janeway-jsonpath 0.1.0

data/lib/janeway/functions/search.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Janeway
+  module Functions
+    # 2.4.7. search() Function Extension
+    # Parameters:
+    #   1. ValueType (string)
+    #   2. ValueType (string conforming to [RFC9485])
+    # Result:
+    #     LogicalType
+    #
+    # The search() function extension provides a way to check whether a given
+    # string contains a substring that matches a given regular expression,
+    # which is in the form described in [RFC9485].
+    #
+    # $[?search(@.author, "[BR]ob")]
+    #
+    # Its arguments are instances of ValueType (possibly taken from a singular
+    # query, as for the first argument in the example above). If the first
+    # argument is not a string or the second argument is not a string
+    # conforming to [RFC9485], the result is LogicalFalse. Otherwise, the
+    # string that is the first argument is searched for a substring that
+    # matches the I-Regexp contained in the string that is the second argument;
+    # the result is LogicalTrue if at least one such substring exists and is
+    # LogicalFalse otherwise.
+    #
+    # tl;dr: How is this different from the match function?
+    # "match" must match the entire string, "search" matches a substring.
+    def parse_function_search
+      consume # function
+      raise "expect group_start token, found #{current}" unless current.type == :group_start
+
+      consume # (
+
+      # Read first parameter
+      parameters = []
+      parameters << parse_function_parameter
+
+      # Consume comma
+      if current.type == :union
+        consume # ,
+      else
+        raise "expect comma token, found #{current}" 
+      end
+
+      # Read second parameter (the regexp)
+      # This could be a string, in which case it is available now.
+      # Otherwise it is an expression that takes the regexp from the input document,
+      # and the iregexp will not be available until interpretation.
+      parameters << parse_function_parameter
+      raise "expect group_end token, found #{current}" unless current.type == :group_end
+
+      AST::Function.new('search', parameters) do |str, str_iregexp|
+        if str.is_a?(String) && str_iregexp.is_a?(String)
+          regexp = translate_iregex_to_ruby_regex(str_iregexp, anchor: false)
+          regexp.match?(str)
+        else
+          false # result defined by RFC9535
+        end
+      end
+    end
+  end
+end

data/lib/janeway/functions/value.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Janeway
+  module Functions
+    #  2.4.8. value() Function Extension
+
+    # Parameters:
+    #   1. NodesType
+    # Result:
+    #   ValueType
+    #
+    # The value() function extension provides a way to convert an instance of
+    # NodesType to a value and make that available for further processing in
+    # the filter expression:
+    #
+    # @example $[?value(@..color) == "red"]
+    #
+    # Its only argument is an instance of NodesType (possibly taken from a
+    # filter-query, as in the example above). The result is an instance of
+    # ValueType.
+    #
+    # If the argument contains a single node, the result is the value of the node.
+    #
+    # If the argument is the empty nodelist or contains multiple nodes, the result is Nothing.
+    #
+    # Note: A singular query may be used anywhere where a ValueType is
+    # expected, so there is no need to use the value() function extension with a singular query.
+    def parse_function_value
+      consume # function
+      raise "expect group_start token, found #{current}" unless current.type == :group_start
+
+      consume # (
+
+      # Read parameter
+      parameters = [parse_function_parameter]
+      raise "expect group_end token, found #{current}" unless current.type == :group_end
+
+      AST::Function.new('value', parameters) do |nodes|
+        if nodes.is_a?(Array) && nodes.size == 1
+          nodes.first
+        else
+          :nothing
+        end
+      end
+    end
+  end
+end

data/lib/janeway/functions.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'ast/function'
+
+module Janeway
+  # Mixin to provide JSONPath function handlers for Parser
+  module Functions
+    # Convert IRegexp format to ruby regexp equivalent, following the instructions in rfc9485.
+    # @see https://www.rfc-editor.org/rfc/rfc9485.html#name-pcre-re2-and-ruby-regexps
+    # @param iregex [String]
+    # @param anchor [Boolean] add anchors to match the string start and end
+    # @return [Regexp]
+    def translate_iregex_to_ruby_regex(iregex, anchor: true)
+      # * For any unescaped dots (.) outside character classes (first
+      #   alternative of charClass production), replace the dot with [^\n\r].
+      chars = iregex.chars
+      in_char_class = false
+      indexes = []
+      chars.each_with_index do |char, i|
+        # FIXME: does not handle escaped '[', ']', or '.'
+        case char
+        when '[' then in_char_class = true
+        when ']' then in_char_class = false
+        when '.'
+          next if in_char_class || chars[i-1] == '\\' # escaped dot
+
+          indexes << i # replace this dot
+        end
+      end
+      indexes.reverse_each do |i|
+        chars[i] = '[^\n\r]'
+      end
+
+      # * Enclose the regexp in \A(?: and )\z.
+      regex_str = anchor ? format('\A(?:%s)\z', chars.join) : chars.join
+      Regexp.new(regex_str)
+    end
+
+    # All jsonpath function parameters are one of these accepted types.
+    # Parse the function parameter and return the result.
+    # @return [String, AST::CurrentNode, AST::RootNode]
+    def parse_function_parameter
+      result =
+        case current.type
+        when :string then parse_string
+        when :current_node then parse_current_node
+        when :root then parse_root
+        else
+          # Invalid, no function uses this.
+          # Instead of crashing here, accept it and let the function return an empty result.
+          parse_expr
+        end
+      consume
+      result
+    end
+  end
+end
+
+# Require function definitions
+Dir.children("#{__dir__}/functions/").each do |path|
+  require_relative "functions/#{path[0..-4]}"
+end