json_p3 0.4.0 → 1.0.0

data/lib/json_p3/path/filter.rb

@@ -0,0 +1,463 @@
+# frozen_string_literal: true
+
+require_relative "function"
+require_relative "serialize"
+
+module JSONP3
+  # JSONPath query expressions.
+  module Path
+    # Base class for all filter expression nodes.
+    class Expression
+      # @dynamic token
+      attr_reader :token
+
+      def initialize(token)
+        @token = token
+      end
+
+      # Evaluate the filter expression in the given context.
+      def evaluate(_context)
+        raise "filter expressions must implement `evaluate(context)`"
+      end
+    end
+
+    # An expression that evaluates to true or false.
+    class FilterExpression < Expression
+      attr_reader :expression
+
+      def initialize(token, expression)
+        super(token)
+        @expression = expression
+      end
+
+      def evaluate(context)
+        JSONP3::Path.truthy?(@expression.evaluate(context))
+      end
+
+      def to_s
+        to_canonical_string(@expression, Precedence::LOWEST)
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @expression == other.expression &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@expression, @token].hash
+      end
+
+      private
+
+      class Precedence
+        LOWEST = 1
+        LOGICAL_OR = 3
+        LOGICAL_AND = 4
+        PREFIX = 7
+      end
+
+      def to_canonical_string(expression, parent_precedence)
+        if expression.instance_of? LogicalAndExpression
+          left = to_canonical_string(expression.left, Precedence::LOGICAL_AND)
+          right = to_canonical_string(expression.right, Precedence::LOGICAL_AND)
+          expr = "#{left} && #{right}"
+          return parent_precedence >= Precedence::LOGICAL_AND ? "(#{expr})" : expr
+        end
+
+        if expression.instance_of? LogicalOrExpression
+          left = to_canonical_string(expression.left, Precedence::LOGICAL_OR)
+          right = to_canonical_string(expression.right, Precedence::LOGICAL_OR)
+          expr = "#{left} || #{right}"
+          return parent_precedence >= Precedence::LOGICAL_OR ? "(#{expr})" : expr
+        end
+
+        if expression.instance_of? LogicalNotExpression
+          operand = to_canonical_string(expression.expression, Precedence::PREFIX)
+          expr = "!#{operand}"
+          return parent_precedence > Precedence::PREFIX ? `(#{expr})` : expr
+        end
+
+        expression.to_s
+      end
+    end
+
+    # Base class for expression literals.
+    class FilterExpressionLiteral < Expression
+      attr_reader :value
+
+      def initialize(token, value)
+        super(token)
+        @value = value
+      end
+
+      def evaluate(_context)
+        @value
+      end
+
+      def to_s
+        @value.to_s
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @value == other.value &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@value, @token].hash
+      end
+    end
+
+    # Literal true or false.
+    class BooleanLiteral < FilterExpressionLiteral; end
+
+    # A double or single quoted string literal.
+    class StringLiteral < FilterExpressionLiteral
+      def to_s
+        JSONP3::Path.canonical_string(@value)
+      end
+    end
+
+    # A literal integer.
+    class IntegerLiteral < FilterExpressionLiteral; end
+
+    # A literal float
+    class FloatLiteral < FilterExpressionLiteral; end
+
+    # A literal null
+    class NullLiteral < FilterExpressionLiteral
+      def to_s
+        "null"
+      end
+    end
+
+    # An expression prefixed with the logical not operator.
+    class LogicalNotExpression < Expression
+      attr_reader :expression
+
+      def initialize(token, expression)
+        super(token)
+        @expression = expression
+      end
+
+      def evaluate(context)
+        !JSONP3::Path.truthy?(@expression.evaluate(context))
+      end
+
+      def to_s
+        "!#{@expression}"
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @expression == other.expression &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@expression, @token].hash
+      end
+    end
+
+    # Base class for expression with a left expression, operator and right expression.
+    class InfixExpression < Expression
+      attr_reader :left, :right
+
+      def initialize(token, left, right)
+        super(token)
+        @left = left
+        @right = right
+      end
+
+      def evaluate(_context)
+        raise "infix expressions must implement `evaluate(context)`"
+      end
+
+      def to_s
+        raise "infix expressions must implement `to_s`"
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @left == other.left &&
+          @right == other.right &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@left, @right, @token].hash
+      end
+    end
+
+    # A logical `&&` expression.
+    class LogicalAndExpression < InfixExpression
+      def evaluate(context)
+        JSONP3::Path.truthy?(@left.evaluate(context)) && JSONP3::Path.truthy?(@right.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} && #{@right}"
+      end
+    end
+
+    # A logical `||` expression.
+    class LogicalOrExpression < InfixExpression
+      def evaluate(context)
+        JSONP3::Path.truthy?(@left.evaluate(context)) || JSONP3::Path.truthy?(@right.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} || #{@right}"
+      end
+    end
+
+    # An `==` expression.
+    class EqExpression < InfixExpression
+      def evaluate(context)
+        JSONP3::Path.eq?(@left.evaluate(context), @right.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} == #{@right}"
+      end
+    end
+
+    # A `!=` expression.
+    class NeExpression < InfixExpression
+      def evaluate(context)
+        !JSONP3::Path.eq?(@left.evaluate(context), @right.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} != #{@right}"
+      end
+    end
+
+    # A `<=` expression.
+    class LeExpression < InfixExpression
+      def evaluate(context)
+        left = @left.evaluate(context)
+        right = @right.evaluate(context)
+        JSONP3::Path.eq?(left, right) || JSONP3::Path.lt?(left, right)
+      end
+
+      def to_s
+        "#{@left} <= #{@right}"
+      end
+    end
+
+    # A `>=` expression.
+    class GeExpression < InfixExpression
+      def evaluate(context)
+        left = @left.evaluate(context)
+        right = @right.evaluate(context)
+        JSONP3::Path.eq?(left, right) || JSONP3::Path.lt?(right, left)
+      end
+
+      def to_s
+        "#{@left} >= #{@right}"
+      end
+    end
+
+    # A `<` expression.
+    class LtExpression < InfixExpression
+      def evaluate(context)
+        JSONP3::Path.lt?(@left.evaluate(context), @right.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} < #{@right}"
+      end
+    end
+
+    # A `>` expression.
+    class GtExpression < InfixExpression
+      def evaluate(context)
+        JSONP3::Path.lt?(@right.evaluate(context), @left.evaluate(context))
+      end
+
+      def to_s
+        "#{@left} > #{@right}"
+      end
+    end
+
+    # Base class for all embedded filter queries
+    class QueryExpression < Expression
+      attr_reader :query
+
+      def initialize(token, query)
+        super(token)
+        @query = query
+      end
+
+      def evaluate(_context)
+        raise "query expressions must implement `evaluate(context)`"
+      end
+
+      def to_s
+        raise "query expressions must implement `to_s`"
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @query == other.query &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@query, @token].hash
+      end
+    end
+
+    # An embedded query starting at the current node.
+    class RelativeQueryExpression < QueryExpression
+      def evaluate(context)
+        unless context.current.is_a?(Array) || context.current.is_a?(Hash)
+          return @query.empty? ? context.current : NodeList.new
+        end
+
+        @query.find(context.current)
+      end
+
+      def to_s
+        "@#{@query.to_s[1..]}"
+      end
+    end
+
+    # An embedded query starting at the root node.
+    class AbsoluteQueryExpression < QueryExpression
+      def evaluate(context)
+        @query.find(context.root)
+      end
+
+      def to_s
+        @query.to_s
+      end
+    end
+
+    # A filter function call.
+    class FunctionExpression < Expression
+      attr_reader :name, :args, :func
+
+      # @param name [String]
+      # @param func [FunctionExtension]
+      # @param args [Array<Expression>]
+      def initialize(token, name, func, args)
+        super(token)
+        @name = name
+        @func = func
+        @args = args
+      end
+
+      def evaluate(context)
+        args = @args.map { |arg| arg.evaluate(context) }
+        unpacked_args = unpack_node_lists(@func, args)
+        @func.call(*unpacked_args)
+      rescue KeyError
+        :nothing
+      end
+
+      def to_s
+        args = @args.join(", ")
+        "#{@name}(#{args})"
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @name == other.name &&
+          @args == other.args &&
+          @token == other.token
+      end
+
+      alias eql? ==
+
+      def hash
+        [@name, @args, @token].hash
+      end
+
+      private
+
+      # @param func [Proc]
+      # @param args [Array<Object>]
+      # @return [Array<Object>]
+      def unpack_node_lists(func, args)
+        unpacked_args = [] # : Array[Object]
+        args.each_with_index do |arg, i|
+          unless arg.is_a?(NodeList) && func.class::ARG_TYPES[i] != :nodes_expression
+            unpacked_args << arg
+            next
+          end
+
+          unpacked_args << case arg.length
+                           when 0
+                             :nothing
+                           when 1
+                             arg.first.value
+                           else
+                             arg
+                           end
+        end
+        unpacked_args
+      end
+    end
+
+    def self.truthy?(obj)
+      return !obj.empty? if obj.is_a?(NodeList)
+      return false if obj == :nothing
+
+      obj != false
+    end
+
+    def self.eq?(left, right)
+      left = left.first.value if left.is_a?(NodeList) && left.length == 1
+      right = right.first.value if right.is_a?(NodeList) && right.length == 1
+
+      right, left = left, right if right.is_a?(NodeList)
+
+      if left.is_a? NodeList
+        return left == right if right.is_a? NodeList
+        return right == :nothing if left.empty?
+        return left.first == right if left.length == 1
+
+        return false
+      end
+
+      return true if left == :nothing && right == :nothing
+
+      left == right
+    end
+
+    def self.lt?(left, right)
+      left = left.first.value if left.is_a?(NodeList) && left.length == 1
+      right = right.first.value if right.is_a?(NodeList) && right.length == 1
+      return left < right if left.is_a?(String) && right.is_a?(String)
+      return left < right if (left.is_a?(Integer) || left.is_a?(Float)) &&
+                             (right.is_a?(Integer) || right.is_a?(Float))
+
+      false
+    end
+
+    # Contextual information and data used for evaluating a filter expression.
+    class FilterContext
+      attr_reader :env, :current, :root
+
+      def initialize(env, current, root)
+        @env = env
+        @current = current
+        @root = root
+      end
+    end
+  end
+end

