Descendant selectors

Author: glyn

src/ast.rs

@@ -54,6 +54,9 @@ pub enum Selector {
     Union(Vec<UnionElement>),
     DotName(String),
     DotWildcard,
+    DescendantDotName(String),
+    DescendantDotWildcard,
+    DescendantUnionElement(UnionElement),
 }
 
 #[derive(Debug)]
@@ -85,6 +88,20 @@ impl Selector {
                 Value::Array(a) => Box::new(a.iter()),
                 _ => Box::new(std::iter::empty()),
             },
+            Selector::DescendantDotName(name) => Self::traverse(input, move |n: &'a Value| Box::new(n.get(name).into_iter())),
+            Selector::DescendantDotWildcard => Self::traverse(input, move |n: &'a Value| Box::new(iter::once(n))),
+            Selector::DescendantUnionElement(element) => Self::traverse(input, move |n: &'a Value| element.find(n)),
+        }
+    }
+
+    // traverse applies the given closure to all the descendants of the input value and
+    // returns a nodelist.
+    fn traverse<'a, F>(input: &'a Value, f: F) -> NodeList<'a>
+    where F: Fn(&'a Value) -> NodeList<'a> + Copy + 'a {
+        match input {
+            Value::Object(m) => Box::new(m.into_iter().flat_map(move |(_k, v)| (&f)(v).chain(Self::traverse::<'a>(v, f)))),
+            Value::Array(a) => Box::new(a.iter().flat_map(move |v| (&f)(v).chain(Self::traverse::<'a>(v, f)))),
+            _ => Box::new(std::iter::empty()),
         }
     }
 }

src/grammar.pest

@@ -3,7 +3,7 @@ selector = ${ SOI ~ rootSelector ~ matchers ~ EOI }
 matchers = ${ matcher* }
 rootSelector = @{ "$" }
 
-matcher = !{ dotChild | union }
+matcher = !{ dotChild | union | descendant }
 
 dotChild = _{ wildcardedDotChild | namedDotChild }
 wildcardedDotChild = { ".*" }
@@ -27,6 +27,10 @@ sliceStart = @{ integer }
 sliceEnd = @{ integer }
 sliceStep = @{ integer }
 
+descendant = ${ ".." ~ descendantVariant }
+descendantVariant = _{ childName | wildcard | "[" ~ unionElement ~ "]" }
+wildcard = { "*" }
+
 doubleQuotedString = _{ "\"" ~ doubleInner ~ "\"" }
 doubleInner = @{ doubleChar* }
 doubleChar = {

src/parser.rs

@@ -40,6 +40,7 @@ fn parse_selector(matcher_rule: pest::iterators::Pair<Rule>) -> Result<Selector,
         Rule::wildcardedDotChild => Selector::DotWildcard,
         Rule::namedDotChild => Selector::DotName(parse_child_name(r)),
         Rule::union => Selector::Union(parse_union_indices(r)?),
+        Rule::descendant => parse_descendant(r)?, 
         _ => panic!("invalid parse tree {:?}", r),
     })
 }
@@ -115,6 +116,19 @@ fn parse_union_array_slice(
     }))
 }
 
+fn parse_descendant(matcher_rule: pest::iterators::Pair<Rule>) -> Result<Selector, ParseIntError> {
+    let r = matcher_rule.into_inner().next().unwrap();
+
+    Ok(match r.as_rule() {
+        Rule::childName => Selector::DescendantDotName(r.as_str().to_owned()),
+        Rule::wildcard => Selector::DescendantDotWildcard,
+        Rule::unionChild => Selector::DescendantUnionElement(parse_union_child(r)),
+        Rule::unionArraySlice => Selector::DescendantUnionElement(parse_union_array_slice(r)?),
+        Rule::unionArrayIndex => Selector::DescendantUnionElement(parse_union_array_index(r)?),
+        _ => panic!("invalid descendant {:?}", r),
+    })
+}
+
 fn unescape(contents: &str) -> String {
     let s = format!(r#""{}""#, contents);
     serde_json::from_str(&s).unwrap()

tests/cts.rs

@@ -90,10 +90,13 @@ mod tests {
                         assert!(false, "find failed") // should not happen
                     }
                 } else {
-                    if !t.invalid_selector {
+                    if t.invalid_selector {
+                        // print failure message
+                        println!("{}: parsing `{}` failed with: {}", t.name, t.selector, path.err().expect("should be an error"));
+                    } else {
                         assert!(
                             path.is_ok(),
-                            "{}: parsing {} should have succeeded but failed: {}",
+                            "{}: parsing `{}` should have succeeded but failed: {}",
                             t.name,
                             t.selector,
                             path.err().expect("should be an error")