json_p3 0.4.1 → 1.0.0

data/lib/json_p3/segment.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-module JSONP3
-  # Base class for all JSONPath segments.
-  class Segment
-    # @dynamic token, selectors
-    attr_reader :token, :selectors
-
-    def initialize(env, token, selectors)
-      @env = env
-      @token = token
-      @selectors = selectors
-    end
-
-    # Select the children of each node in _nodes_.
-    # @return [Array<JSONPathNode>]
-    def resolve(_nodes)
-      raise "segments must implement resolve(nodes)"
-    end
-
-    # Select the children of each node in _nodes_.
-    # @return [Enumerable<JSONPathNode>]
-    def resolve_enum(_nodes)
-      raise "segments must implement resolve_enum(nodes)"
-    end
-  end
-
-  # The child selection segment.
-  class ChildSegment < Segment
-    def resolve(nodes)
-      rv = [] # : Array[JSONPathNode]
-      nodes.each do |node|
-        @selectors.each do |selector|
-          rv.concat selector.resolve(node)
-        end
-      end
-      rv
-    end
-
-    def resolve_enum(nodes)
-      Enumerator.new do |yielder|
-        nodes.each do |node|
-          @selectors.each do |selector|
-            selector.resolve(node).each do |item|
-              yielder << item
-            end
-          end
-        end
-      end
-    end
-
-    def to_s
-      "[#{@selectors.map(&:to_s).join(", ")}]"
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @selectors == other.selectors &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      [@selectors, @token].hash
-    end
-  end
-
-  # The recursive descent segment
-  class RecursiveDescentSegment < Segment
-    def resolve(nodes)
-      rv = [] # : Array[JSONPathNode]
-      nodes.each do |node|
-        visit(node).each do |descendant|
-          @selectors.each do |selector|
-            rv.concat selector.resolve(descendant)
-          end
-        end
-      end
-      rv
-    end
-
-    def resolve_enum(nodes)
-      Enumerator.new do |yielder|
-        nodes.each do |node|
-          visit_enum(node).each do |descendant|
-            @selectors.each do |selector|
-              selector.resolve(descendant).each do |item|
-                yielder << item
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def to_s
-      "..[#{@selectors.map(&:to_s).join(", ")}]"
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @selectors == other.selectors &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      ["..", @selectors, @token].hash
-    end
-
-    protected
-
-    def visit(node, depth = 1)
-      raise JSONPathRecursionError.new("recursion limit exceeded", @token) if depth > @env.class::MAX_RECURSION_DEPTH
-
-      rv = [node]
-
-      if node.value.is_a? Array
-        node.value.each_with_index do |value, i|
-          child = JSONPathNode.new(value, [node.location, i], node.root)
-          rv.concat visit(child, depth + 1)
-        end
-      elsif node.value.is_a? Hash
-        node.value.each do |key, value|
-          child = JSONPathNode.new(value, [node.location, key], node.root)
-          rv.concat visit(child, depth + 1)
-        end
-      end
-
-      rv
-    end
-
-    def visit_enum(node, depth = 1)
-      raise JSONPathRecursionError.new("recursion limit exceeded", @token) if depth > @env.class::MAX_RECURSION_DEPTH
-
-      Enumerator.new do |yielder|
-        yielder << node
-        if node.value.is_a? Array
-          node.value.each_with_index do |value, i|
-            child = JSONPathNode.new(value, [node.location, i], node.root)
-            visit_enum(child, depth + 1).each do |item|
-              yielder << item
-            end
-          end
-        elsif node.value.is_a? Hash
-          node.value.each do |key, value|
-            child = JSONPathNode.new(value, [node.location, key], node.root)
-            visit_enum(child, depth + 1).each do |item|
-              yielder << item
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/json_p3/selector.rb

