json_p3 0.4.1 → 1.0.0

data/lib/json_p3/filter.rb

@@ -1,459 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "function"
-require_relative "serialize"
-
-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
-      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.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.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)
-      unpacked_args = [] # : Array[Object]
-      args.each_with_index do |arg, i|
-        unless arg.is_a?(JSONPathNodeList) && 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?(JSONPathNodeList)
-    return false if obj == :nothing
-
-    obj != false
-  end
-
-  def self.eq?(left, right)
-    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)
-    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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module JSONP3
-  # 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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../function"
-
-module JSONP3
-  # 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

data/lib/json_p3/function_extensions/length.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../function"
-
-module JSONP3
-  # 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

data/lib/json_p3/function_extensions/match.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../cache"
-require_relative "../function"
-require_relative "pattern"
-
-module JSONP3
-  # 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.map_iregexp(pattern)
-      parts << ")\\z" if !explicit_caret && !explicit_dollar
-      parts.join
-    end
-  end
-end

data/lib/json_p3/function_extensions/pattern.rb

@@ -1,39 +0,0 @@
-# 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)
-    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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../cache"
-require_relative "../function"
-require_relative "pattern"
-
-module JSONP3
-  # 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.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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../function"
-
-module JSONP3
-  # 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