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 99 100 101 102 103 104 105 106 107 108 109 110 111 112
//! A YAML 1.2 parser using greedy parsing algorithm with PEG atoms. //! //! The major purpose of this crate is to let the user build their own YAML reader / builder / validator. //! //! This parser is not ensure about YAML spec but almost functions are well-implemented. //! (test case is [here](https://github.com/KmolYuan/yaml-peg-rs/blob/main/src/tests/test.yaml)) //! //! The buffer reader has also not implemented, but the chunks can be read by sub-parsers. //! //! Function [`parse`] is used to parse YAML string into [`Node`] data structure. //! To get back as string, please use [`dump`] function. //! //! There are also have some macros for building [`Node`] structure from Rust data. //! Especially [`node!`] macro, almost data can be built by the macro literally. //! //! If you went to rise your own error message, [`indicated_msg`] might be a good choice. //! //! Please be aware that the anchor system must be done by your self to prevent recursive problem. //! This crate is only store the anchor information in [`Yaml::Anchor`] and [`Node::anchor`]. //! A reference counter system maybe the best choice. pub use crate::dumper::dump; pub use crate::indicator::*; pub use crate::node::*; pub use crate::parser::parse; pub use crate::yaml::*; /// Create [`Node`] items literally. /// /// Literals and expressions will be transformed to [`Yaml`] automatically by calling [`Into::into`]. /// /// ``` /// use yaml_peg::node; /// let k = "a"; /// assert_eq!(node!(k), node!("a")); /// ``` /// /// The members are ordered as `node!(yaml, pos, anchor, ty)`. /// /// Arrays and maps can be created from this macro directly through brackets (`[]`, `{}`). /// /// ``` /// use yaml_peg::{node, yaml_array, yaml_map}; /// assert_eq!(node!([node!(1), node!(2)]), node!(yaml_array![node!(1), node!(2)])); /// assert_eq!(node!({node!(1) => node!(2)}), node!(yaml_map![node!(1) => node!(2)])); /// ``` /// /// The [`Yaml::Null`] and the [`Yaml::Null`] are also supported by the syntax: /// /// ``` /// use yaml_peg::{node, Yaml}; /// assert_eq!(node!(Yaml::Null), node!(null)); /// assert_eq!(node!(Yaml::Anchor("x".into())), node!(*("x"))); /// ``` #[macro_export] macro_rules! node { ([$($token:tt)*] $($opt:tt)*) => { $crate::node!($crate::yaml_array![$($token)*] $($opt)*) }; ({$($token:tt)*} $($opt:tt)*) => { $crate::node!($crate::yaml_map![$($token)*] $($opt)*) }; (null $($opt:tt)*) => { $crate::node!($crate::Yaml::Null $($opt)*) }; (*($anchor:expr) $($opt:tt)*) => { $crate::node!($crate::Yaml::Anchor($anchor.into()) $($opt)*) }; ($yaml:expr $(, $pos:expr $(, $anchor:expr $(, $ty:expr)?)?)?) => { $crate::Node::new($yaml.into())$(.pos($pos.into())$(.anchor($anchor.into())$(.ty($ty.into()))?)?)? }; } /// Create [`Yaml::Array`] items literally. /// /// ``` /// use yaml_peg::{node, yaml_array}; /// yaml_array![node!("a"), node!("b"), node!("c")]; /// ``` #[macro_export] macro_rules! yaml_array { ($($token:tt)*) => { $crate::Yaml::Array(vec![$($token)*]) }; } /// Create [`Yaml::Map`] items literally. /// /// ``` /// use yaml_peg::{node, yaml_map}; /// yaml_map!{ /// node!("a") => node!("b"), /// node!("c") => node!("d"), /// }; /// ``` #[macro_export] macro_rules! yaml_map { () => { $crate::Yaml::Map($crate::Map::new()) }; ($k1:expr => $v1:expr $(, $k2:expr => $v2:expr)* $(,)?) => {{ use std::iter::FromIterator; $crate::Yaml::from_iter(vec![($k1, $v1) $(, ($k2, $v2))*]) }}; } pub mod dumper; mod indicator; mod node; pub mod parser; #[cfg(test)] mod tests; mod yaml;