data/lib/json_p3/path/function.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONP3
+  module Path
+    # Base class for all filter functions.
+    class FunctionExtension
+      def call(*_args, **_kwargs)
+        raise "function extensions must implement `call()`"
+      end
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/count.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JSONP3
+  module Path
+    # The standard `count` function.
+    class Count < FunctionExtension
+      ARG_TYPES = [:nodes_expression].freeze
+      RETURN_TYPE = :value_expression
+
+      def call(node_list)
+        node_list.length
+      end
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/length.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSONP3
+  module Path
+    # The standard `length` function.
+    class Length < FunctionExtension
+      ARG_TYPES = [:value_expression].freeze
+      RETURN_TYPE = :value_expression
+
+      def call(obj)
+        return :nothing unless obj.is_a?(Array) || obj.is_a?(Hash) || obj.is_a?(String)
+
+        obj.length
+      end
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/match.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "pattern"
+
+module JSONP3
+  module Path
+    # The standard `match` function.
+    class Match < FunctionExtension
+      ARG_TYPES = %i[value_expression value_expression].freeze
+      RETURN_TYPE = :logical_expression
+
+      # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
+      #   zero or negative to disable the cache.
+      # @param raise_errors [Boolean] if _false_ (the default), return _false_ when this
+      #   function causes a RegexpError instead of raising the exception.
+      def initialize(cache_size = 128, raise_errors: false)
+        super()
+        @cache_size = cache_size
+        @raise_errors = raise_errors
+        @cache = LRUCache.new(cache_size)
+      end
+
+      # @param value [String]
+      # @param pattern [String]
+      # @return Boolean
+      def call(value, pattern)
+        return false unless pattern.is_a?(String) && value.is_a?(String)
+
+        if @cache_size.positive?
+          re = @cache[pattern] || Regexp.new(full_match(pattern))
+        else
+          re = Regexp.new(full_match(pattern))
+          @cache[pattern] = re
+        end
+
+        re.match?(value)
+      rescue RegexpError
+        raise if @raise_errors
+
+        false
+      end
+
+      private
+
+      def full_match(pattern)
+        parts = [] # : Array[String]
+        explicit_caret = pattern.start_with?("^")
+        explicit_dollar = pattern.end_with?("$")
+
+        # Replace '^' with '\A' and '$' with '\z'
+        pattern = pattern.sub("^", "\\A") if explicit_caret
+        pattern = "#{pattern[..-1]}\\z" if explicit_dollar
+
+        # Wrap with '\A' and '\z' if they are not already part of the pattern.
+        parts << "\\A(?:" if !explicit_caret && !explicit_dollar
+        parts << JSONP3::Path.map_iregexp(pattern)
+        parts << ")\\z" if !explicit_caret && !explicit_dollar
+        parts.join
+      end
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/pattern.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module JSONP3
+  # JSONPath query expressions.
+  module Path
+    # Map I-Regexp pattern to Ruby regex pattern.
+    # @param pattern [String]
+    # @return [String]
+    def self.map_iregexp(pattern)
+      escaped = false
+      char_class = false
+      mapped = String.new(encoding: "UTF-8")
+
+      pattern.each_char do |c|
+        if escaped
+          mapped << c
+          escaped = false
+          next
+        end
+
+        case c
+        when "."
+          # mapped << (char_class ? c : "(?:(?![\\r\\n])\\P{Cs}|\\p{Cs}\\p{Cs})")
+          mapped << (char_class ? c : "[^\\n\\r]")
+        when "\\"
+          escaped = true
+          mapped << "\\"
+        when "["
+          char_class = true
+          mapped << "["
+        when "]"
+          char_class = false
+          mapped << "]"
+        else
+          mapped << c
+        end
+      end
+
+      mapped
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/search.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "pattern"
+
+module JSONP3
+  module Path
+    # The standard `search` function.
+    class Search < FunctionExtension
+      ARG_TYPES = %i[value_expression value_expression].freeze
+      RETURN_TYPE = :logical_expression
+
+      # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
+      #   zero or negative to disable the cache.
+      # @param raise_errors [Boolean] if _false_ (the default), return _false_ when this
+      #   function causes a RegexpError instead of raising the exception.
+      def initialize(cache_size = 128, raise_errors: false)
+        super()
+        @cache_size = cache_size
+        @raise_errors = raise_errors
+        @cache = LRUCache.new(cache_size)
+      end
+
+      # @param value [String]
+      # @param pattern [String]
+      # @return Boolean
+      def call(value, pattern)
+        return false unless pattern.is_a?(String) && value.is_a?(String)
+
+        if @cache_size.positive?
+          re = @cache[pattern] || Regexp.new(JSONP3::Path.map_iregexp(pattern))
+        else
+          re = Regexp.new(JSONP3::Path.map_iregexp(pattern))
+          @cache[pattern] = re
+        end
+
+        re.match?(value)
+      rescue RegexpError
+        raise if @raise_errors
+
+        false
+      end
+    end
+  end
+end

data/lib/json_p3/path/function_extensions/value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JSONP3
+  module Path
+    # The standard `value` function.
+    class Value < FunctionExtension
+      ARG_TYPES = [:nodes_expression].freeze
+      RETURN_TYPE = :value_expression
+
+      def call(node_list)
+        node_list.length == 1 ? node_list.first.value : :nothing
+      end
+    end
+  end
+end