1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#![doc = concat!(
    include_str!("../README.md"),
    "# What is Preserves Schema?\n\n",
    include_str!("../doc/what-is-preserves-schema.md"),
    include_str!("../doc/example.md"),
)]

pub mod compiler;
/// Auto-generated Preserves Schema Metaschema types, parsers, and unparsers.
pub mod gen;
pub mod support;
pub mod syntax;

pub use support::Codec;
pub use support::Deserialize;
pub use support::ParseError;

#[cfg(test)]
mod tests {
    #[test]
    fn can_access_preserves_core() {
        use preserves::value::*;
        assert_eq!(format!("{:?}", UnwrappedIOValue::from(3 + 4)), "7");
    }

    #[test]
    fn simple_rendering() {
        use crate::syntax::block::*;
        use crate::*;

        let code = semiblock![
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["g", parens![]],
            parens![]
        ];
        println!("{}", Formatter::to_string(&code));
    }

    #[test]
    fn metaschema_parsing() -> Result<(), std::io::Error> {
        use crate::gen::schema::*;
        use crate::support::Parse;
        use crate::support::Unparse;
        use preserves::value::{BinarySource, IOBinarySource, Reader};

        let mut f = std::fs::File::open("./schema.bin")?;
        let mut src = IOBinarySource::new(&mut f);
        let mut reader = src.packed_iovalues();
        let schema = reader.demand_next(false)?;
        let language = crate::gen::Language::default();
        let parsed = Schema::parse(&language, &schema).expect("successful parse");
        assert_eq!(schema, parsed.unparse(&language));
        Ok(())
    }
}

#[macro_export]
macro_rules! define_language {
    ($fname:ident () : $lang:ident < $default_value:ty > { $($field:ident : $($type:ident)::+ ,)* }) => {
        pub struct $lang<N: $crate::support::preserves::value::NestedValue> {
            $(pub $field: std::sync::Arc<$($type)::*<N>>),*
        }

        $(impl<'a, N: $crate::support::preserves::value::NestedValue> From<&'a $lang<N>> for &'a $($type)::*<N> {
            fn from(v: &'a $lang<N>) -> Self {
                &v.$field
            }
        })*

        impl<N: $crate::support::preserves::value::NestedValue> $crate::support::NestedValueCodec
            for $lang<N> {}

        mod $fname {
            use super::*;
            lazy_static::lazy_static! {
                pub static ref GLOBAL_LANG: std::sync::Arc<$lang<$default_value>> =
                    std::sync::Arc::new($lang {
                        $($field: std::sync::Arc::new($($type)::*::default())),*
                    });
            }
        }

        impl $lang<$default_value> {
            pub fn arc() -> &'static std::sync::Arc<$lang<$default_value>> {
                &*$fname::GLOBAL_LANG
            }
        }

        pub fn $fname() -> &'static $lang<$default_value> {
            &*$fname::GLOBAL_LANG
        }
    };
}