add sing query

Author: besok

src/parser/grammar/json_path_9535.pest

@@ -21,6 +21,9 @@ paren_expr = {not_op? ~ S ~ "(" ~ S ~ logical_expr_or ~ S ~ ")"}
 comp_expr = { comparable ~ S ~ comp_op ~ S ~ comparable }
 test_expr = {not_op? ~ S ~ (filter_query | function_expr)}
 function_expr = { function_name ~ "(" ~ S ~ (function_argument ~ (S ~ "," ~ S ~ function_argument)*)? ~ S ~ ")" }
+function_name = { function_name_first ~ function_name_char* }
+function_name_first = { LCALPHA }
+function_name_char = { function_name_first | "_" | DIGIT }
 function_argument = { literal | filter_query | logical_expr_or | function_expr }
 filter_query = {rel_query | jp_query}
 rel_query = {curr ~ S ~ segments}
@@ -35,9 +38,7 @@ singular_query_segments = { (S ~ (name_segment | index_segment))* }
 name_segment = { ("[" ~ name_selector ~ "]") | ("." ~ member_name_shorthand) }
 index_segment = { "[" ~ index_selector ~ "]" }
 comp_op = { "==" | "!=" | "<=" | ">=" | "<" | ">" }
-function_name = { function_name_first ~ function_name_char* }
-function_name_first = { LCALPHA }
-function_name_char = { function_name_first | "_" | DIGIT }
+
 LCALPHA = { 'a'..'z' }
 
 
@@ -52,7 +53,7 @@ member_name_shorthand = { name_first ~ name_char* }
 name_first = { ALPHA | "_" | '\u{0080}'..'\u{D7FF}' | '\u{E000}'..'\u{10FFFF}' }
 name_char = { name_first | DIGIT }
 not_op = {"!"}
