Progress on the test functions

Author: thehiddenwaffle

jsonpath-ast/src/ast.rs

@@ -61,22 +61,23 @@ macro_rules! terminating_from_pest {
 use super::parse::{JSPathParser, Rule};
 #[cfg(feature = "compiled-path")]
 use crate::syn_parse::parse_impl::{
- ParseUtilsExt, parse_bool, parse_float, validate_function_name, validate_js_int,
- validate_js_str, validate_member_name_shorthand,
+ parse_bool, parse_float, validate_js_int, validate_js_str,
+ validate_member_name_shorthand, ParseUtilsExt,
 };
 use derive_new::new;
 use from_pest::{ConversionError, FromPest, Void};
-use pest::Parser;
 use pest::iterators::{Pair, Pairs};
+use pest::Parser;
 use pest_ast::FromPest;
 use proc_macro2::Span;
-#[allow(unused_imports)]
-use syn::LitBool;
+use quote::ToTokens;
 #[cfg(feature = "compiled-path")]
 use syn::parse::ParseStream;
 use syn::punctuated::Punctuated;
 use syn::token::Bracket;
-use syn::{Ident, Token, token};
+#[allow(unused_imports)]
+use syn::LitBool;
+use syn::{token, Token};
 #[cfg(feature = "compiled-path")]
 use syn_derive::Parse;
 
@@ -611,12 +612,12 @@ impl<'pest> FromPest<'pest> for CompOp {
 }
 
 #[derive(Debug, new, PartialEq)]
-#[cfg_attr(feature = "compiled-path", derive(Parse))]
+// #[cfg_attr(feature = "compiled-path", derive(Parse))]
 pub struct FunctionExpr {
  pub(crate) name: FunctionName,
- #[cfg_attr(feature = "compiled-path", syn(parenthesized))]
+ // #[cfg_attr(feature = "compiled-path", syn(parenthesized))]
  pub(crate) paren: token::Paren,
- #[cfg_attr(feature = "compiled-path", syn(in = paren))]
+ // #[cfg_attr(feature = "compiled-path", syn(in = paren))]
  // #[cfg_attr(feature = "compiled-path", parse(|i: ParseStream| PestIgnoredPunctuated::parse_terminated(i)))]
  pub(crate) args: PestIgnoredPunctuated<FunctionArgument, Token![,]>,
 }
@@ -650,9 +651,27 @@ impl<'pest> from_pest::FromPest<'pest> for FunctionExpr {
 
 #[derive(Debug, new, PartialEq)]
 #[cfg_attr(feature = "compiled-path", derive(Parse))]
-pub struct FunctionName {
- #[cfg_attr(feature = "compiled-path", parse(validate_function_name))]
- name: Ident,
+pub enum FunctionName {
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::length))]
+ Length(kw::length),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::value))]
+ Value(kw::value),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::count))]
+ Count(kw::count),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::search))]
+ Search(kw::search),
+ #[cfg_attr(feature = "compiled-path", parse(peek = Token![match]))]
+ Match(Token![match]),
+ #[cfg_attr(feature = "compiled-path", parse(peek = Token![in]))]
+ In(Token![in]),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::nin))]
+ Nin(kw::nin),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::none_of))]
+ NoneOf(kw::none_of),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::any_of))]
+ AnyOf(kw::any_of),
+ #[cfg_attr(feature = "compiled-path", parse(peek = kw::subset_of))]
+ SubsetOf(kw::subset_of),
 }
 
 impl<'pest> FromPest<'pest> for FunctionName {
@@ -666,12 +685,20 @@ impl<'pest> FromPest<'pest> for FunctionName {
  let pair = clone.next().ok_or(ConversionError::NoMatch)?;
  if matches!(
  pair.as_rule(),
- Rule::function_name_one_arg | Rule::function_name_two_arg
+ Rule::function_name
  ) {
- let mut inner = pair.into_inner();
- let inner = &mut inner;
- let this = FunctionName {
- name: Ident::new(inner.to_string().as_str().trim(), Span::call_site()),
+ let this = match pair.as_str().trim() {
+ "length" => Self::Length(Default::default()),
+ "value" => Self::Value(Default::default()),
+ "count" => Self::Count(Default::default()),
+ "search" => Self::Search(Default::default()),
+ "match" => Self::Match(Default::default()),
+ "in" => Self::In(Default::default()),
+ "nin" => Self::Nin(Default::default()),
+ "none_of" => Self::NoneOf(Default::default()),
+ "any_of" => Self::AnyOf(Default::default()),
+ "subset_of" => Self::SubsetOf(Default::default()),
+ _ => unreachable!("Invalid function name should be impossible, error in pest grammar")
  };
  *pest = clone;
  Ok(this)

jsonpath-ast/src/syn_parse.rs

@@ -1,24 +1,25 @@
 #[cfg(feature = "compiled-path")]
 pub(crate) mod parse_impl {
  use crate::ast::parse::{JSPathParser, Rule};
+ use crate::ast::{kw, CompOp, IndexSelector, Main, NameSelector};
  use crate::ast::{
  AbsSingularQuery, AtomExpr, Bool, BracketName, BracketedSelection, ChildSegment, CompExpr,
- Comparable, DescendantSegment, EOI, FilterSelector, FunctionArgument, FunctionExpr,
- FunctionName, IndexSegment, JPQuery, JSInt, JSString, Literal, LogicalExpr, LogicalExprAnd,
- MemberNameShorthand, NameSegment, NotOp, Null, Number, ParenExpr, PestIgnoredPunctuated,
- PestLiteralWithoutRule, RelQuery, RelSingularQuery, Root, Segment, Segments, Selector,
- SingularQuery, SingularQuerySegment, SingularQuerySegments, SliceEnd, SliceSelector,
- SliceStart, SliceStep, Test, TestExpr, WildcardSelector,
- WildcardSelectorOrMemberNameShorthand,
+ Comparable, DescendantSegment, FilterSelector, FunctionArgument, FunctionExpr, FunctionName,
+ IndexSegment, JPQuery, JSInt, JSString, Literal, LogicalExpr, LogicalExprAnd, MemberNameShorthand,
+ NameSegment, NotOp, Null, Number, ParenExpr, PestIgnoredPunctuated, PestLiteralWithoutRule,
+ RelQuery, RelSingularQuery, Root, Segment, Segments, Selector, SingularQuery,
+ SingularQuerySegment, SingularQuerySegments, SliceEnd, SliceSelector, SliceStart,
+ SliceStep, Test, TestExpr, WildcardSelector, WildcardSelectorOrMemberNameShorthand,
+ EOI,
  };
- use crate::ast::{CompOp, IndexSelector, Main, NameSelector, kw};
  use pest::Parser;
  use proc_macro2::{Ident, TokenStream};
- use quote::{ToTokens, quote};
+ use quote::{quote, ToTokens};
  use syn::parse::{Parse, ParseStream};
  use syn::punctuated::Punctuated;
+ use syn::spanned::Spanned;
  use syn::token::Token;
- use syn::{LitBool, LitInt, LitStr, Token, token};
+ use syn::{token, LitBool, LitInt, LitStr, Token};
 
  pub trait ParseUtilsExt: Parse {
  fn peek(input: ParseStream) -> bool;
@@ -629,11 +630,27 @@ pub(crate) mod parse_impl {
 
  impl ToTokens for FunctionName {
  fn to_tokens(&self, tokens: &mut TokenStream) {
- tokens.extend(quote! {
- ::jsonpath_ast::ast::FunctionName::new(
- ::proc_macro2::Ident::new("function_name", ::proc_macro2::Span::call_site())
- )
- });
+ // tokens.extend(quote! {
+ // ::jsonpath_ast::ast::FunctionName::new(
+ // ::proc_macro2::Ident::new("function_name", ::proc_macro2::Span::call_site())
+ // )
+ // });
+ let variant = match self {
+ // Literal::Number(inner) => {
+ // quote!(new_number(#inner))
+ // }
+ FunctionName::Length(_) => { quote!(new_length(Default::default())) }
+ FunctionName::Value(_) => { quote!(new_value(Default::default())) }
+ FunctionName::Count(_) => { quote!(new_count(Default::default())) }
+ FunctionName::Search(_) => { quote!(new_search(Default::default())) }
+ FunctionName::Match(_) => { quote!(new_match(Default::default())) }
+ FunctionName::In(_) => { quote!(new_in(Default::default())) }
+ FunctionName::Nin(_) => { quote!(new_nin(Default::default())) }
+ FunctionName::NoneOf(_) => { quote!(new_none_of(Default::default())) }
+ FunctionName::AnyOf(_) => { quote!(new_any_of(Default::default())) }
+ FunctionName::SubsetOf(_) => { quote!(new_subset_of(Default::default())) }
+ };
+ tokens.extend(quote!(::jsonpath_ast::ast::FunctionName::#variant))
  }
  }
 
@@ -840,9 +857,13 @@ pub(crate) mod parse_impl {
  impl ToTokens for TestExpr {
  fn to_tokens(&self, tokens: &mut TokenStream) {
  let Self { not_op, test } = self;
+ let repr_not = match not_op {
+ Some(not_op) => quote! {Some(#not_op)},
+ None => quote! {None},
+ };
  tokens.extend(quote! {
  ::jsonpath_ast::ast::TestExpr::new(
- #not_op,
+ #repr_not,
  #test
  )
  });
@@ -992,7 +1013,11 @@ pub(crate) mod parse_impl {
 
  impl ParseUtilsExt for CompExpr {
  fn peek(input: ParseStream) -> bool {
- Comparable::peek(input)
+ let fork = input.fork();
+ // This is very suboptimal but the only option because at this point in the stream a comp_expr and a test_expr
+ // look identical if they're both functions, IE: $[?match(@, $.regex)] is a test_exp while $[?match(@, $.regex) == true]
+ // is a comp_exp
+ fork.parse::<Comparable>().is_ok() && fork.parse::<CompOp>().is_ok()
  }
  }
  impl ParseUtilsExt for TestExpr {
@@ -1084,6 +1109,27 @@ pub(crate) mod parse_impl {
  Ok(num)
  }
 
+ fn function_name_expected_args(name: &FunctionName) -> (String, usize) {
+ (format!("{:?}", name), match name {
+ FunctionName::Length(_) | FunctionName::Value(_) | FunctionName::Count(_) => { 1 },
+ FunctionName::Search(_) | FunctionName::Match(_)
+ | FunctionName::In(_) | FunctionName::Nin(_)
+ | FunctionName::NoneOf(_) | FunctionName::AnyOf(_) | FunctionName::SubsetOf(_) => { 2 },
+ })
+ }
+ impl Parse for FunctionExpr {
+ fn parse(__input: ParseStream) -> ::syn::Result<Self> {
+ let paren;
+ let ret = Self { name: __input.parse()?, paren: syn::parenthesized!(paren in __input ), args: PestIgnoredPunctuated::parse_separated_nonempty(&paren)? };
+ let (func_name, expected_num_args) = function_name_expected_args(&ret.name);
+ if expected_num_args == ret.args.0.len() {
+ Ok(ret)
+ } else {
+ Err(syn::Error::new(ret.args.span(), format!("Invalid number of arguments for function {}, expected {}", func_name, expected_num_args)))
+ }
+ }
+ }
+
  impl ParseUtilsExt for FunctionExpr {
  fn peek(input: ParseStream) -> bool {
  FunctionName::peek(input)
@@ -1105,53 +1151,6 @@ pub(crate) mod parse_impl {
  }
  }
 
- pub fn validate_function_name(input: ParseStream) -> Result<Ident, syn::Error> {
- 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 {
  fn peek(input: ParseStream) -> bool {
  input.peek(Token![@])

jsonpath-rust-impl/tests/rfc9535_compile_tests/functions/count/compile_and_passes.rs

@@ -0,0 +1,28 @@
+// Test case: 00_count_function
+// Tags: function, count
+#[test]
+fn test_00_count_function() {
+ let q_ast = ::jsonpath_rust_impl::json_query!($[?count(@..*)>2]);
+ let q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@..*)>2]"#).expect("failed to parse");
+assert_eq!(q_pest, q_ast);
+}
+
+// Test case: 01_single_node_arg
+// Tags: function, count
+#[test]
+fn test_01_single_node_arg() {
+ let q_ast = ::jsonpath_rust_impl::json_query!($[?count(@.a)>1]);
+ let q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@.a)>1]"#).expect("failed to parse");
+assert_eq!(q_pest, q_ast);
+}
+
+// Test case: 02_multiple_selector_arg
+// Tags: function, count
+#[test]
+fn test_02_multiple_selector_arg() {
+ let q_ast = ::jsonpath_rust_impl::json_query!($[?count(@["a","d"])>1]);
+ let q_pest_double = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@["a","d"])>1]"#).expect("failed to parse");
+ let q_pest_single = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@['a','d'])>1]"#).expect("failed to parse");
+assert_eq!(q_pest_double, q_ast);
+ assert_eq!(q_pest_single, q_ast);
+}

jsonpath-rust-impl/tests/rfc9535_compile_tests/functions/count/compile_but_expect_err.rs

@@ -0,0 +1,63 @@
+// Test case: 03_non_query_arg_number
+// Tags: function, count
+#[test]
+fn test_03_non_query_arg_number() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(1)>2]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(1)>2]"#).expect_err("should not parse");
+}
+
+// Test case: 04_non_query_arg_string
+// Tags: function, count
+#[test]
+fn test_04_non_query_arg_string() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count('string')>2]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count('string')>2]"#).expect_err("should not parse");
+}
+
+// Test case: 05_non_query_arg_true
+// Tags: function, count
+#[test]
+fn test_05_non_query_arg_true() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(true)>2]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(true)>2]"#).expect_err("should not parse");
+}
+
+// Test case: 06_non_query_arg_false
+// Tags: function, count
+#[test]
+fn test_06_non_query_arg_false() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(false)>2]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(false)>2]"#).expect_err("should not parse");
+}
+
+// Test case: 07_non_query_arg_null
+// Tags: function, count
+#[test]
+fn test_07_non_query_arg_null() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(null)>2]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(null)>2]"#).expect_err("should not parse");
+}
+
+// Test case: 08_result_must_be_compared
+// Tags: function, count
+#[test]
+fn test_08_result_must_be_compared() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(@..*)]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@..*)]"#).expect_err("should not parse");
+}
+
+// Test case: 09_no_params
+// Tags: function, count
+#[test]
+fn test_09_no_params() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count()==1]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count()==1]"#).expect_err("should not parse");
+}
+
+// Test case: 10_too_many_params
+// Tags: function, count
+#[test]
+fn test_10_too_many_params() {
+ // let q_ast = ::jsonpath_rust_impl::json_query!($[?count(@.a,@.b)==1]);
+ let _q_pest = ::jsonpath_ast::ast::Main::try_from_pest_parse(r#"$[?count(@.a,@.b)==1]"#).expect_err("should not parse");
+}