Merge pull request jsonpath-standard#3 from glyn/refactor

Refactor

Author: glyn

src/matchers.rs

@@ -9,13 +9,13 @@ use serde_json::Value;
 // 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.
 pub trait Matcher {
-    fn select(&self, node: Value) -> Vec<Value>;
+    fn select<'a>(&self, node: &'a Value) -> Vec<&'a Value>;
 }
 
 pub struct RootSelector {}
 
 impl Matcher for RootSelector {
-    fn select(&self, node: Value) -> Vec<Value> {
+    fn select<'a>(&self, node: &'a Value) -> Vec<&'a Value> {
         let mut results = Vec::new();
         results.push(node);
         results

src/parser.rs

@@ -38,21 +38,18 @@ pub fn parse(selector: &str) -> Result<Box<dyn Path>, String> {
 }
 
 impl Path for SelectorPath<'_> {
-    fn find(&self, document: Value) -> Result<Vec<Value>, FindError> {
-        let mut nodes = Vec::new();
-        nodes.push(document);
-
-        // pass nodes through each matcher in turn
-        for m in self.matchers.clone().into_iter() {
-            let mut selected = Vec::new();
-            for n in nodes.clone().into_iter() {
-                for r in m.select(n).into_iter() {
-                    selected.push(r);
-                }
-            }
-            nodes = selected;
-        }
-
-        Ok(nodes)
+    fn find<'a>(&self, document: &'a Value) -> Result<Vec<&'a Value>, FindError> {
+        // pass nodes, starting with document alone, through each matcher in turn
+        Ok((&self.matchers)
+            .iter()
+            .fold(doc_node(document), |nodes, matcher| {
+                nodes.iter().flat_map(|node| matcher.select(node)).collect()
+            }))
     }
 }
+
+fn doc_node<'a>(document: &'a Value) -> Vec<&'a Value> {
+    let mut nodes = Vec::new();
+    nodes.push(document);
+    nodes
+}

src/path.rs

@@ -11,5 +11,5 @@ pub enum FindError {
 }
 
 pub trait Path {
-    fn find(&self, document: Value) -> Result<Vec<Value>, FindError>;
+    fn find<'a>(&self, document: &'a Value) -> Result<Vec<&'a Value>, FindError>;
 }

tests/cts.rs

@@ -54,9 +54,12 @@ mod tests {
 
                 if let Ok(p) = path {
                     if let Ok(result) =
-                        p.find(as_json_value(&t.document).expect("invalid document"))
+                        p.find(&as_json_value(t.document).expect("invalid document"))
                     {
-                        if result != as_json_value_array(&t.result).expect("invalid result") {
+                        if !equal(
+                            &result,
+                            as_json_value_array(&t.result).expect("invalid result"),
+                        ) {
                             assert!(
                                 false,
                                 "incorrect result, expected: {:?}, got: {:?}",
@@ -76,6 +79,16 @@ mod tests {
         assert!(errors.is_empty())
     }
 
+    fn equal(actual: &Vec<&serde_json::Value>, expected: Vec<serde_json::Value>) -> bool {
+        if actual.len() != expected.len() {
+            false
+        } else {
+            (0..actual.len()).fold(true, |result, item| {
+                result && actual[item] == &expected[item]
+            })
+        }
+    }
+
     fn as_json(v: &serde_yaml::Value) -> Result<String, String> {
         match v {
             serde_yaml::Value::Null => Ok("null".to_string()),
@@ -106,11 +119,11 @@ mod tests {
         }
     }
 
-    fn as_json_value(v: &serde_yaml::Value) -> Result<serde_json::Value, String> {
+    fn as_json_value(v: serde_yaml::Value) -> Result<serde_json::Value, String> {
         match v {
             serde_yaml::Value::Null => Ok(serde_json::Value::Null),
 
-            serde_yaml::Value::Bool(b) => Ok(serde_json::Value::Bool(*b)),
+            serde_yaml::Value::Bool(b) => Ok(serde_json::Value::Bool(b)),
 
             serde_yaml::Value::Number(num) => {
                 Ok(serde_json::Value::Number(yaml_number_as_json(num.clone())))
@@ -129,7 +142,7 @@ mod tests {
                 let object_members = map.iter().map(|(k, v)| {
                     (
                         serde_yaml::to_string(k).expect("non-string mapping key"),
-                        as_json_value(v).expect("invalid map value"),
+                        as_json_value(v.clone()).expect("invalid map value"),
                     )
                 });
                 Ok(serde_json::Value::Object(object_members.collect()))
@@ -142,7 +155,7 @@ mod tests {
             serde_yaml::Value::Sequence(seq) => {
                 let array_elements = seq
                     .into_iter()
-                    .map(|v| as_json_value(v).expect("invalid sequence element"));
+                    .map(|v| as_json_value(v.clone()).expect("invalid sequence element"));
                 Ok(array_elements.collect())
             }
             _ => Err("not a sequence".to_string()),