#![warn(
    elided_lifetimes_in_paths,
    explicit_outlives_requirements,
    missing_debug_implementations,
    noop_method_call,
    single_use_lifetimes,
    trivial_casts,
    trivial_numeric_casts,
    unreachable_pub,
    unsafe_code,
    unused_qualifications
)]
#![warn(clippy::pedantic)]

#![doc = include_str!("../README.md")]
#![warn(
    elided_lifetimes_in_paths,
    explicit_outlives_requirements,
    missing_debug_implementations,
    missing_docs,
    noop_method_call,
    single_use_lifetimes,
    trivial_casts,
    trivial_numeric_casts,
    unreachable_pub,
    unsafe_code,
    unused_crate_dependencies,
    unused_qualifications
)]
#![warn(clippy::pedantic, clippy::cargo)]

/// a document as parsed by knuffel

/// a schema validation failure

    /// an I/O failure while reading the document

    /// a parse error while parsing the document

    /// a validation error while checking the document against the schema

    /// a validation error while checking the document against the schema,
    /// with more information for better reporting

        /// the raw text of the document

        /// what happened in validation

/// allow a [Schema] to check a document for validity

    /// check if the file at the given path matches this schema
    ///
    /// # Errors
    ///
    /// returns an error on IO failure, parsing failure, or validation failure

    /// check if the given document matches this schema
    ///
    /// document name is used for error reporting by both the knuffel parser and this crate
    ///
    /// # Errors
    ///
    /// returns an error on parsing failure or validation failure

    /// check if the given already-parsed document matches this schema
    ///
    /// # Errors
    ///
    /// returns an error on validation failure

        check::check(document_ast, self)?;

        check::check(&document_ast, self)?;

#[allow(clippy::module_name_repetitions)]

pub type Result<T = ()> = std::result::Result<T, CheckFailure>;

type Result<T = ()> = std::result::Result<T, CheckFailure>;

pub(crate) fn check(document: DocumentAst, schema: &Schema) -> Result {

pub(crate) fn check(document: &DocumentAst, schema: &Schema) -> Result {

                None => format!("nodes"),

                None => "nodes".to_string(),

    if values.len() == 0 && values_schemas.len() == 0 {

    if values.is_empty() && values_schemas.is_empty() {

        format!("values")

        "values".to_string()

fn get_string_value(value: &Value) -> Result<&Box<str>> {

fn get_string_value(value: &Value) -> Result<&str> {

# kdl-schema-check
[KDL Schema](https://github.com/kdl-org/kdl/blob/1.0.0/SCHEMA-SPEC.md) document validation.
## examples
Library usage:
```rust
use kdl_schema::Schema;
use kdl_schema_check::CheckExt;
let schema_kdl = r#"
document {
    info {
        title "Sample Schema" lang="en"
        description "An example schema" lang="en"
        author "boringcactus"
    }
    node "name" {
        value {
            type "string"
        }
    }
    node "age" {
        value {
            type "number"
        }
    }
}
"#;
let schema = Schema::parse(schema_kdl).unwrap();
let document = r#"
name "Joe"
age 69
"#;
schema.check_text_matches("<sample document>", document)
    .expect("document validation failed");
```
Binary usage:
```text
$ cargo install kdl-schema-check
$ kdl-schema-check schema.kdl document.kdl
Validation succeeded!
```
## conditions blocking version 1.0.0
- return more than one error
- kdl-schema is at 1.0.0
- comprehensive tests for error reporting
- no TODOs left in code
## license
[Blue Oak Model License 1.0.0](https://blueoakcouncil.org/license/1.0.0).

authors = ["boringcactus / Melody Horn"]

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

description = "schema-based document verification for KDL"
repository = "https://nest.pijul.com/boringcactus/kdl-schema-check"
license = "BlueOak-1.0.0"
keywords = ["kdl"]
categories = ["command-line-utilities"]