Use new AST base parser by default

Author: Marko Mikulicic

src/ast.rs

@@ -104,15 +104,12 @@ fn abs_index(index: i64, node: &Value) -> usize {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::parser_ast::parse;
+    use crate::parser::parse;
     use serde_json::json;
 
     #[test]
     fn demo() {
-        let a1 = Path::Sel(
-            Box::new(Path::Root),
-            Selector::DotName("foo".to_owned()),
-        );
+        let a1 = Path::Sel(Box::new(Path::Root), Selector::DotName("foo".to_owned()));
         let a2 = Path::Sel(Box::new(a1), Selector::DotName("bar".to_owned()));
         let a3 = Path::Sel(
             Box::new(a2),

src/jsonpath.rs

@@ -4,8 +4,9 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+use crate::ast;
 use crate::parser;
-use crate::path::Path;
+use serde_json::Value;
 
 #[derive(Debug)]
 pub struct SyntaxError {
@@ -18,6 +19,19 @@ impl std::fmt::Display for SyntaxError {
     }
 }
 
-pub fn parse(selector: &str) -> Result<impl Path, SyntaxError> {
-    parser::parse(selector).map_err(|m| SyntaxError { message: m })
+pub enum FindError {
+    // no errors yet
+}
+
+pub fn parse(selector: &str) -> Result<Path, SyntaxError> {
+    let p = parser::parse(selector).map_err(|m| SyntaxError { message: m })?;
+    Ok(Path(p))
+}
+
+pub struct Path(ast::Path);
+
+impl Path {
+    pub fn find<'a>(&'a self, document: &'a Value) -> Result<Vec<&'a Value>, FindError> {
+        Ok(self.0.find(document).collect())
+    }
 }

src/lib.rs

@@ -8,10 +8,6 @@ extern crate pest;
 #[macro_use]
 extern crate pest_derive;
 
+pub mod ast;
 pub mod jsonpath;
-mod matchers;
 mod parser;
-pub mod path;
-
-pub mod ast;
-pub mod parser_ast;

src/matchers.rs

@@ -4,119 +4,77 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-use crate::matchers;
-use crate::path;
+pub use crate::ast::*;
 use crate::pest::Parser;
 
 #[derive(Parser)]
 #[grammar = "grammar.pest"]
 struct PathParser;
 
-pub fn parse(selector: &str) -> Result<impl path::Path, String> {
+pub fn parse(selector: &str) -> Result<Path, String> {
     let selector_rule = PathParser::parse(Rule::selector, selector)
         .map_err(|e| format!("{}", e))?
         .next()
         .unwrap();
 
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
+    let mut res = Path::Root;
     for r in selector_rule.into_inner() {
-        match r.as_rule() {
-            Rule::rootSelector => ms.push(Box::new(matchers::RootSelector {})),
-
-            Rule::matcher => {
-                for m in parse_matcher(r) {
-                    ms.push(m)
-                }
-            }
-
-            _ => println!("r={:?}", r),
+        res = match r.as_rule() {
+            Rule::rootSelector => res, // TODO: fix grammar so that this is a silent rule since we don't need it
+            Rule::matcher => Path::Sel(Box::new(res), parse_selector(r)),
+            _ => panic!("invalid parse tree {:?}", r),
         }
     }
-
-    Ok(path::new(ms))
+    Ok(res)
 }
 
-fn parse_matcher(matcher_rule: pest::iterators::Pair<Rule>) -> Vec<Box<dyn matchers::Matcher>> {
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
-    for r in matcher_rule.into_inner() {
-        match r.as_rule() {
-            Rule::wildcardedDotChild => ms.push(Box::new(matchers::WildcardedChild {})),
-
-            Rule::namedDotChild => {
-                for m in parse_dot_child_matcher(r) {
-                    ms.push(m)
-                }
-            }
-
-            Rule::union => {
-                for m in parse_union(r) {
-                    ms.push(m)
-                }
-            }
+fn parse_selector(matcher_rule: pest::iterators::Pair<Rule>) -> Selector {
+    let r = matcher_rule.into_inner().next().unwrap();
 
-            _ => (),
-        }
+    match r.as_rule() {
+        Rule::wildcardedDotChild => Selector::DotWildcard,
+        Rule::namedDotChild => Selector::DotName(parse_child_name(r)),
+        Rule::union => Selector::Union(parse_union_indices(r)),
+        _ => panic!("invalid parse tree {:?}", r),
     }
-    ms
 }
 
-fn parse_dot_child_matcher(
-    matcher_rule: pest::iterators::Pair<Rule>,
-) -> Vec<Box<dyn matchers::Matcher>> {
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
-    for r in matcher_rule.into_inner() {
-        if let Rule::childName = r.as_rule() {
-            ms.push(Box::new(matchers::Child::new(r.as_str().to_owned())));
-        }
+fn parse_child_name(matcher_rule: pest::iterators::Pair<Rule>) -> String {
+    let r = matcher_rule.into_inner().next().unwrap();
+    match r.as_rule() {
+        Rule::childName => r.as_str().to_owned(),
+        _ => panic!("invalid parse tree {:?}", r),
     }
-    ms
 }
 
-fn parse_union(matcher_rule: pest::iterators::Pair<Rule>) -> Vec<Box<dyn matchers::Matcher>> {
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
+fn parse_union_indices(matcher_rule: pest::iterators::Pair<Rule>) -> Vec<Index> {
+    let mut res = Vec::new();
+
     for r in matcher_rule.into_inner() {
         match r.as_rule() {
-            Rule::unionChild => {
-                for m in parse_union_child(r) {
-                    ms.push(m)
-                }
-            }
-            Rule::unionArrayIndex => {
-                for m in parse_union_array_index(r) {
-                    ms.push(m)
-                }
-            }
-            _ => {}
+            Rule::unionChild => res.append(&mut parse_union_child(r)),
+            Rule::unionArrayIndex => res.push(parse_union_array_index(r)),
+            _ => panic!("invalid parse tree {:?}", r),
         }
     }
-    vec![Box::new(matchers::Union::new(ms))]
+    res
 }
 
-fn parse_union_child(matcher_rule: pest::iterators::Pair<Rule>) -> Vec<Box<dyn matchers::Matcher>> {
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
+fn parse_union_child(matcher_rule: pest::iterators::Pair<Rule>) -> Vec<Index> {
+    let mut res = Vec::new();
     for r in matcher_rule.into_inner() {
         match r.as_rule() {
-            Rule::doubleInner => {
-                ms.push(Box::new(matchers::Child::new(unescape(r.as_str()))));
-            }
-
-            Rule::singleInner => {
-                ms.push(Box::new(matchers::Child::new(unescape_single(r.as_str()))));
-            }
-
-            _ => (),
+            Rule::doubleInner => res.push(Index::Field(unescape(r.as_str()))),
+            Rule::singleInner => res.push(Index::Field(unescape_single(r.as_str()))),
+            _ => panic!("invalid parse tree {:?}", r),
         }
     }
-    ms
+    res
 }
 
-fn parse_union_array_index(
-    matcher_rule: pest::iterators::Pair<Rule>,
-) -> Vec<Box<dyn matchers::Matcher>> {
-    let mut ms: Vec<Box<dyn matchers::Matcher>> = Vec::new();
+fn parse_union_array_index(matcher_rule: pest::iterators::Pair<Rule>) -> Index {
     let i = matcher_rule.as_str().parse().unwrap();
-    ms.push(Box::new(matchers::ArrayIndex::new(i)));
-    ms
+    Index::Number(i)
 }
 
 fn unescape(contents: &str) -> String {