json_p3 0.2.1

data/lib/json_p3/filter.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "function"
+
+module JSONP3 # rubocop:disable Style/Documentation
+  # 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.truthy?(@expression.evaluate(context))
+    end
+
+    def to_s
+      @expression.to_s
+    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 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
+      JSON.generate(@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.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.truthy?(@left.evaluate(context)) && JSONP3.truthy?(@right.evaluate(context))
+    end
+
+    def to_s
+      "#{@left} && #{@right}"
+    end
+  end
+
+  # A logical `||` expression.
+  class LogicalOrExpression < InfixExpression
+    def evaluate(context)
+      JSONP3.truthy?(@left.evaluate(context)) || JSONP3.truthy?(@right.evaluate(context))
+    end
+
+    def to_s
+      "#{@left} || #{@right}"
+    end
+  end
+
+  # An `==` expression.
+  class EqExpression < InfixExpression
+    def evaluate(context)
+      JSONP3.eq?(@left.evaluate(context), @right.evaluate(context))
+    end
+
+    def to_s
+      "#{@left} == #{@right}"
+    end
+  end
+
+  # A `!=` expression.
+  class NeExpression < InfixExpression
+    def evaluate(context)
+      !JSONP3.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.eq?(left, right) || JSONP3.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.eq?(left, right) || JSONP3.lt?(right, left)
+    end
+
+    def to_s
+      "#{@left} >= #{@right}"
+    end
+  end
+
+  # A `<` expression.
+  class LtExpression < InfixExpression
+    def evaluate(context)
+      JSONP3.lt?(@left.evaluate(context), @right.evaluate(context))
+    end
+
+    def to_s
+      "#{@left} < #{@right}"
+    end
+  end
+
+  # A `>` expression.
+  class GtExpression < InfixExpression
+    def evaluate(context)
+      JSONP3.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 : JSONPathNodeList.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 RootQueryExpression < 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
+
+    # @param name [String]
+    # @param args [Array<Expression>]
+    def initialize(token, name, args)
+      super(token)
+      @name = name
+      @args = args
+    end
+
+    def evaluate(context)
+      func = context.env.function_extensions.fetch(@name)
+      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.map(&:to_s).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) # rubocop:disable Metrics/MethodLength
+      unpacked_args = []
+      args.each_with_index do |arg, i|
+        unless arg.is_a?(JSONPathNodeList) && func.class::ARG_TYPES[i] != ExpressionType::NODES
+          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?(JSONPathNodeList)
+    return false if obj == :nothing
+
+    obj != false
+  end
+
+  def self.eq?(left, right) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+    left = left.first.value if left.is_a?(JSONPathNodeList) && left.length == 1
+    right = right.first.value if right.is_a?(JSONPathNodeList) && right.length == 1
+
+    right, left = left, right if right.is_a?(JSONPathNodeList)
+
+    if left.is_a? JSONPathNodeList
+      return left == right if right.is_a? JSONPathNodeList
+      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) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    left = left.first.value if left.is_a?(JSONPathNodeList) && left.length == 1
+    right = right.first.value if right.is_a?(JSONPathNodeList) && 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

data/lib/json_p3/function.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JSONP3
+  class ExpressionType
+    VALUE = :value_expression
+    LOGICAL = :logical_expression
+    NODES = :nodes_expression
+  end
+
+  # Base class for all filter functions.
+  class FunctionExtension
+    def call(*_args, **_kwargs)
+      raise "function extensions must implement `call()`"
+    end
+  end
+end

data/lib/json_p3/function_extensions/count.rb

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

data/lib/json_p3/function_extensions/length.rb

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

data/lib/json_p3/function_extensions/match.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../cache"
+require_relative "../function"
+require_relative "pattern"
+
+module JSONP3
+  # The standard `match` function.
+  class Match < FunctionExtension
+    ARG_TYPES = [ExpressionType::VALUE, ExpressionType::VALUE].freeze
+    RETURN_TYPE = ExpressionType::LOGICAL
+
+    # @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) # rubocop:disable Metrics/MethodLength
+      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 = []
+      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.map_iregexp(pattern)
+      parts << ")\\z" if !explicit_caret && !explicit_dollar
+      parts.join
+    end
+  end
+end

data/lib/json_p3/function_extensions/pattern.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module JSONP3 # rubocop:disable Style/Documentation
+  # Map I-Regexp pattern to Ruby regex pattern.
+  # @param pattern [String]
+  # @return [String]
+  def self.map_iregexp(pattern) # rubocop:disable Metrics/MethodLength
+    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

data/lib/json_p3/function_extensions/search.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../cache"
+require_relative "../function"
+require_relative "pattern"
+
+module JSONP3
+  # The standard `search` function.
+  class Search < FunctionExtension
+    ARG_TYPES = [ExpressionType::VALUE, ExpressionType::VALUE].freeze
+    RETURN_TYPE = ExpressionType::LOGICAL
+
+    # @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) # rubocop:disable Metrics/MethodLength
+      return false unless pattern.is_a?(String) && value.is_a?(String)
+
+      if @cache_size.positive?
+        re = @cache[pattern] || Regexp.new(JSONP3.map_iregexp(pattern))
+      else
+        re = Regexp.new(JSONP3.map_iregexp(pattern))
+        @cache[pattern] = re
+      end
+
+      re.match?(value)
+    rescue RegexpError
+      raise if @raise_errors
+
+      false
+    end
+  end
+end

data/lib/json_p3/function_extensions/value.rb

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