Play with explicit AST

Author: Marko Mikulicic

src/ast.rs

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2020 VMware, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+use serde_json::Value;
+
+/// A path is a tree of selector nodes.
+///
+/// For example, the JSONPath `$.foo.bar` yields this AST:
+///
+/// ```text
+///               *
+///              / \
+///             *   \___ DotName("bar")
+///            / \
+///           *   \___ DotName("foo")
+///          /
+/// Root ___/
+/// ```
+///
+/// A more complicated example: `$.foo[1,2]["bar"]`:
+///
+/// ```text
+///                  *
+///                 / \
+///                *   \___ Union
+///               / \            \
+///              *   \___ Union   \
+///             /            \     [Field("bar")]
+///            *              \
+///           / \              [Number(1), Number(2)]
+///          /   \
+/// Root ___/     \___ DotName("foo")
+/// ```
+///
+#[derive(Debug)]
+pub enum Path {
+    Root,
+    Sel(Box<Path>, Selector),
+}
+
+#[derive(Debug)]
+pub enum Selector {
+    Union(Vec<Index>),
+    DotName(String),
+    DotWildcard,
+}
+
+#[derive(Debug)]
+pub enum Index {
+    Field(String),
+    Number(i64),
+}
+
+type Iter<'a> = Box<dyn Iterator<Item = &'a Value> + 'a>;
+
+impl Path {
+    pub fn find<'a>(&'a self, input: &'a Value) -> Iter<'a> {
+        match self {
+            Path::Root => Box::new(std::iter::once(input)),
+            Path::Sel(left, sel) => Box::new(left.find(input).flat_map(move |v| sel.find(v))),
+        }
+    }
+}
+
+impl Selector {
+    pub fn find<'a>(&'a self, input: &'a Value) -> Iter<'a> {
+        match self {
+            Selector::Union(indices) => Box::new(indices.iter().flat_map(move |i| i.get(input))),
+            Selector::DotName(name) => Box::new(input.get(name).into_iter()),
+            Selector::DotWildcard => match input {
+                Value::Object(m) => Box::new(m.values()),
+                Value::Array(a) => Box::new(a.iter()),
+                _ => Box::new(std::iter::empty()),
+            },
+        }
+    }
+}
+
+impl Index {
+    pub fn get<'a>(&self, v: &'a Value) -> Iter<'a> {
+        match self {
+            Index::Field(name) => Box::new(v.get(name).into_iter()),
+            Index::Number(num) => Box::new(v.get(abs_index(*num, v)).into_iter()),
+        }
+    }
+}
+
+fn abs_index(index: i64, node: &Value) -> usize {
+    if index >= 0 {
+        index as usize
+    } else {
+        let len = if let Value::Array(a) = node {
+            a.len() as i64
+        } else {
+            0
+        };
+        (len + index) as usize
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser_ast::parse;
+    use serde_json::json;
+
+    #[test]
+    fn demo() {
+        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),
+            Selector::Union(vec![Index::Field("baz".to_owned())]),
+        );
+        let a4 = Path::Sel(Box::new(a3), Selector::Union(vec![Index::Number(4)]));
+
+        let j = json!({"foo":{"bar":{"baz":[10,20,30,40,50,60]}}});
+        println!("j: {}", j);
+
+        let v = a4.find(&j).collect::<Vec<_>>();
+        assert_eq!(v[0], 50);
+    }
+
+    #[test]
+    fn parse_demo() -> Result<(), String> {
+        let p = parse("$.foo['bar'].*[4,-1]")?;
+        println!("AST: {:?}", &p);
+        let j = json!({"foo":{"bar":{"baz":[10,20,30,40,50,60]}}});
+
+        let v = p.find(&j).collect::<Vec<_>>();
+        println!("RES: {:?}", v);
+
+        assert_eq!(v[0], 50);
+        assert_eq!(v[1], 60);
+        Ok(())
+    }
+}

src/lib.rs

@@ -12,3 +12,6 @@ pub mod jsonpath;
 mod matchers;
 mod parser;
 pub mod path;
+
+pub mod ast;
+pub mod parser_ast;

src/parser_ast.rs

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2020 VMware, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+use crate::ast::*;
+use crate::pest::Parser;
+
+#[derive(Parser)]
+#[grammar = "grammar.pest"]
+struct PathParser;
+
+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 res = Path::Root;
+    for r in selector_rule.into_inner() {
+        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(res)
+}
+
+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),
+    }
+}
+
+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),
+    }
+}
+
+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 => res.append(&mut parse_union_child(r)),
+            Rule::unionArrayIndex => res.push(parse_union_array_index(r)),
+            _ => panic!("invalid parse tree {:?}", r),
+        }
+    }
+    res
+}
+
+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 => res.push(Index::Field(unescape(r.as_str()))),
+            Rule::singleInner => res.push(Index::Field(unescape_single(r.as_str()))),
+            _ => panic!("invalid parse tree {:?}", r),
+        }
+    }
+    res
+}
+
+fn parse_union_array_index(matcher_rule: pest::iterators::Pair<Rule>) -> Index {
+    let i = matcher_rule.as_str().parse().unwrap();
+    Index::Number(i)
+}
+
+fn unescape(contents: &str) -> String {
+    let s = format!(r#""{}""#, contents);
+    serde_json::from_str(&s).unwrap()
+}
+
+fn unescape_single(contents: &str) -> String {
+    let d = to_double_quoted(contents);
+    unescape(&d)
+}
+
+// converts a single quoted string body into a string that can be unescaped
+// by a function that knows how to unescape double quoted string,
+// It works by unescaping single quotes and escaping double quotes while leaving
+// everything else untouched.
+fn to_double_quoted(contents: &str) -> String {
+    let mut output = String::new();
+    let mut escaping = false;
+    for ch in contents.chars() {
+        if !escaping {
+            if ch == '\\' {
+                escaping = true;
+            } else {
+                if ch == '"' {
+                    output.push('\\');
+                }
+                output.push(ch);
+            }
+        } else {
+            escaping = false;
+            if ch != '\'' {
+                output.push('\\');
+            };
+            output.push(ch);
+        }
+    }
+    output
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_to_double() {
+        assert_eq!(to_double_quoted(r#"ab"#), r#"ab"#);
+        assert_eq!(to_double_quoted(r#"a"b"#), r#"a\"b"#);
+        assert_eq!(to_double_quoted(r#"a\'b"#), r#"a'b"#);
+        assert_eq!(to_double_quoted(r#"a\nb"#), r#"a\nb"#);
+        assert_eq!(to_double_quoted(r#"a\bb"#), r#"a\bb"#);
+        assert_eq!(to_double_quoted(r#"a\\b"#), r#"a\\b"#);
+    }
+}