Refactor function parsing and add support for new keywords. All tests including rfc passing.

Work still needed to remove redundant parsing logic from main crate.

Updated the function parsing logic to support one-arg and two-arg functions, and check function names within the pest grammar. Adjusted syntax rules and tests to reflect these changes.

Author: thehiddenwaffle

jsonpath-ast/src/ast.rs

@@ -9,9 +9,16 @@ pub(crate) mod kw {
     // syn::custom_keyword!(in);
     syn::custom_keyword!(nin);
     syn::custom_keyword!(size);
-    syn::custom_keyword!(noneOf);
-    syn::custom_keyword!(anyOf);
-    syn::custom_keyword!(subsetOf);
+    syn::custom_keyword!(none_of);
+    syn::custom_keyword!(any_of);
+    syn::custom_keyword!(subset_of);
+
+    syn::custom_keyword!(length);
+    syn::custom_keyword!(value);
+    syn::custom_keyword!(count);
+    syn::custom_keyword!(search);
+    // reserved
+    // syn::custom_keyword!(match);
 
     syn::custom_keyword!(null);
 }
@@ -657,7 +664,7 @@ impl<'pest> FromPest<'pest> for FunctionName {
     ) -> Result<Self, ConversionError<Self::FatalError>> {
         let mut clone = pest.clone();
         let pair = clone.next().ok_or(ConversionError::NoMatch)?;
-        if pair.as_rule() == Rule::function_name {
+        if matches!(pair.as_rule(), Rule::function_name_one_arg | Rule::function_name_two_arg) {
             let mut inner = pair.into_inner();
             let inner = &mut inner;
             let this = FunctionName {

jsonpath-ast/src/syn_parse.rs

@@ -1092,16 +1092,61 @@ pub(crate) mod parse_impl {
 
     impl ParseUtilsExt for FunctionName {
         fn peek(input: ParseStream) -> bool {
-            input.peek(syn::Ident)
+            input.peek(kw::length)
+                || input.peek(kw::value)
+                || input.peek(kw::count)
+                || input.peek(kw::search)
+                || input.peek(Token![match])
+                || input.peek(Token![in])
+                || input.peek(kw::nin)
+                || input.peek(kw::none_of)
+                || input.peek(kw::any_of)
+                || input.peek(kw::subset_of)
         }
     }
 
     pub fn validate_function_name(input: ParseStream) -> Result<Ident, syn::Error> {
-        let ident = input.parse::<Ident>()?;
-        match JSPathParser::parse(Rule::function_name, &ident.to_string()) {
-            Ok(_) => Ok(ident),
-            Err(e) => Err(syn::Error::new(ident.span(), e.to_string())),
-        }
+        if input.peek(kw::length) {
+            input.parse::<kw::length>()?;
+            return Ok(Ident::new("length", input.span()));
+        }    
+        if input.peek(kw::value) {
+            input.parse::<kw::value>()?;
+            return Ok(Ident::new("value", input.span()));
+        }
+        if input.peek(kw::count) {
+            input.parse::<kw::count>()?;
+            return Ok(Ident::new("count", input.span()));
+        }
+        if input.peek(kw::search) {
+            input.parse::<kw::search>()?;
+            return Ok(Ident::new("search", input.span()));
+        }
+        if input.peek(Token![match]) {
+            input.parse::<Token![match]>()?;
+            return Ok(Ident::new("match", input.span()));
+        }
+        if input.peek(Token![in]) {
+            input.parse::<Token![in]>()?;
+            return Ok(Ident::new("in", input.span()));
+        }
+        if input.peek(kw::nin) {
+            input.parse::<kw::nin>()?;
+            return Ok(Ident::new("nin", input.span()));
+        }
+        if input.peek(kw::none_of) {
+            input.parse::<kw::none_of>()?;
+            return Ok(Ident::new("none_of", input.span()));
+        }
+        if input.peek(kw::any_of) {
+            input.parse::<kw::any_of>()?;
+            return Ok(Ident::new("any_of", input.span()));
+        }
+        if input.peek(kw::subset_of) {
+            input.parse::<kw::subset_of>()?;
+            return Ok(Ident::new("subset_of", input.span()));
+        }
+        Err(syn::Error::new(input.span(), "invalid function name, expected one of: length, value, count, search, match, in, nin, none_of, any_of, subset_of"))
     }
 
     impl ParseUtilsExt for RelQuery {

jsonpath-rust-impl/tests/test.rs

@@ -9,6 +9,7 @@ mod tests {
 
     #[test]
     fn scratch() {
+        let q_ast = json_query!($.values[?match(@, $.regex)]).into();
         json_query!( $..[1] );
         json_query!( $[1,::] );
 

rfc9535/src/suite.rs

@@ -4,7 +4,6 @@ use jsonpath_rust::parser::parse_json_path;
 use jsonpath_rust::JsonPath;
 use serde_json::Value;
 use std::str::FromStr;
-use jsonpath_rust::ast::Main;
 
 type SkippedCases = usize;
 type SkippedCasesToFix = usize;
@@ -104,20 +103,6 @@ pub fn handle_test_case(case: &TestCase) -> TestResult {
     }
 }
 
-pub fn test_macro(case: &TestCase) -> TestResult {
-    let pest_ast: Main = Main::try_from_pest_parse(case.selector.as_str())
-        .map_err(|_| TestFailure::invalid(case))?;
-
-    let syn_ast: Main = jsonpath_rust::ast::Main::parse_syn_ast_from_string(case.selector.clone())
-        .map_err(|_| { TestFailure::invalid(case) })?;
-
-    if pest_ast == syn_ast {
-        Ok(())
-    } else {
-        Err(TestFailure::invalid(case))
-    }
-}
-
 #[derive(serde::Deserialize)]
 struct FilterCase {
     name: String,

rfc9535/test_suite/results.csv

@@ -1,6 +1,4 @@
 Total; Passed; Failed; Date
-687; 652; 10; 2025-03-18 22:29:42
-687; 652; 5; 2025-03-18 22:34:48
 687; 652; 4; 2025-03-18 22:40:55
 687; 652; 2; 2025-03-18 22:41:43
 687; 652; 1; 2025-03-18 22:41:53
@@ -10,3 +8,4 @@ Total; Passed; Failed; Date
 687; 652; 0; 2025-03-18 22:57:01
 687; 652; 0; 2025-05-13 21:21:59
 687; 652; 0; 2025-05-19 15:05:31
+687; 652; 0; 2025-05-29 10:41:32

src/parser/grammar/json_path_9535.pest

@@ -25,11 +25,12 @@ comp_expr = { comparable ~ S ~ comp_op ~ S ~ comparable }
 test_expr = {not_op? ~ S ~ test}
 test = {rel_query | jp_query | function_expr}
 rel_query = {curr ~ S ~ segments}
-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 | test | logical_expr  }
+function_expr = { ( function_name_one_arg ~ one_arg ) | ( function_name_two_arg ~ two_arg ) }
+function_name_one_arg = { "length" | "value" | "count" }
+function_name_two_arg = { "search" | "match" |  "in" | "nin" | "none_of" | "any_of" | "subset_of" }
+function_argument = { literal | test | logical_expr }
+one_arg = _{ "(" ~ S ~ function_argument ~ S ~ ")" }
+two_arg = _{ "(" ~ S ~ function_argument ~ S ~ "," ~ S ~ function_argument ~ S ~ ")" }
 comparable = { literal | singular_query | function_expr }
 literal = { number | string | bool | null }
 bool = {"true" | "false"}