@@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-module JSONP3
-  # Base class for all JSONPath selectors
-  class Selector
-    # @dynamic token
-    attr_reader :token
-
-    def initialize(env, token)
-      @env = env
-      @token = token
-    end
-
-    # Apply this selector to _node_.
-    # @return [Array<JSONPathNode>]
-    def resolve(_node)
-      raise "selectors must implement resolve(node)"
-    end
-
-    # Apply this selector to _node_.
-    # @return [Enumerable<JSONPathNode>]
-    def resolve_enum(node)
-      resolve(node)
-    end
-
-    # Return true if this selector is a singular selector.
-    def singular?
-      false
-    end
-  end
-
-  # The name selector select values from hashes given a key.
-  class NameSelector < Selector
-    # @dynamic name
-    attr_reader :name
-
-    def initialize(env, token, name)
-      super(env, token)
-      @name = name
-    end
-
-    def resolve(node)
-      if node.value.is_a?(Hash) && node.value.key?(@name)
-        [node.new_child(node.value[@name], @name)]
-      else
-        []
-      end
-    end
-
-    def singular?
-      true
-    end
-
-    def to_s
-      JSONP3.canonical_string(@name)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @name == other.name &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      [@name, @token].hash
-    end
-  end
-
-  # This non-standard name selector selects values from hashes given a string or
-  # symbol key.
-  class SymbolNameSelector < NameSelector
-    def initialize(env, token, name)
-      super
-      @sym = @name.to_sym
-    end
-
-    def resolve(node)
-      if node.value.is_a?(Hash)
-        if node.value.key?(@name)
-          [node.new_child(node.value[@name], @name)]
-        elsif node.value.key?(@sym)
-          [node.new_child(node.value[@sym], @name)]
-        else
-          []
-        end
-      else
-        []
-      end
-    end
-  end
-
-  # The index selector selects values from arrays given an index.
-  class IndexSelector < Selector
-    # @dynamic index
-    attr_reader :index
-
-    def initialize(env, token, index)
-      super(env, token)
-      @index = index
-    end
-
-    def resolve(node)
-      if node.value.is_a?(Array)
-        norm_index = normalize(@index, node.value.length)
-        return [] if norm_index.negative? || norm_index >= node.value.length
-
-        [node.new_child(node.value[@index], norm_index)]
-      else
-        []
-      end
-    end
-
-    def singular?
-      true
-    end
-
-    def to_s
-      @index.to_s
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @index == other.index &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      [@index, @token].hash
-    end
-
-    private
-
-    def normalize(index, length)
-      index.negative? && length >= index.abs ? length + index : index
-    end
-  end
-
-  # The wildcard selector selects all elements from an array or values from a hash.
-  class WildcardSelector < Selector
-    def resolve(node)
-      if node.value.is_a? Hash
-        node.value.map { |k, v| node.new_child(v, k) }
-      elsif node.value.is_a? Array
-        node.value.map.with_index { |e, i| node.new_child(e, i) }
-      else
-        []
-      end
-    end
-
-    def resolve_enum(node)
-      if node.value.is_a? Hash
-        Enumerator.new do |yielder|
-          node.value.each do |k, v|
-            yielder << node.new_child(v, k)
-          end
-        end
-      elsif node.value.is_a? Array
-        Enumerator.new do |yielder|
-          node.value.each.with_index do |e, i|
-            yielder << node.new_child(e, i)
-          end
-        end
-      else
-        []
-      end
-    end
-
-    def to_s
-      "*"
-    end
-
-    def ==(other)
-      self.class == other.class && @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      @token.hash
-    end
-  end
-
-  # The slice selector selects a range of elements from an array.
-  class SliceSelector < Selector
-    # @dynamic start, stop, step
-    attr_reader :start, :stop, :step
-
-    def initialize(env, token, start, stop, step)
-      super(env, token)
-      @start = start
-      @stop = stop
-      @step = step || 1
-    end
-
-    def resolve(node)
-      return [] unless node.value.is_a?(Array)
-
-      length = node.value.length
-      return [] if length.zero? || @step.zero?
-
-      normalized_start = if @start.nil?
-                           @step.negative? ? length - 1 : 0
-                         elsif @start&.negative?
-                           [length + (@start || raise), 0].max
-                         else
-                           [@start || raise, length - 1].min
-                         end
-
-      normalized_stop = if @stop.nil?
-                          @step.negative? ? -1 : length
-                        elsif @stop&.negative?
-                          [length + (@stop || raise), -1].max
-                        else
-                          [@stop || raise, length].min
-                        end
-
-      (normalized_start...normalized_stop).step(@step).map { |i| node.new_child(node.value[i], i) }
-    end
-
-    def to_s
-      start = @start || ""
-      stop = @stop || ""
-      step = @step || 1
-      "#{start}:#{stop}:#{step}"
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @start == other.start &&
-        @stop == other.stop &&
-        @step == other.step &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      [@start, @stop, @step, @token].hash
-    end
-  end
-
-  # Select array elements or hash values according to a filter expression.
-  class FilterSelector < Selector
-    # @dynamic expression
-    attr_reader :expression
-
-    def initialize(env, token, expression)
-      super(env, token)
-      @expression = expression
-    end
-
-    def resolve(node)
-      nodes = [] # : Array[JSONPathNode]
-
-      if node.value.is_a?(Array)
-        node.value.each_with_index do |e, i|
-          context = FilterContext.new(@env, e, node.root)
-          nodes << node.new_child(e, i) if @expression.evaluate(context)
-        end
-      elsif node.value.is_a?(Hash)
-        node.value.each_pair do |k, v|
-          context = FilterContext.new(@env, v, node.root)
-          nodes << node.new_child(v, k) if @expression.evaluate(context)
-        end
-      end
-
-      nodes
-    end
-
-    def resolve_enum(node)
-      Enumerator.new do |yielder|
-        if node.value.is_a?(Array)
-          node.value.each_with_index do |e, i|
-            context = FilterContext.new(@env, e, node.root)
-            yielder << node.new_child(e, i) if @expression.evaluate(context)
-          end
-        elsif node.value.is_a?(Hash)
-          node.value.each_pair do |k, v|
-            context = FilterContext.new(@env, v, node.root)
-            yielder << node.new_child(v, k) if @expression.evaluate(context)
-          end
-        end
-      end
-    end
-
-    def to_s
-      "?#{@expression}"
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @expression == other.start &&
-        @token == other.token
-    end
-
-    alias eql? ==
-
-    def hash
-      [@expression, @token].hash
-    end
-  end
-end

