introduce a parser

Author: glyn

Cargo.toml

@@ -7,6 +7,8 @@ edition = "2018"
 [dependencies]
 itertools = "0.9.0"
 json = "0.12.4"
+pest = "2.1.3"
+pest_derive = "2.1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.57"
 serde_yaml = "0.8.13"

src/grammar.pest

@@ -0,0 +1,10 @@
+selector = _{ SOI ~ jsonPath ~ EOI }
+
+jsonPath = ${ rootSelector ~ matcher* }
+rootSelector = { "$" }
+
+matcher = { dotChild }
+
+dotChild = { ".*" }
+
+WHITESPACE = _{ " " }

src/jsonpath.rs

@@ -4,25 +4,20 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-use serde_json::Value;
+use crate::parser;
+use crate::path::Path;
 
 #[derive(Debug)]
-pub enum SyntaxError {
-    Message(String),
+pub struct SyntaxError {
+    message: String,
 }
 
-fn err(message: &str) -> Result<&dyn Path, SyntaxError> {
-    Err(SyntaxError::Message(message.to_string()))
+impl std::fmt::Display for SyntaxError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", self.message)
+    }
 }
 
-pub fn parse(_selector: &str) -> Result<&dyn Path, SyntaxError> {
-    err("not implemented")
-}
-
-pub enum FindError {
-    // no errors yet
-}
-
-pub trait Path {
-    fn find(&self, document: Value) -> Result<Vec<Value>, FindError>;
+pub fn parse(selector: &str) -> Result<Box<dyn Path>, SyntaxError> {
+    parser::parse(selector).map_err(|m| SyntaxError { message: m })
 }

src/lib.rs

@@ -4,4 +4,11 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+extern crate pest;
+#[macro_use]
+extern crate pest_derive;
+
 pub mod jsonpath;
+mod matchers;
+mod parser;
+pub mod path;

src/matchers.rs

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 VMware, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+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>;
+}
+
+pub struct RootSelector {}
+
+impl Matcher for RootSelector {
+    fn select(&self, node: Value) -> Vec<Value> {
+        let mut results = Vec::new();
+        results.push(node);
+        results
+    }
+}

src/parser.rs

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 VMware, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+use crate::matchers;
+use crate::path::{FindError, Path};
+use crate::pest::Parser;
+use serde_json::Value;
+
+#[derive(Parser)]
+#[grammar = "grammar.pest"]
+struct PathParser;
+
+struct SelectorPath<'a> {
+    matchers: Vec<&'a dyn matchers::Matcher>,
+}
+
+#[allow(clippy::single_match)]
+pub fn parse(selector: &str) -> Result<Box<dyn Path>, String> {
+    let selector_rule = PathParser::parse(Rule::selector, selector)
+        .map_err(|e| format!("{}", e))?
+        .next()
+        .unwrap();
+
+    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 {});
+            }
+            _ => println!("r={:?}", r),
+        }
+    }
+
+    Ok(Box::new(SelectorPath { matchers: ms }))
+}
+
+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)
+    }
+}

src/path.rs

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2020 VMware, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+use serde_json::Value;
+
+pub enum FindError {
+    // no errors yet
+}
+
+pub trait Path {
+    fn find(&self, document: Value) -> Result<Vec<Value>, FindError>;
+}

tests/cts.rs

@@ -43,7 +43,8 @@ mod tests {
                 let path = jsonpath::parse(&t.selector);
                 assert!(
                     path.is_ok(),
-                    "parse failed: {:?}",
+                    "parsing {} failed: {}",
+                    t.selector,
                     path.err().expect("should be an error")
                 );
 
@@ -52,7 +53,12 @@ mod tests {
                         p.find(as_json_value(&t.document).expect("invalid document"))
                     {
                         if result != as_json_value_array(&t.result).expect("invalid result") {
-                            assert!(false, "incorrect result")
+                            assert!(
+                                false,
+                                "incorrect result, expected: {:?}, got: {:?}",
+                                as_json_value_array(&t.result).unwrap(),
+                                result
+                            )
                         }
                     } else {
                         assert!(false, "find failed") // should not happen