-curr = {"@"}
+curr = _{"@"}
 ESC = _{ "\\" }
 unescaped = _{
     '\u{0020}'..'\u{0021}' |

src/parser/macros2.rs

@@ -1,4 +1,4 @@
-use crate::parser::model2::Literal;
+use crate::parser::model2::{Literal, SingularQuery};
 
 #[macro_export]
 macro_rules! lit {
@@ -7,4 +7,33 @@ macro_rules! lit {
     (s$s:expr) => { Literal::String($s.to_string()) };
     (i$n:expr) => { Literal::Int($n) };
     (f$n:expr) => { Literal::Float($n) };
+}
+
+#[macro_export]
+macro_rules! q_segments {
+    ($segment:tt) => {
+        vec![q_segment!($segment)]
+    };
+    // Recursive case: multiple segments
+    ($segment:tt $($rest:tt)*) => {{
+        let mut segments = q_segments!($($rest)*);
+        segments.insert(0, q_segment!($segment));
+        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) };
+}
+#[macro_export]
+macro_rules! singular_query {
+    (@$($segment:tt)*) => {
+        SingularQuery::Current(q_segments!($($segment)*))
+    };
+    ($($segment:tt)*) => {
+        SingularQuery::Root(q_segments!($($segment)*))
+    };
 }

src/parser/model2.rs

@@ -1,4 +1,6 @@
 use std::fmt::{Display, Formatter};
+use crate::parser::errors2::JsonPathParserError;
+use crate::parser::parser2::Parsed;
 
 /// Represents a JSONPath query with a list of segments.
 #[derive(Debug, Clone)]
@@ -171,8 +173,8 @@ impl Display for Comparable {
 }
 
 /// Enum representing different types of singular queries in a JSONPath query.
-#[derive(Debug, Clone)]
-enum SingularQuery {
+#[derive(Debug, Clone, PartialEq)]
+pub enum SingularQuery {
     /// Represents a current node query.
     Current(Vec<SingularQuerySegment>),
     /// Represents a root node query.
@@ -189,8 +191,8 @@ impl Display for SingularQuery {
 }
 
 /// Enum representing different types of singular query segments in a JSONPath query.
-#[derive(Debug, Clone)]
-enum SingularQuerySegment {
+#[derive(Debug, Clone, PartialEq)]
+pub enum SingularQuerySegment {
     /// Represents an index segment.
     Index(i64),
     /// Represents a name segment.
@@ -244,6 +246,21 @@ enum TestFunction {
     Match(FnArg, FnArg),
 }
 
+impl TestFunction {
+    pub fn new(name: &str, args: Vec<FnArg>) -> Parsed<Self> {
+        match (name,args.as_slice()) {
+            ("length",[a]) => Ok(TestFunction::Length(Box::new(a.clone()))),
+            ("value",[a]) => Ok(TestFunction::Value(a.clone())),
+            ("count",[a]) => Ok(TestFunction::Count(a.clone())),
+            ("search",[a,b]) => Ok(TestFunction::Search(a.clone(), b.clone())),
+            ("match", [a,b]) => Ok(TestFunction::Match(a.clone(), b.clone())),
+            ("length" | "value" | "count" | "match" | "search", args ) =>
+                Err(JsonPathParserError::InvalidJsonPath(format!("Invalid number of arguments for the function `{}`: got {}", name, args.len()))),
+            (custom,_) => Ok(TestFunction::Custom(custom.to_string(), args)),
+        }
+    }
+}
+
 impl Display for TestFunction {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {

src/parser/parser2.rs

@@ -5,7 +5,7 @@ use crate::parser::errors2::JsonPathParserError;
 use crate::parser::model::JsonPath;
 use crate::path::JsonLike;
 use pest::Parser;
-use crate::parser::model2::Literal;
+use crate::parser::model2::{Literal, SingularQuery, SingularQuerySegment};
 
 #[derive(Parser)]
 #[grammar = "parser/grammar/json_path_9535.pest"]
@@ -28,6 +28,35 @@ where
 }
 
 
+pub fn singular_query_segments(rule:Pair<Rule>) -> Parsed<Vec<SingularQuerySegment>> {
+    let mut segments = vec![];
+    for r in rule.into_inner(){
+        match r.as_rule(){
+            Rule::name_segment => {
+                segments.push(SingularQuerySegment::Name(child(r)?.as_str().to_string()));
+            }
+            Rule::index_segment => {
+                segments.push(
+                    SingularQuerySegment::Index(child(r)?
+                        .as_str()
+                        .parse::<i64>()
+                        .map_err(|e|(e,"int"))?));
+            }
+            _ => return Err(r.into())
+        }
+    }
+    Ok(segments)
+}
+
+pub fn singular_query(rule:Pair<Rule>) -> Parsed<SingularQuery>{
+    let query = child(rule)?;
+    let segments = singular_query_segments(child(query.clone())?)?;
+    match query.as_rule() {
+        Rule::rel_singular_query => Ok(SingularQuery::Current(segments)),
+        Rule::abs_singular_query => Ok(SingularQuery::Root(segments)),
+        _ => Err(query.into())
+    }
+}
 
 pub fn literal(rule:Pair<Rule>) -> Parsed<Literal> {
     fn parse_number(num: &str) -> Parsed<Literal> {
@@ -59,20 +88,9 @@ pub fn literal(rule:Pair<Rule>) -> Parsed<Literal> {
 
 
 fn child(rule:Pair<Rule>) -> Parsed<Pair<Rule>> {
-    let string = rule.as_str().to_string();
-    rule.into_inner().next().ok_or(JsonPathParserError::EmptyInner(string))
+    let rule_as_str = rule.as_str().to_string();
+    rule.into_inner().next().ok_or(JsonPathParserError::EmptyInner(rule_as_str))
 }
 fn children(rule:Pair<Rule>) -> Pairs<Rule> {
     rule.into_inner()
 }
-
-#[cfg(test)]
-mod tests {
-    use std::fmt::Debug;
-    use super::*;
-    use std::panic;
-    use pest::error::Error;
-    use crate::lit;
-
-
-}

src/parser/tests.rs

@@ -1,10 +1,12 @@
+use crate::parser::model2::SingularQuery;
+use crate::parser::model2::SingularQuerySegment;
 use crate::parser::model2::Literal;
 use std::fmt::Debug;
 use pest::error::Error;
 use pest::iterators::Pair;
 use pest::Parser;
-use crate::lit;
-use crate::parser::parser2::{literal, Rule};
+use crate::{lit, q_segments, q_segment, singular_query};
+use crate::parser::parser2::{literal, singular_query, singular_query_segments, Rule};
 use std::panic;
 
 struct TestPair<T> {
@@ -88,4 +90,26 @@ fn literals(){
     ;
 
 
+}
+
+#[test]
+fn singular_query_segment_test(){
+    TestPair::new(Rule::singular_query_segments, singular_query_segments)
+        .assert("[\"b\"][\"b\"]",q_segments!([b][b]))
+        .assert("[2][1]",q_segments!([2][1]))
+        .assert("[2][\"a\"]",q_segments!([2][a]))
+        .assert(".a.b",q_segments!(a b))
+        .assert(".a.b[\"c\"][1]",q_segments!(a b [c][1]))
+    ;
+}
+#[test]
+fn singular_query_test(){
+    TestPair::new(Rule::singular_query, singular_query)
+        .assert("@.a.b",singular_query!(@ a b))
+        .assert("@",SingularQuery::Current(vec![]))
+        .assert("$",SingularQuery::Root(vec![]))
+        .assert("$.a.b.c",singular_query!(a b c))
+        .assert("$[\"a\"].b[3]",singular_query!([a] b [3]))
+
+    ;
 }