data/lib/json_p3/serialize.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module JSONP3 # rubocop:disable Style/Documentation
-  TRANS = { "\\\"" => "\"", "'" => "\\'" }.freeze
-
-  # Return _value_ formatted as a canonical string literal.
-  # @param value [String]
-  def self.canonical_string(value)
-    "'#{(JSON.dump(value)[1..-2] || raise).gsub(/('|\\")/, TRANS)}'"
-  end
-end

data/lib/json_p3/token.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "errors"
-
-module JSONP3
-  # Tokens are produced by the lexer and consumed by the parser. Each token contains sub
-  # string from a JSONPath expression, its location within the JSONPath expression and a
-  # symbol indicating what type of token it is.
-  class Token
-    # @dynamic type, value, start, query, message
-    attr_reader :type, :value, :start, :query, :message
-
-    def initialize(type, value, start, query, message: nil)
-      @type = type
-      @value = value
-      @start = start
-      @query = query
-      @message = message
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @type == other.type &&
-        @value == other.value &&
-        @start == other.start &&
-        @query == other.query &&
-        @message == other.message
-    end
-
-    alias eql? ==
-
-    def hash
-      [@type, @value].hash
-    end
-  end
-end

data/lib/json_p3/unescape.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module JSONP3 # rubocop:disable Style/Documentation
-  # Replace escape sequences with their equivalent Unicode code point.
-  # @param value [String]
-  # @param quote [String] one of '"' or "'".
-  # @param token [Token]
-  # @return [String] A new string without escape sequences.
-  def self.unescape_string(value, quote, token)
-    unescaped = String.new(encoding: "UTF-8")
-    index = 0
-    length = value.length
-
-    while index < length
-      ch = value[index] || raise
-      if ch == "\\"
-        index += 1
-        case value[index]
-        when quote
-          unescaped << quote
-        when "\\"
-          unescaped << "\\"
-        when "/"
-          unescaped << "/"
-        when "b"
-          unescaped << "\x08"
-        when "f"
-          unescaped << "\x0C"
-        when "n"
-          unescaped << "\n"
-        when "r"
-          unescaped << "\r"
-        when "t"
-          unescaped << "\t"
-        when "u"
-          code_point, index = JSONP3.decode_hex_char(value, index, token)
-          unescaped << JSONP3.code_point_to_string(code_point, token)
-        else
-          raise JSONPathSyntaxError.new("unknown escape sequence", token)
-        end
-      else
-        raise JSONPathSyntaxError.new("invalid character", token) if ch.ord <= 0x1F
-
-        unescaped << ch
-      end
-
-      index += 1
-
-    end
-
-    unescaped
-  end
-
-  def self.decode_hex_char(value, index, token)
-    length = value.length
-
-    raise JSONPathSyntaxError.new("incomplete escape sequence", token) if index + 4 >= length
-
-    index += 1 # move past 'u'
-    code_point = parse_hex_digits(value[index, 4], token)
-
-    raise JSONPathSyntaxError.new("unexpected low surrogate", token) if low_surrogate?(code_point)
-
-    return [code_point, index + 3] unless high_surrogate?(code_point)
-
-    unless index + 9 < length && value[index + 4] == "\\" && value[index + 5] == "u"
-      raise JSONPathSyntaxError.new("incomplete escape sequence", token)
-    end
-
-    low_surrogate = parse_hex_digits(value[index + 6, 10], token)
-
-    raise JSONPathSyntaxError.new("unexpected low surrogate", token) unless low_surrogate?(low_surrogate)
-
-    code_point = 0x10000 + (
-      ((code_point & 0x03FF) << 10) | (low_surrogate & 0x03FF)
-    )
-
-    [code_point, index + 9]
-  end
-
-  def self.parse_hex_digits(digits, token)
-    code_point = 0
-    digits.each_byte do |b|
-      code_point <<= 4
-      case b
-      when 48..57
-        code_point |= b - 48
-      when 65..70
-        code_point |= b - 65 + 10
-      when 97..102
-        code_point |= b - 97 + 10
-      else
-        raise JSONPathSyntaxError.new("invalid escape sequence", token)
-      end
-    end
-    code_point
-  end
-
-  def self.high_surrogate?(code_point)
-    code_point >= 0xD800 && code_point <= 0xDBFF
-  end
-
-  def self.low_surrogate?(code_point)
-    code_point >= 0xDC00 && code_point <= 0xDFFF
-  end
-
-  def self.code_point_to_string(code_point, token)
-    raise JSONPathSyntaxError.new("invalid character", token) if code_point <= 0x1F
-
-    code_point.chr(Encoding::UTF_8)
-  end
-end