berkus
/
kdl-rs
mirror of https://github.com/kdl-org/kdl-rs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

more stuff

This commit is contained in:
Kat Marchán 2020-12-18 20:46:52 -08:00
parent a032a9ec86
commit b4d3f07d09
No known key found for this signature in database
GPG Key ID: AEB529C08A3C7E9E
3 changed files with 389 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/lib.rs
View File

@ -2,7 +2,7 @@ use nom::combinator::all_consuming;
use nom::Finish; use nom::Finish;
pub use crate::error::{KdlError, KdlErrorKind, TryFromKdlNodeValueError}; pub use crate::error::{KdlError, KdlErrorKind, TryFromKdlNodeValueError};
pub use crate::node::{KdlNode, KdlNodeValue}; pub use crate::node::{KdlNode, KdlValue};
mod error; mod error;
mod node; mod node;

92
src/node.rs
View File

@ -5,13 +5,13 @@ use crate::TryFromKdlNodeValueError;
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub struct KdlNode { pub struct KdlNode {
pub name: String, pub name: String,
pub values: Vec<KdlNodeValue>, pub values: Vec<KdlValue>,
pub properties: HashMap<String, KdlNodeValue>, pub properties: HashMap<String, KdlValue>,
pub children: Vec<KdlNode>, pub children: Vec<KdlNode>,
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum KdlNodeValue { pub enum KdlValue {
Int(i64), Int(i64),
Float(f64), Float(f64),
String(String), String(String),
@ -21,42 +21,42 @@ pub enum KdlNodeValue {
// Support conversions from base types into KdlNodeValue // Support conversions from base types into KdlNodeValue
impl From<i64> for KdlNodeValue { impl From<i64> for KdlValue {
fn from(v: i64) -> Self { fn from(v: i64) -> Self {
Self::Int(v) Self::Int(v)
} }
} }
impl From<f64> for KdlNodeValue { impl From<f64> for KdlValue {
fn from(v: f64) -> Self { fn from(v: f64) -> Self {
Self::Float(v) Self::Float(v)
} }
} }
impl From<String> for KdlNodeValue { impl From<String> for KdlValue {
fn from(v: String) -> Self { fn from(v: String) -> Self {
Self::String(v) Self::String(v)
} }
} }
impl From<&str> for KdlNodeValue { impl From<&str> for KdlValue {
fn from(v: &str) -> Self { fn from(v: &str) -> Self {
Self::String(v.to_owned()) Self::String(v.to_owned())
} }
} }
impl From<bool> for KdlNodeValue { impl From<bool> for KdlValue {
fn from(v: bool) -> Self { fn from(v: bool) -> Self {
Self::Boolean(v) Self::Boolean(v)
} }
} }
impl<T> From<Option<T>> for KdlNodeValue impl<T> From<Option<T>> for KdlValue
where where
T: Into<KdlNodeValue>, T: Into<KdlValue>,
{ {
fn from(v: Option<T>) -> Self { fn from(v: Option<T>) -> Self {
v.map_or(KdlNodeValue::Null, |v| v.into()) v.map_or(KdlValue::Null, |v| v.into())
} }
} }
@ -74,11 +74,11 @@ macro_rules! impl_try_from {
fn try_from(value: $source) -> Result<Self, Self::Error> { fn try_from(value: $source) -> Result<Self, Self::Error> {
match value { match value {
$( $good => Ok($value), )+ $( $good => Ok($value), )+
$( KdlNodeValue::$bad(_) => Err(TryFromKdlNodeValueError { $( KdlValue::$bad(_) => Err(TryFromKdlNodeValueError {
expected: stringify!($typ), expected: stringify!($typ),
variant: stringify!($bad) variant: stringify!($bad)
}), )+ }), )+
KdlNodeValue::Null => Err(TryFromKdlNodeValueError { KdlValue::Null => Err(TryFromKdlNodeValueError {
expected: stringify!($typ), expected: stringify!($typ),
variant: "Null" variant: "Null"
}), }),
@ -90,31 +90,31 @@ macro_rules! impl_try_from {
fn try_from(value: $source) -> Result<Self, Self::Error> { fn try_from(value: $source) -> Result<Self, Self::Error> {
match value { match value {
$( $good => Ok(Some($value)), )+ $( $good => Ok(Some($value)), )+
$( KdlNodeValue::$bad(_) => Err(TryFromKdlNodeValueError { $( KdlValue::$bad(_) => Err(TryFromKdlNodeValueError {
expected: concat!("Option::<", stringify!($typ), ">"), expected: concat!("Option::<", stringify!($typ), ">"),
variant: stringify!($bad) variant: stringify!($bad)
}), )+ }), )+
KdlNodeValue::Null => Ok(None), KdlValue::Null => Ok(None),
} }
} }
} }
}; };
(& $($lt:lifetime)?, $typ:ty, $($tt:tt)*) => { (& $($lt:lifetime)?, $typ:ty, $($tt:tt)*) => {
impl_try_from!(<$($lt)?> & $($lt)? KdlNodeValue => $typ, $($tt)*); impl_try_from!(<$($lt)?> & $($lt)? KdlValue => $typ, $($tt)*);
}; };
($typ:ty, $($tt:tt)*) => { ($typ:ty, $($tt:tt)*) => {
impl_try_from!(<> KdlNodeValue => $typ, $($tt)*); impl_try_from!(<> KdlValue => $typ, $($tt)*);
}; };
} }
impl_try_from!(i64, KdlNodeValue::Int(v) => v; Float, String, Boolean); impl_try_from!(i64, KdlValue::Int(v) => v; Float, String, Boolean);
impl_try_from!(&, i64, KdlNodeValue::Int(v) => *v; Float, String, Boolean); impl_try_from!(&, i64, KdlValue::Int(v) => *v; Float, String, Boolean);
impl_try_from!(f64, KdlNodeValue::Float(v) => v; Int, String, Boolean); impl_try_from!(f64, KdlValue::Float(v) => v; Int, String, Boolean);
impl_try_from!(&, f64, KdlNodeValue::Float(v) => *v; Int, String, Boolean); impl_try_from!(&, f64, KdlValue::Float(v) => *v; Int, String, Boolean);
impl_try_from!(String, KdlNodeValue::String(v) => v; Int, Float, Boolean); impl_try_from!(String, KdlValue::String(v) => v; Int, Float, Boolean);
impl_try_from!(&'a, &'a str, KdlNodeValue::String(v) => &v[..]; Int, Float, Boolean); impl_try_from!(&'a, &'a str, KdlValue::String(v) => &v[..]; Int, Float, Boolean);
impl_try_from!(bool, KdlNodeValue::Boolean(v) => v; Int, Float, String); impl_try_from!(bool, KdlValue::Boolean(v) => v; Int, Float, String);
impl_try_from!(&, bool, KdlNodeValue::Boolean(v) => *v; Int, Float, String); impl_try_from!(&, bool, KdlValue::Boolean(v) => *v; Int, Float, String);
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
@ -122,41 +122,41 @@ mod tests {
#[test] #[test]
fn from() { fn from() {
assert_eq!(KdlNodeValue::from(1), KdlNodeValue::Int(1)); assert_eq!(KdlValue::from(1), KdlValue::Int(1));
assert_eq!(KdlNodeValue::from(1.5), KdlNodeValue::Float(1.5)); assert_eq!(KdlValue::from(1.5), KdlValue::Float(1.5));
assert_eq!( assert_eq!(
KdlNodeValue::from("foo".to_owned()), KdlValue::from("foo".to_owned()),
KdlNodeValue::String("foo".to_owned()) KdlValue::String("foo".to_owned())
); );
assert_eq!( assert_eq!(
KdlNodeValue::from("bar"), KdlValue::from("bar"),
KdlNodeValue::String("bar".to_owned()) KdlValue::String("bar".to_owned())
); );
assert_eq!(KdlNodeValue::from(true), KdlNodeValue::Boolean(true)); assert_eq!(KdlValue::from(true), KdlValue::Boolean(true));
assert_eq!(KdlNodeValue::from(None::<i64>), KdlNodeValue::Null); assert_eq!(KdlValue::from(None::<i64>), KdlValue::Null);
assert_eq!(KdlNodeValue::from(Some(1)), KdlNodeValue::Int(1)); assert_eq!(KdlValue::from(Some(1)), KdlValue::Int(1));
} }
#[test] #[test]
fn try_from_success() { fn try_from_success() {
assert_eq!(i64::try_from(KdlNodeValue::Int(1)), Ok(1)); assert_eq!(i64::try_from(KdlValue::Int(1)), Ok(1));
assert_eq!(i64::try_from(&KdlNodeValue::Int(1)), Ok(1)); assert_eq!(i64::try_from(&KdlValue::Int(1)), Ok(1));
assert_eq!(f64::try_from(KdlNodeValue::Float(1.5)), Ok(1.5)); assert_eq!(f64::try_from(KdlValue::Float(1.5)), Ok(1.5));
assert_eq!(f64::try_from(&KdlNodeValue::Float(1.5)), Ok(1.5)); assert_eq!(f64::try_from(&KdlValue::Float(1.5)), Ok(1.5));
assert_eq!( assert_eq!(
String::try_from(KdlNodeValue::String("foo".to_owned())), String::try_from(KdlValue::String("foo".to_owned())),
Ok("foo".to_owned()) Ok("foo".to_owned())
); );
assert_eq!( assert_eq!(
<&str as TryFrom<_>>::try_from(&KdlNodeValue::String("foo".to_owned())), <&str as TryFrom<_>>::try_from(&KdlValue::String("foo".to_owned())),
Ok("foo") Ok("foo")
); );
assert_eq!(bool::try_from(KdlNodeValue::Boolean(true)), Ok(true)); assert_eq!(bool::try_from(KdlValue::Boolean(true)), Ok(true));
assert_eq!(bool::try_from(&KdlNodeValue::Boolean(true)), Ok(true)); assert_eq!(bool::try_from(&KdlValue::Boolean(true)), Ok(true));
assert_eq!(Option::<i64>::try_from(KdlNodeValue::Int(1)), Ok(Some(1))); assert_eq!(Option::<i64>::try_from(KdlValue::Int(1)), Ok(Some(1)));
assert_eq!(Option::<i64>::try_from(KdlNodeValue::Null), Ok(None)); assert_eq!(Option::<i64>::try_from(KdlValue::Null), Ok(None));
} }
#[test] #[test]
@ -164,13 +164,13 @@ mod tests {
// We don't expose the internal format of the error type, so let's just test the message // We don't expose the internal format of the error type, so let's just test the message
// for a couple of cases. // for a couple of cases.
assert_eq!( assert_eq!(
format!("{}", i64::try_from(KdlNodeValue::Float(1.5)).unwrap_err()), format!("{}", i64::try_from(KdlValue::Float(1.5)).unwrap_err()),
"Failed to convert from KdlNodeValue::Float to i64." "Failed to convert from KdlNodeValue::Float to i64."
); );
assert_eq!( assert_eq!(
format!( format!(
"{}", "{}",
Option::<i64>::try_from(KdlNodeValue::Float(1.5)).unwrap_err() Option::<i64>::try_from(KdlValue::Float(1.5)).unwrap_err()
), ),
"Failed to convert from KdlNodeValue::Float to Option::<i64>." "Failed to convert from KdlNodeValue::Float to Option::<i64>."
); );

440
src/parser.rs
View File

@ -12,7 +12,7 @@ use nom::Finish;
use nom::IResult; use nom::IResult;
use crate::error::KdlParseError; use crate::error::KdlParseError;
use crate::node::{KdlNode, KdlNodeValue}; use crate::node::{KdlNode, KdlValue};
/// `nodes := linespace* node* linespace*` /// `nodes := linespace* node* linespace*`
pub(crate) fn nodes(input: &str) -> IResult<&str, Vec<KdlNode>, KdlParseError<&str>> { pub(crate) fn nodes(input: &str) -> IResult<&str, Vec<KdlNode>, KdlParseError<&str>> {
@ -65,8 +65,8 @@ pub(crate) fn strip_trailing_newline(input: &str) -> &str {
#[derive(Clone)] #[derive(Clone)]
enum NodeArg { enum NodeArg {
Value(KdlNodeValue), Value(KdlValue),
Property(String, KdlNodeValue), Property(String, KdlValue),
} }
/// `node := ('/-' ws*)? identifier (node-space node-props-and-args)* node-space* (node-terminator | node-children)` /// `node := ('/-' ws*)? identifier (node-space node-props-and-args)* node-space* (node-terminator | node-children)`
@ -75,10 +75,7 @@ pub(crate) fn node(input: &str) -> IResult<&str, Option<KdlNode>, KdlParseError<
let (input, tag) = identifier(input)?; let (input, tag) = identifier(input)?;
let (input, args) = many0(preceded(node_space, node_prop_or_arg))(input)?; let (input, args) = many0(preceded(node_space, node_prop_or_arg))(input)?;
let (input, _) = many0(node_space)(input)?; let (input, _) = many0(node_space)(input)?;
let (input, children) = alt(( let (input, children) = alt((value(Vec::new(), node_terminator), node_children))(input)?;
value(Vec::new(), node_terminator),
node_children,
))(input)?;
if comment.is_some() { if comment.is_some() {
Ok((input, None)) Ok((input, None))
} else { } else {
@ -141,7 +138,7 @@ fn node_prop_or_arg(input: &str) -> IResult<&str, Option<NodeArg>, KdlParseError
} }
/// `prop := identifier '=' value` /// `prop := identifier '=' value`
fn property(input: &str) -> IResult<&str, (String, KdlNodeValue), KdlParseError<&str>> { fn property(input: &str) -> IResult<&str, (String, KdlValue), KdlParseError<&str>> {
let (input, key) = identifier(input)?; let (input, key) = identifier(input)?;
let (input, _) = tag("=")(input)?; let (input, _) = tag("=")(input)?;
let (input, val) = node_value(input)?; let (input, val) = node_value(input)?;
@ -149,19 +146,24 @@ fn property(input: &str) -> IResult<&str, (String, KdlNodeValue), KdlParseError<
} }
/// `value := string | raw_string | number | boolean | 'null'` /// `value := string | raw_string | number | boolean | 'null'`
fn node_value(input: &str) -> IResult<&str, KdlNodeValue, KdlParseError<&str>> { fn node_value(input: &str) -> IResult<&str, KdlValue, KdlParseError<&str>> {
alt(( alt((
map(string, KdlNodeValue::String), map(string, KdlValue::String),
map(raw_string, |s| KdlNodeValue::String(s.into())), map(raw_string, |s| KdlValue::String(s.into())),
number, number,
boolean, boolean,
value(KdlNodeValue::Null, tag("null")), value(KdlValue::Null, tag("null")),
))(input) ))(input)
} }
/// node-terminator := single-line-comment | newline | ';' | eof /// node-terminator := single-line-comment | newline | ';' | eof
fn node_terminator(input: &str) -> IResult<&str, (), KdlParseError<&str>> { fn node_terminator(input: &str) -> IResult<&str, (), KdlParseError<&str>> {
alt((value((), eof), single_line_comment, newline, value((), char(';'))))(input) alt((
value((), eof),
single_line_comment,
newline,
value((), char(';')),
))(input)
} }
/// `node-children := ('/-' ws*)? '{' nodes '}'` /// `node-children := ('/-' ws*)? '{' nodes '}'`
@ -231,13 +233,13 @@ fn raw_string(input: &str) -> IResult<&str, &str, KdlParseError<&str>> {
} }
/// `number := decimal | hex | octal | binary` /// `number := decimal | hex | octal | binary`
fn number(input: &str) -> IResult<&str, KdlNodeValue, KdlParseError<&str>> { fn number(input: &str) -> IResult<&str, KdlValue, KdlParseError<&str>> {
alt(( alt((
map(integer, KdlNodeValue::Int), map(integer, KdlValue::Int),
map(hexadecimal, KdlNodeValue::Int), map(hexadecimal, KdlValue::Int),
map(octal, KdlNodeValue::Int), map(octal, KdlValue::Int),
map(binary, KdlNodeValue::Int), map(binary, KdlValue::Int),
map(float, KdlNodeValue::Float), map(float, KdlValue::Float),
))(input) ))(input)
} }
@ -325,10 +327,10 @@ fn binary(input: &str) -> IResult<&str, i64, KdlParseError<&str>> {
} }
/// `boolean := 'true' | 'false'` /// `boolean := 'true' | 'false'`
fn boolean(input: &str) -> IResult<&str, KdlNodeValue, KdlParseError<&str>> { fn boolean(input: &str) -> IResult<&str, KdlValue, KdlParseError<&str>> {
alt(( alt((
value(KdlNodeValue::Boolean(true), tag("true")), value(KdlValue::Boolean(true), tag("true")),
value(KdlNodeValue::Boolean(false), tag("false")), value(KdlValue::Boolean(false), tag("false")),
))(input) ))(input)
} }
@ -387,6 +389,173 @@ fn newline(input: &str) -> IResult<&str, (), KdlParseError<&str>> {
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn test_nodes() {
assert_eq!(
nodes("node"),
Ok((
"",
vec![KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
}]
))
);
assert_eq!(
nodes("node\n"),
Ok((
"",
vec![KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
}]
))
);
assert_eq!(
nodes("\nnode\n"),
Ok((
"",
vec![KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
}]
))
);
assert_eq!(
nodes("node1\nnode2"),
Ok((
"",
vec![
KdlNode {
name: "node1".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
},
KdlNode {
name: "node2".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
}
]
))
);
}
#[test]
fn test_node() {
assert_eq!(
node("node"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node\n"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node;"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node 1"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: vec![KdlValue::Int(1)],
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node 1 2 \"3\" true false null"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: vec![
KdlValue::Int(1),
KdlValue::Int(2),
KdlValue::String("3".into()),
KdlValue::Boolean(true),
KdlValue::Boolean(false),
KdlValue::Null
],
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node {\n node2\n}"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: vec![KdlNode {
name: "node2".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new()
}]
})
))
);
assert_eq!(
node("node { node2; }"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: vec![KdlNode {
name: "node2".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new()
}]
})
))
);
}
#[test] #[test]
fn test_node_slashdash_comment() { fn test_node_slashdash_comment() {
assert_eq!(node("/-node"), Ok(("", None))); assert_eq!(node("/-node"), Ok(("", None)));
@ -395,93 +564,168 @@ mod tests {
assert_eq!(node("/-node 1 2 3"), Ok(("", None))); assert_eq!(node("/-node 1 2 3"), Ok(("", None)));
assert_eq!(node("/-node key=false"), Ok(("", None))); assert_eq!(node("/-node key=false"), Ok(("", None)));
assert_eq!(node("/-node{\nnode\n}"), Ok(("", None))); assert_eq!(node("/-node{\nnode\n}"), Ok(("", None)));
assert_eq!(node("/-node 1 2 3 key=\"value\" \\\n{\nnode\n}"), Ok(("", None))); assert_eq!(
node("/-node 1 2 3 key=\"value\" \\\n{\nnode\n}"),
Ok(("", None))
);
} }
#[test] #[test]
fn test_arg_slashdash_comment() { fn test_arg_slashdash_comment() {
assert_eq!(node("node /-1"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /-1"),
values: Vec::new(), Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
assert_eq!(node("node /-1 2"), Ok(("", Some(KdlNode { values: Vec::new(),
name: "node".into(), properties: HashMap::new(),
values: vec![KdlNodeValue::Int(2)], children: Vec::new(),
properties: HashMap::new(), })
children: Vec::new(), ))
})))); );
assert_eq!(node("node 1 /- 2 3"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /-1 2"),
values: vec![KdlNodeValue::Int(1), KdlNodeValue::Int(3)], Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
assert_eq!(node("node /--1"), Ok(("", Some(KdlNode { values: vec![KdlValue::Int(2)],
name: "node".into(), properties: HashMap::new(),
values: Vec::new(), children: Vec::new(),
properties: HashMap::new(), })
children: Vec::new(), ))
})))); );
assert_eq!(node("node /- -1"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node 1 /- 2 3"),
values: Vec::new(), Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
assert_eq!(node("node \\\n/- -1"), Ok(("", Some(KdlNode { values: vec![KdlValue::Int(1), KdlValue::Int(3)],
name: "node".into(), properties: HashMap::new(),
values: Vec::new(), children: Vec::new(),
properties: HashMap::new(), })
children: Vec::new(), ))
})))); );
assert_eq!(
node("node /--1"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node /- -1"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node \\\n/- -1"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
} }
#[test] #[test]
fn test_prop_slashdash_comment() { fn test_prop_slashdash_comment() {
let mut properties = HashMap::new(); let mut properties = HashMap::new();
properties.insert("key".to_owned(), KdlNodeValue::Int(1)); properties.insert("key".to_owned(), KdlValue::Int(1));
assert_eq!(node("node /-key=1"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /-key=1"),
values: Vec::new(), Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
assert_eq!(node("node /- key=1"), Ok(("", Some(KdlNode { values: Vec::new(),
name: "node".into(), properties: HashMap::new(),
values: Vec::new(), children: Vec::new(),
properties: HashMap::new(), })
children: Vec::new(), ))
})))); );
assert_eq!(node("node key=1 /-key2=2"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /- key=1"),
values: Vec::new(), Ok((
properties, "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node key=1 /-key2=2"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties,
children: Vec::new(),
})
))
);
} }
#[test] #[test]
fn test_children_slashdash_comment() { fn test_children_slashdash_comment() {
assert_eq!(node("node /-{}"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /-{}"),
values: Vec::new(), Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
assert_eq!(node("node /- {}"), Ok(("", Some(KdlNode { values: Vec::new(),
name: "node".into(), properties: HashMap::new(),
values: Vec::new(), children: Vec::new(),
properties: HashMap::new(), })
children: Vec::new(), ))
})))); );
assert_eq!(node("node /-{\nnode2\n}"), Ok(("", Some(KdlNode { assert_eq!(
name: "node".into(), node("node /- {}"),
values: Vec::new(), Ok((
properties: HashMap::new(), "",
children: Vec::new(), Some(KdlNode {
})))); name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
assert_eq!(
node("node /-{\nnode2\n}"),
Ok((
"",
Some(KdlNode {
name: "node".into(),
values: Vec::new(),
properties: HashMap::new(),
children: Vec::new(),
})
))
);
} }
#[test] #[test]
@ -583,8 +827,8 @@ mod tests {
#[test] #[test]
fn test_boolean() { fn test_boolean() {
assert_eq!(boolean("true"), Ok(("", KdlNodeValue::Boolean(true)))); assert_eq!(boolean("true"), Ok(("", KdlValue::Boolean(true))));
assert_eq!(boolean("false"), Ok(("", KdlNodeValue::Boolean(false)))); assert_eq!(boolean("false"), Ok(("", KdlValue::Boolean(false))));
assert!(boolean("blah").is_err()); assert!(boolean("blah").is_err());
} }