json_p3 0.2.1

data/lib/json_p3/selector.rb

@@ -0,0 +1,285 @@
+# 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
+
+    # 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
+      @name.inspect
+    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) # rubocop:disable Metrics/MethodLength
+      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 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) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      return [] unless node.value.is_a?(Array)
+
+      length = node.value.length
+      return [] if length.zero? || @step.zero?
+
+      norm_start = normalized_start(length)
+      norm_stop = normalized_stop(length)
+
+      nodes = []
+
+      if @step.positive?
+
+        for i in (norm_start...norm_stop).step(@step) # rubocop:disable Style/For
+          nodes << node.new_child(node.value[i], i)
+        end
+      else
+        i = norm_start
+        while i > norm_stop
+          nodes << node.new_child(node.value[i], i)
+          i += @step
+        end
+      end
+      nodes
+    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
+
+    private
+
+    def normalized_start(length)
+      # NOTE: trying to please the type checker :(
+      return @step.negative? ? length - 1 : 0 if @start.nil?
+      return [length + (@start || raise), 0].max if @start&.negative?
+
+      [@start || raise, length - 1].min
+    end
+
+    def normalized_stop(length)
+      # NOTE: trying to please the type checker :(
+      return @step.negative? ? -1 : length if @stop.nil?
+      return [length + (@stop || raise), -1].max if @stop&.negative?
+
+      [@stop || raise, length].min
+    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) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      nodes = []
+
+      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 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/token.rb

@@ -0,0 +1,74 @@
+# 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
+    EOI = :token_eoi
+    ERROR = :token_error
+
+    SHORTHAND_NAME = :token_shorthand_name
+    COLON = :token_colon
+    COMMA = :token_comma
+    DOT = :token_dot
+    DOUBLE_DOT = :token_double_dot
+    FILTER = :token_filter
+    INDEX = :token_index
+    LBRACKET = :token_lbracket
+    NAME = :token_name
+    RBRACKET = :token_rbracket
+    ROOT = :token_root
+    WILD = :token_wild
+
+    AND = :token_and
+    CURRENT = :token_current
+    DOUBLE_QUOTE_STRING = :token_double_quote_string
+    EQ = :token_eq
+    FALSE = :token_false
+    FLOAT = :token_float
+    FUNCTION = :token_function
+    GE = :token_ge
+    GT = :token_gt
+    INT = :token_int
+    LE = :token_le
+    LPAREN = :token_lparen
+    LT = :token_lt
+    NE = :token_ne
+    NOT = :token_not
+    NULL = :token_null
+    OP = :token_op
+    OR = :token_or
+    RPAREN = :token_rparen
+    SINGLE_QUOTE_STRING = :token_single_quote_string
+    TRUE = :token_true
+
+    # @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

@@ -0,0 +1,112 @@
+# 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) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    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) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    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...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...index + 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) # rubocop:disable Metrics/MethodLength
+    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

data/lib/json_p3/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JSONP3
+  VERSION = "0.2.1"
+end

data/lib/json_p3.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "json_p3/version"
+require_relative "json_p3/environment"
+
+# RFC 9535 JSONPath query expressions for JSON.
+module JSONP3
+  DefaultEnvironment = JSONPathEnvironment.new
+
+  def self.find(path, data)
+    DefaultEnvironment.find(path, data)
+  end
+
+  def self.compile(path)
+    DefaultEnvironment.compile(path)
+  end
+end

