wildcarded dot child

Author: glyn

src/grammar.pest

@@ -5,6 +5,7 @@ rootSelector = { "$" }
 
 matcher = { dotChild }
 
-dotChild = { ".*" }
+dotChild = _{ wildcardedDotChild }
+wildcardedDotChild = { ".*" }
 
 WHITESPACE = _{ " " }

src/matchers.rs

@@ -5,7 +5,7 @@
  */
 
 use serde_json::Value;
-use std::iter::once;
+use std::iter;
 
 // Matcher maps a node to a list of nodes. If the input node is not matched by the matcher or
 // the matcher does not select any subnodes of the input node, then the result is empty.
@@ -17,6 +17,18 @@ pub struct RootSelector {}
 
 impl Matcher for RootSelector {
     fn select<'a>(&self, node: &'a Value) -> Box<dyn Iterator<Item = &'a Value> + 'a> {
-        Box::new(once(node))
+        Box::new(iter::once(node))
+    }
+}
+
+pub struct WildcardedChild {}
+
+impl Matcher for WildcardedChild {
+    fn select<'a>(&self, node: &'a Value) -> Box<dyn Iterator<Item = &'a Value> + 'a> {
+        if node.is_object() {
+            Box::new(node.as_object().unwrap().into_iter().map(|(_k, v)| v))
+        } else {
+            Box::new(iter::empty())
+        }
     }
 }

src/parser.rs

@@ -12,7 +12,6 @@ use crate::pest::Parser;
 #[grammar = "grammar.pest"]
 struct PathParser;
 
-#[allow(clippy::single_match)]
 pub fn parse(selector: &str) -> Result<Box<dyn path::Path>, String> {
     let selector_rule = PathParser::parse(Rule::selector, selector)
         .map_err(|e| format!("{}", e))?
@@ -22,12 +21,19 @@ pub fn parse(selector: &str) -> Result<Box<dyn path::Path>, String> {
     let mut ms: Vec<&dyn matchers::Matcher> = Vec::new();
     for r in selector_rule.into_inner() {
         match r.as_rule() {
-            Rule::rootSelector => {
-                ms.push(&matchers::RootSelector {});
-            }
+            Rule::rootSelector => ms.push(&matchers::RootSelector {}),
+            Rule::matcher => parse_matcher(r, &mut ms),
             _ => println!("r={:?}", r),
         }
     }
 
     Ok(Box::new(path::new(ms)))
 }
+
+fn parse_matcher(matcher_rule: pest::iterators::Pair<Rule>, ms: &mut Vec<&dyn matchers::Matcher>) {
+    for r in matcher_rule.into_inner() {
+        if let Rule::wildcardedDotChild = r.as_rule() {
+            ms.push(&matchers::WildcardedChild {});
+        }
+    }
+}

tests/cts.rs

@@ -62,7 +62,8 @@ mod tests {
                         ) {
                             assert!(
                                 false,
-                                "incorrect result, expected: {:?}, got: {:?}",
+                                "incorrect result for {}, expected: {:?}, got: {:?}",
+                                t.name,
                                 as_json_value_array(&t.result).unwrap(),
                                 result
                             )
@@ -140,8 +141,14 @@ mod tests {
 
             serde_yaml::Value::Mapping(map) => {
                 let object_members = map.iter().map(|(k, v)| {
+                    println!(
+                        ">>>>>>>>> k={:?}, v={:?}, serde_json::to_string(k)={:?}",
+                        k,
+                        v,
+                        serde_json::to_string(k).expect("bananas")
+                    );
                     (
-                        serde_yaml::to_string(k).expect("non-string mapping key"),
+                        serde_json::to_string(k).expect("non-string mapping key"),
                         as_json_value(v.clone()).expect("invalid map value"),
                     )
                 });

tests/cts.yaml

@@ -3,3 +3,7 @@ tests:
       selector: "$"
       document: ["first", "second"]
       result: [["first", "second"]]
+    - name: wildcarded_child
+      selector: "$.*"
+      document: {"a" : "A", "b" : "B"}
+      result: ["A", "B"]