add part to parse

Author: besok

src/parser/grammar/json_path_9535.pest

@@ -16,11 +16,11 @@ step = {":" ~ S ~ int?}
 start = {int}
 end = {int}
 slice_selector = { start? ~ S ~ ":" ~ S ~ end? ~ S ~ step? }
-filter_selector = {"?"~ S ~ logical_expr_or}
-logical_expr_or = {logical_expr_and ~ S ~ ("||" ~ S ~ logical_expr_and)*}
+filter_selector = {"?"~ S ~ logical_expr}
+logical_expr = {logical_expr_and ~ S ~ ("||" ~ S ~ logical_expr_and)*}
 logical_expr_and = {atom_expr ~ S ~ ("&&" ~ S ~ atom_expr)*}
 atom_expr = {paren_expr | comp_expr| test_expr}
-paren_expr = {not_op? ~ S ~ "(" ~ S ~ logical_expr_or ~ S ~ ")"}
+paren_expr = {not_op? ~ S ~ "(" ~ S ~ logical_expr ~ S ~ ")"}
 comp_expr = { comparable ~ S ~ comp_op ~ S ~ comparable }
 test_expr = {not_op? ~ S ~ test}
 test = {rel_query | jp_query | function_expr}
@@ -29,7 +29,7 @@ function_expr = { function_name ~ "(" ~ S ~ (function_argument ~ (S ~ "," ~ S ~
 function_name = { function_name_first ~ function_name_char* }
 function_name_first = { LCALPHA }
 function_name_char = { function_name_first | "_" | DIGIT }
-function_argument = { literal | test | logical_expr_or  }
+function_argument = { literal | test | logical_expr  }
 comparable = { literal | singular_query | function_expr }
 literal = { number | string | bool | null }
 bool = {"true" | "false"}

src/parser/macros2.rs

@@ -1,12 +1,22 @@
-use crate::parser::model2::{Literal, SingularQuery};
+use crate::parser::model2::{Filter, FilterAtom, FnArg, Literal, SingularQuery, Test};
 
 #[macro_export]
 macro_rules! lit {
-    () => { Literal::Null };
-    (b$b:expr ) => { Literal::Bool($b) };
-    (s$s:expr) => { Literal::String($s.to_string()) };
-    (i$n:expr) => { Literal::Int($n) };
-    (f$n:expr) => { Literal::Float($n) };
+    () => {
+        Literal::Null
+    };
+    (b$b:expr ) => {
+        Literal::Bool($b)
+    };
+    (s$s:expr) => {
+        Literal::String($s.to_string())
+    };
+    (i$n:expr) => {
+        Literal::Int($n)
+    };
+    (f$n:expr) => {
+        Literal::Float($n)
+    };
 }
 
 #[macro_export]
@@ -24,9 +34,15 @@ macro_rules! q_segments {
 
 #[macro_export]
 macro_rules! q_segment {
-    ($name:ident) => { SingularQuerySegment::Name(stringify!($name).to_string()) };
-    ([$name:ident]) => { SingularQuerySegment::Name(format!("\"{}\"", stringify!($name))) };
-    ([$index:expr]) => { SingularQuerySegment::Index($index) };
+    ($name:ident) => {
+        SingularQuerySegment::Name(stringify!($name).to_string())
+    };
+    ([$name:ident]) => {
+        SingularQuerySegment::Name(format!("\"{}\"", stringify!($name)))
+    };
+    ([$index:expr]) => {
+        SingularQuerySegment::Index($index)
+    };
 }
 #[macro_export]
 macro_rules! singular_query {
@@ -63,5 +79,76 @@ macro_rules! slice {
     };
     ($start:expr, $end:expr, $step:expr) => {
         (Some($start), Some($end), Some($step))
+    };
+}
+
+#[macro_export]
+macro_rules! test_fn {
+    ($name:ident $arg:expr) => {
+        TestFunction::try_new(stringify!($name), vec![$arg]).unwrap()
+    };
+    ($name:ident $arg1:expr, $arg2:expr ) => {
+        TestFunction::try_new(stringify!($name), vec![$arg1, $arg2]).unwrap()
+    };
+}
+
+#[macro_export]
+macro_rules! arg {
+    ($arg:expr) => {
+        FnArg::Literal($arg)
+    };
+    (t $arg:expr) => {
+        FnArg::Test(Box::new($arg))
+    };
+    (f $arg:expr) => {
+        FnArg::Filter($arg)
     }
+}
+
+#[macro_export]
+macro_rules! test {
+  (@ $($segments:expr)*) => { Test::RelQuery(vec![$($segments),*]) };
+  (S $jq:expr) => { Test::AbsQuery($jq) };
+  ($tf:expr) => { Test::Function(Box::new($tf)) };
+
+}
+
+#[macro_export]
+macro_rules! or {
+    ($($items:expr)*) => {
+        Filter::Or(vec![ $($items),* ])
+    };
+}
+
+#[macro_export]
+macro_rules! and {
+    ($($items:expr)*) => {
+        Filter::And(vec![ $($items),* ])
+    };
+}
+
+#[macro_export]
+macro_rules! atom {
+    (! $filter:expr) => {
+        FilterAtom::filter($filter, true)
+    };
+    ($filter:expr) => {
+        FilterAtom::filter($filter, false)
+    };
+    (t! $filter:expr) => {
+        FilterAtom::filter($filter, true)
+    };
+    (t $filter:expr) => {
+        FilterAtom::filter($filter, false)
+    };
+    ($lhs:expr, $s:ident, $rhs:expr) => {
+        FilterAtom::Comparison(Box::new(cmp!($lhs, $s, $rhs)))
+    };
+}
+
+#[macro_export]
+macro_rules! cmp {
+  ($lhs:expr, $s:ident, $rhs:expr) => {
+      Comparison::try_new($lhs, stringify!($s), $rhs).unwrap()
+  }
 }

src/parser/model2.rs

@@ -3,7 +3,7 @@ use crate::parser::errors2::JsonPathParserError;
 use crate::parser::parser2::Parsed;
 
 /// Represents a JSONPath query with a list of segments.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct JpQuery  {
     segments: Vec<Segment>
 }
@@ -22,7 +22,7 @@ impl Display for JpQuery {
     }
 }
 /// Enum representing different types of segments in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Segment {
     /// Represents a descendant segment.
     Descendant,
@@ -32,6 +32,12 @@ pub enum Segment {
     Selectors(Vec<Selector>),
 }
 
+impl Segment {
+    pub fn name(name:&str) -> Self{
+        Segment::Selector(Selector::Name(name.to_string()))
+    }
+}
+
 impl Display for Segment {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -42,16 +48,16 @@ impl Display for Segment {
     }
 }
 /// Enum representing different types of selectors in a JSONPath query.
-#[derive(Debug, Clone)]
-enum Selector {
+#[derive(Debug, Clone, PartialEq)]
+pub enum Selector {
     /// Represents a name selector.
     Name(String),
     /// Represents a wildcard selector.
     Wildcard,
     /// Represents an index selector.
     Index(i64),
     /// Represents a slice selector.
-    Slice(i64, i64, i64),
+    Slice(Option<i64>, Option<i64>, Option<i64>),
     /// Represents a filter selector.
     Filter(Filter),
 }
@@ -62,37 +68,41 @@ impl Display for Selector {
             Selector::Name(name) => write!(f, "{}", name),
             Selector::Wildcard => write!(f, "*"),
             Selector::Index(index) => write!(f, "{}", index),
-            Selector::Slice(start, end, step) => write!(f, "{}:{}:{}", start, end, step),
+            Selector::Slice(start, end, step) => write!(f, "{}:{}:{}",
+                                                        start.unwrap_or(0),
+                                                        end.unwrap_or(0),
+                                                        step.unwrap_or(1)),
             Selector::Filter(filter) => write!(f, "[?{}]", filter),
         }
     }
 }
 /// Enum representing different types of filters in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Filter {
     /// Represents a logical OR filter.
-    Or(Box<Filter>, Box<Filter>),
+    Or(Vec<Filter>),
     /// Represents a logical AND filter.
-    And(Box<Filter>, Box<Filter>),
-    /// Represents a logical NOT filter.
-    Not(Box<Filter>),
+    And(Vec<Filter>),
     /// Represents an atomic filter.
     Atom(FilterAtom),
 }
 
 impl Display for Filter {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+
+        let items_to_str = |items: &Vec<Filter>, sep:&str|
+            items.iter().map(|f| f.to_string()).collect::<Vec<_>>().join(sep);
+
         match self {
-            Filter::Or(left, right) => write!(f, "{} || {}", left, right),
-            Filter::And(left, right) => write!(f, "{} && {}", left, right),
-            Filter::Not(expr) => write!(f, "!{}", expr),
+            Filter::Or(filters) => write!(f, "{}", items_to_str(filters, " || ")),
+            Filter::And(filters) => write!(f, "{}", items_to_str(filters, " && ")),
             Filter::Atom(atom) => write!(f, "{}", atom),
         }
     }
 }
 
 /// Enum representing different types of atomic filters in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum FilterAtom {
     /// Represents a nested filter with an optional NOT flag.
     Filter {
@@ -144,7 +154,7 @@ impl Display for FilterAtom {
     }
 }
 /// Enum representing different types of comparisons in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Comparison {
     /// Represents an equality comparison.
     Eq(Comparable, Comparable),
@@ -188,7 +198,7 @@ impl Display for Comparison {
 }
 
 /// Enum representing different types of comparable values in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Comparable {
     /// Represents a literal value.
     Literal(Literal),
@@ -245,7 +255,7 @@ impl Display for SingularQuerySegment {
 }
 
 /// Enum representing different types of tests in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Test {
     /// Represents a relative query.
     RelQuery(Vec<Segment>),
@@ -266,7 +276,7 @@ impl Display for Test {
 }
 
 /// Enum representing different types of test functions in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum TestFunction {
     /// Represents a custom function.
     Custom(String, Vec<FnArg>),
@@ -311,7 +321,7 @@ impl Display for TestFunction {
 }
 
 /// Enum representing different types of function arguments in a JSONPath query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum FnArg {
     /// Represents a literal argument.
     Literal(Literal),