data/performance/benchmark.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "json"
+require "json_p3"
+
+CTS = JSON.parse(File.read("test/cts/cts.json"))
+VALID_QUERIES = CTS["tests"].filter { |t| !t.key?("invalid_selector") }
+COMPILED_QUERIES = VALID_QUERIES.map { |t| [JSONP3.compile(t["selector"]), t["document"]] }
+
+n = 100
+
+puts "repeating #{VALID_QUERIES.length} queries #{n} times"
+
+Benchmark.bmbm(18) do |x|
+  x.report("compile and find:") do
+    n.times do
+      VALID_QUERIES.map { |t| JSONP3.find(t["selector"], t["document"]) }
+    end
+  end
+
+  x.report("just compile:") do
+    n.times do
+      VALID_QUERIES.map { |t| JSONP3.compile(t["selector"]) }
+    end
+  end
+
+  x.report("just find:") do
+    n.times do
+      COMPILED_QUERIES.map { |p, d| p.find(d) }
+    end
+  end
+end

data/performance/benchmark_ips.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "json"
+require "json_p3"
+
+CTS = JSON.parse(File.read("test/cts/cts.json"))
+VALID_QUERIES = CTS["tests"].filter { |t| !t.key?("invalid_selector") }
+COMPILED_QUERIES = VALID_QUERIES.map { |t| [JSONP3.compile(t["selector"]), t["document"]] }
+
+puts "#{VALID_QUERIES.length} queries per iteration"
+
+Benchmark.ips do |x|
+  # Configure the number of seconds used during
+  # the warmup phase (default 2) and calculation phase (default 5)
+  x.config(warmup: 2, time: 5)
+
+  x.report("compile and find:") do
+    VALID_QUERIES.map { |t| JSONP3.find(t["selector"], t["document"]) }
+  end
+
+  x.report("just compile:") do
+    VALID_QUERIES.map { |t| JSONP3.compile(t["selector"]) }
+  end
+
+  x.report("just find:") do
+    COMPILED_QUERIES.map { |p, d| p.find(d) }
+  end
+end

data/performance/benchmark_small_citylots.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "json"
+require "json_p3"
+
+# TODO: include small-citylots.json as a git submodule
+DATA = JSON.parse(File.read("/tmp/small-citylots.json")).freeze
+
+Benchmark.bm(15) do |x|
+  x.report("deep:") do
+    JSONP3.find("$.features..properties.BLOCK_NUM", DATA)
+  end
+
+  x.report("shallow:") do
+    JSONP3.find("$.features..properties", DATA)
+  end
+end

data/performance/memory_profile.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "memory_profiler"
+require "json"
+require "json_p3"
+
+CTS = JSON.parse(File.read("test/cts/cts.json"))
+VALID_QUERIES = CTS["tests"].filter { |t| !t.key?("invalid_selector") }
+COMPILED_QUERIES = VALID_QUERIES.map { |t| [JSONP3.compile(t["selector"]), t["document"]] }
+
+n = 10
+
+report = MemoryProfiler.report do
+  n.times do
+    VALID_QUERIES.map { |t| JSONP3.compile(t["selector"]) }
+  end
+end
+
+report.pretty_print

data/performance/memory_profile_small_citylots.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "memory_profiler"
+require "json"
+require "json_p3"
+
+# TODO: include small-citylots.json as a git submodule
+DATA = JSON.parse(File.read("/tmp/small-citylots.json")).freeze
+
+report = MemoryProfiler.report do
+  JSONP3.find("$.features..properties", DATA)
+end
+
+report.pretty_print

data/performance/profile.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "stackprof"
+
+require "json"
+require "json_p3"
+
+CTS = JSON.parse(File.read("test/cts/cts.json"))
+VALID_QUERIES = CTS["tests"].filter { |t| t.key?("result") }
+COMPILED_QUERIES = VALID_QUERIES.map { |t| [JSONP3.compile(t["selector"]), t["document"]] }
+
+n = 100
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-compile-and-find.dump") do
+  n.times do
+    VALID_QUERIES.map { |t| JSONP3.find(t["selector"], t["document"]) }
+  end
+end
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-just-compile.dump") do
+  n.times do
+    VALID_QUERIES.map { |t| JSONP3.compile(t["selector"]) }
+  end
+end
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-just-find.dump") do
+  n.times do
+    COMPILED_QUERIES.map { |p, d| p.find(d) }
+  end
+end