better error messages

Author: meir

src/grammer.pest

@@ -1,5 +1,4 @@
-complex_literal = _{(!("."|"*"|"\""|"'"|"["|"]"|"="|" "|"("|")"|"{"|"}"|"|"|"<"|">"|"!"|",") ~ ANY)+}
-literal = @{('a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | "-" | "_")+ | complex_literal}
+literal = @{('a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | "-" | "_" | "`" | "~" | "+" | "#" | "%" | "$" | "^" | "/")+}
 
 string = _{("'" ~ (string_value) ~ "'") | ("\"" ~ (string_value) ~ "\"") | ("\"" ~ (string_value_escape_1) ~ "\"") | ("'" ~ (string_value_escape_2) ~ "'")}
     string_escape = @{"\\"}

src/json_path.rs

@@ -29,6 +29,22 @@ impl std::fmt::Display for QueryCompilationError {
     }
 }
 
+impl std::fmt::Display for Rule {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        match self {
+            Rule::literal => write!(f, "<string>"),
+            Rule::all => write!(f, "'*'"),
+            Rule::full_scan => write!(f, "'..'"),
+            Rule::numbers_list => write!(f, "'<number>[,<number>,...]'"),
+            Rule::string_list => write!(f, "'<string>[,<string>,...]'"),
+            Rule::numbers_range => write!(f, "['start:end:steps']"),
+            Rule::number => write!(f, "'<number>'"),
+            Rule::filter => write!(f, "'[?(filter_expression)]'"),
+            _ => write!(f, "{:?}", self)
+        }
+    }
+}
+
 pub (crate) fn compile<'i>(s: &'i str) -> Result<Query<'i>, QueryCompilationError> {
     let q = JsonPathParser::parse(Rule::query, s);
     match q {
@@ -47,12 +63,12 @@ pub (crate) fn compile<'i>(s: &'i str) -> Result<Query<'i>, QueryCompilationErro
                     ref negatives,
                 } => {
                     let positives = if positives.len() > 0 {
-                        Some(positives.iter().map(|v| format!("{:?}", v)).collect::<Vec<_>>().join(", "))
+                        Some(positives.iter().map(|v| format!("{}", v)).collect::<Vec<_>>().join(", "))
                     } else {
                         None
                     };
                     let negatives = if negatives.len() > 0 {
-                        Some(negatives.iter().map(|v| format!("{:?}", v)).collect::<Vec<_>>().join(", "))
+                        Some(negatives.iter().map(|v| format!("{}", v)).collect::<Vec<_>>().join(", "))
                     } else {
                         None
                     };

src/lib.rs

@@ -40,6 +40,10 @@ pub fn compile<'i>(s: &'i str) -> Result<Query<'i>, QueryCompilationError> {
     json_path::compile(s)
 }
 
+/// Calc once allows to performe a one time calculation on the give query.
+/// The query ownership is taken so it can not be used after. This allows
+/// the get a better performance if there is a need to calculate the query
+/// only once.
 pub fn calc_once<'j, 'p, S:SelectValue>(mut q: Query<'j>, json: &'p S) -> Vec<&'p S> {
     let root = q.query.next().unwrap();
     PathCalculator::<'p, DummyTrackerGenerator> {
@@ -48,6 +52,7 @@ pub fn calc_once<'j, 'p, S:SelectValue>(mut q: Query<'j>, json: &'p S) -> Vec<&'
     }.calc_with_paths_on_root(json, root).into_iter().map(|e: CalculationResult<'p, S, DummyTracker>| e.res).collect()
 }
 
+/// A version of `calc_once` that returns also paths.
 pub fn calc_once_with_paths<'j, 'p, S:SelectValue>(mut q: Query<'j>, json: &'p S) -> Vec<CalculationResult<'p, S, PTracker>> {
     let root = q.query.next().unwrap();
     PathCalculator {
@@ -56,6 +61,7 @@ pub fn calc_once_with_paths<'j, 'p, S:SelectValue>(mut q: Query<'j>, json: &'p S
     }.calc_with_paths_on_root(json, root)
 }
 
+/// A version of `calc_once` that returns only paths as Vec<Vec<String>>.
 pub fn calc_once_paths<'j, 'p, S:SelectValue>(mut q: Query<'j>, json: &'p S) -> Vec<Vec<String>> {
     let root = q.query.next().unwrap();
     PathCalculator {