iso-jsonpath 1.1.6

data/lib/jsonpath/enumerable.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+class JsonPath
+  class Enumerable
+    include ::Enumerable
+    include Dig
+
+    def initialize(path, object, mode, options = {})
+      @path = path.path
+      @object = object
+      @mode = mode
+      @options = options
+    end
+
+    def each(context = @object, key = nil, pos = 0, &blk)
+      node = key ? dig_one(context, key) : context
+      @_current_node = node
+      return yield_value(blk, context, key) if pos == @path.size
+
+      case expr = @path[pos]
+      when '*', '..', '@'
+        each(context, key, pos + 1, &blk)
+      when '$'
+        if node == @object
+          each(context, key, pos + 1, &blk)
+        else
+          handle_wildcard(node, "['#{expr}']", context, key, pos, &blk)
+        end
+      when /^\[(.*)\]$/
+        handle_wildcard(node, expr, context, key, pos, &blk)
+      when /\(.*\)/
+        keys = expr.gsub(/[()]/, '').split(',').map(&:strip)
+        new_context = filter_context(context, keys)
+        yield_value(blk, new_context, key)
+      end
+
+      if pos > 0 && @path[pos - 1] == '..' || (@path[pos - 1] == '*' && @path[pos] != '..')
+        case node
+        when Hash  then node.each { |k, _| each(node, k, pos, &blk) }
+        when Array then node.each_with_index { |_, i| each(node, i, pos, &blk) }
+        end
+      end
+    end
+
+    private
+
+    def filter_context(context, keys)
+      case context
+      when Hash
+        dig_as_hash(context, keys)
+      when Array
+        context.each_with_object([]) do |c, memo|
+          memo << dig_as_hash(c, keys)
+        end
+      end
+    end
+
+    def handle_wildcard(node, expr, _context, _key, pos, &blk)
+      expr[1, expr.size - 2].split(',').each do |sub_path|
+        case sub_path[0]
+        when '\'', '"'
+          k = sub_path[1, sub_path.size - 2]
+          yield_if_diggable(node, k) do
+            each(node, k, pos + 1, &blk)
+          end
+        when '?'
+          handle_question_mark(sub_path, node, pos, &blk)
+        else
+          next if node.is_a?(Array) && node.empty?
+          next if node.nil? # when default_path_leaf_to_null is true
+          next if node.size.zero?
+
+          array_args = sub_path.split(':')
+          if array_args[0] == '*'
+            start_idx = 0
+            end_idx = node.size - 1
+          elsif sub_path.count(':') == 0
+            start_idx = end_idx = process_function_or_literal(array_args[0], 0)
+            next unless start_idx
+            next if start_idx >= node.size
+          else
+            start_idx = process_function_or_literal(array_args[0], 0)
+            next unless start_idx
+
+            end_idx = array_args[1] && ensure_exclusive_end_index(process_function_or_literal(array_args[1], -1)) || -1
+            next unless end_idx
+            next if start_idx == end_idx && start_idx >= node.size
+          end
+
+          start_idx %= node.size
+          end_idx %= node.size
+          step = process_function_or_literal(array_args[2], 1)
+          next unless step
+
+          if @mode == :delete
+            (start_idx..end_idx).step(step) { |i| node[i] = nil }
+            node.compact!
+          else
+            (start_idx..end_idx).step(step) { |i| each(node, i, pos + 1, &blk) }
+          end
+        end
+      end
+    end
+
+    def ensure_exclusive_end_index(value)
+      return value unless value.is_a?(Integer) && value > 0
+
+      value - 1
+    end
+
+    def handle_question_mark(sub_path, node, pos, &blk)
+      case node
+      when Array
+        node.size.times do |index|
+          @_current_node = node[index]
+          if process_function_or_literal(sub_path[1, sub_path.size - 1])
+            each(@_current_node, nil, pos + 1, &blk)
+          end
+        end
+      when Hash
+        if process_function_or_literal(sub_path[1, sub_path.size - 1])
+          each(@_current_node, nil, pos + 1, &blk)
+        end
+      else
+        yield node if process_function_or_literal(sub_path[1, sub_path.size - 1])
+      end
+    end
+
+    def yield_value(blk, context, key)
+      case @mode
+      when nil
+        blk.call(key ? dig_one(context, key) : context)
+      when :compact
+        if key && context[key].nil?
+          key.is_a?(Integer) ? context.delete_at(key) : context.delete(key)
+        end
+      when :delete
+        if key
+          key.is_a?(Integer) ? context.delete_at(key) : context.delete(key)
+        else
+          context.replace({})
+        end
+      when :substitute
+        if key
+          context[key] = blk.call(context[key])
+        else
+          context.replace(blk.call(context[key]))
+        end
+      end
+    end
+
+    def process_function_or_literal(exp, default = nil)
+      return default if exp.nil? || exp.empty?
+      return Integer(exp) if exp[0] != '('
+      return nil unless @_current_node
+
+      identifiers = /@?(((?<!\d)\.(?!\d)(\w+))|\['(.*?)'\])+/.match(exp)
+      # to filter arrays with known/unknown name.
+      if (!identifiers.nil? && !(@_current_node.methods.include?(identifiers[2]&.to_sym) || @_current_node.methods.include?(identifiers[4]&.to_sym)))
+        exp_to_eval = exp.dup
+        begin
+          return JsonPath::Parser.new(@_current_node, @options).parse(exp_to_eval)
+        rescue StandardError
+          return default
+        end
+      end
+      JsonPath::Parser.new(@_current_node, @options).parse(exp)
+    end
+  end
+end

data/lib/jsonpath/parser.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+class JsonPath
+  # Parser parses and evaluates an expression passed to @_current_node.
+  class Parser
+    include Dig
+
+    REGEX = /\A\/(.+)\/([imxnesu]*)\z|\A%r{(.+)}([imxnesu]*)\z/
+
+    def initialize(node, options)
+      @_current_node = node
+      @_expr_map = {}
+      @options = options
+    end
+
+    # parse will parse an expression in the following way.
+    # Split the expression up into an array of legs for && and || operators.
+    # Parse this array into a map for which the keys are the parsed legs
+    #  of the split. This map is then used to replace the expression with their
+    # corresponding boolean or numeric value. This might look something like this:
+    # ((false || false) && (false || true))
+    #  Once this string is assembled... we proceed to evaluate from left to right.
+    #  The above string is broken down like this:
+    # (false && (false || true))
+    # (false && true)
+    #  false
+    def parse(exp)
+      exps = exp.split(/(&&)|(\|\|)/)
+      construct_expression_map(exps)
+      @_expr_map.each { |k, v| exp.sub!(k, v.to_s) }
+      raise ArgumentError, "unmatched parenthesis in expression: #{exp}" unless check_parenthesis_count(exp)
+
+      exp = parse_parentheses(exp) while exp.include?('(')
+      bool_or_exp(exp)
+    end
+
+    # Construct a map for which the keys are the expressions
+    #  and the values are the corresponding parsed results.
+    # Exp.:
+    # {"(@['author'] =~ /herman|lukyanenko/i)"=>0}
+    # {"@['isTrue']"=>true}
+    def construct_expression_map(exps)
+      exps.each_with_index do |item, _index|
+        next if item == '&&' || item == '||'
+
+        item = item.strip.gsub(/\)*$/, '').gsub(/^\(*/, '')
+        @_expr_map[item] = parse_exp(item)
+      end
+    end
+
+    # Using a scanner break down the individual expressions and determine if
+    # there is a match in the JSON for it or not.
+    def parse_exp(exp)
+      exp = exp.sub(/@/, '').gsub(/^\(/, '').gsub(/\)$/, '').tr('"', '\'').strip
+      exp.scan(/^\[(\d+)\]/) do |i|
+        next if i.empty?
+
+        index = Integer(i[0])
+        raise ArgumentError, 'Node does not appear to be an array.' unless @_current_node.is_a?(Array)
+        raise ArgumentError, "Index out of bounds for nested array. Index: #{index}" if @_current_node.size < index
+
+        @_current_node = @_current_node[index]
+        # Remove the extra '' and the index.
+        exp = exp.gsub(/^\[\d+\]|\[''\]/, '')
+      end
+      scanner = StringScanner.new(exp)
+      elements = []
+      until scanner.eos?
+        if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_ ]+'\]/))
+          elements << t.gsub(/^\s*\[\s*'(.*)'\s*\]\s*$/, '\1')
+        elsif (t = scanner.scan(/\.[a-zA-Z0-9_]+[?]?/))
+          elements << t.gsub(/[\[\]'.]|\s+/, '')
+        elsif (t = scanner.scan(/(\s+)?[<>=!\-+][=~]?(\s+)?/))
+          operator = t
+        elsif (t = scanner.scan(/(\s+)?'?.*'?(\s+)?/))
+          # If we encounter a node which does not contain `'` it means
+          #  that we are dealing with a boolean type.
+          operand =
+            if t == 'true'
+              true
+            elsif t == 'false'
+              false
+            elsif operator.to_s.strip == '=~'
+              parse_regex(t)
+            else
+              t.gsub(%r{^'|'$}, '').strip
+            end
+        elsif (t = scanner.scan(/\/\w+\//))
+        elsif (t = scanner.scan(/.*/))
+          raise "Could not process symbol: #{t}"
+        end
+      end
+
+      el = if elements.empty?
+             @_current_node
+           elsif @_current_node.is_a?(Hash)
+             dig(@_current_node, *elements)
+           else
+             elements.inject(@_current_node, &:__send__)
+           end
+
+      return (el ? true : false) if el.nil? || operator.nil?
+
+      el = Float(el) rescue el
+      operand = Float(operand) rescue operand
+
+      el.__send__(operator.strip, operand)
+    end
+
+    private
+
+    # /foo/i -> Regex.new("foo", Regexp::IGNORECASE) without using eval
+    # also supports %r{foo}i
+    # following https://github.com/seamusabshere/to_regexp/blob/master/lib/to_regexp.rb
+    def parse_regex(t)
+      t =~ REGEX
+      content = $1 || $3
+      options = $2 || $4
+
+      raise ArgumentError, "unsupported regex #{t} use /foo/ style" if !content || !options
+
+      content = content.gsub '\\/', '/'
+
+      flags = 0
+      flags |= Regexp::IGNORECASE if options.include?('i')
+      flags |= Regexp::MULTILINE if options.include?('m')
+      flags |= Regexp::EXTENDED if options.include?('x')
+
+      # 'n' = none, 'e' = EUC, 's' = SJIS, 'u' = UTF-8
+      lang = options.scan(/[nes]/).join.downcase # ignores u since that is default and causes a warning
+
+      args = [content, flags]
+      args << lang unless lang.empty? # avoid warning
+      Regexp.new(*args)
+    end
+
+    #  This will break down a parenthesis from the left to the right
+    #  and replace the given expression with it's returned value.
+    # It does this in order to make it easy to eliminate groups
+    # one-by-one.
+    def parse_parentheses(str)
+      opening_index = 0
+      closing_index = 0
+
+      (0..str.length - 1).step(1) do |i|
+        opening_index = i if str[i] == '('
+        if str[i] == ')'
+          closing_index = i
+          break
+        end
+      end
+
+      to_parse = str[opening_index + 1..closing_index - 1]
+
+      #  handle cases like (true && true || false && true) in
+      # one giant parenthesis.
+      top = to_parse.split(/(&&)|(\|\|)/)
+      top = top.map(&:strip)
+      res = bool_or_exp(top.shift)
+      top.each_with_index do |item, index|
+        if item == '&&'
+          next_value = bool_or_exp(top[index + 1])
+          res &&= next_value
+        elsif item == '||'
+          next_value = bool_or_exp(top[index + 1])
+          res ||= next_value
+        end
+      end
+
+      #  if we are at the last item, the opening index will be 0
+      # and the closing index will be the last index. To avoid
+      # off-by-one errors we simply return the result at that point.
+      if closing_index + 1 >= str.length && opening_index == 0
+        res.to_s
+      else
+        "#{str[0..opening_index - 1]}#{res}#{str[closing_index + 1..str.length]}"
+      end
+    end
+
+    #  This is convoluted and I should probably refactor it somehow.
+    #  The map that is created will contain strings since essentially I'm
+    # constructing a string like `true || true && false`.
+    # With eval the need for this would disappear but never the less, here
+    #  it is. The fact is that the results can be either boolean, or a number
+    # in case there is only indexing happening like give me the 3rd item... or
+    # it also can be nil in case of regexes or things that aren't found.
+    # Hence, I have to be clever here to see what kind of variable I need to
+    # provide back.
+    def bool_or_exp(b)
+      if b.to_s == 'true'
+        return true
+      elsif b.to_s == 'false'
+        return false
+      elsif b.to_s == ''
+        return nil
+      end
+
+      b = Float(b) rescue b
+      b
+    end
+
+    # this simply makes sure that we aren't getting into the whole
+    #  parenthesis parsing business without knowing that every parenthesis
+    # has its pair.
+    def check_parenthesis_count(exp)
+      return true unless exp.include?('(')
+
+      depth = 0
+      exp.chars.each do |c|
+        if c == '('
+          depth += 1
+        elsif c == ')'
+          depth -= 1
+        end
+      end
+      depth == 0
+    end
+  end
+end

data/lib/jsonpath/proxy.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class JsonPath
+  class Proxy
+    attr_reader :obj
+    alias to_hash obj
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def gsub(path, replacement = nil, &replacement_block)
+      _gsub(_deep_copy, path, replacement ? proc(&method(:replacement)) : replacement_block)
+    end
+
+    def gsub!(path, replacement = nil, &replacement_block)
+      _gsub(@obj, path, replacement ? proc(&method(:replacement)) : replacement_block)
+    end
+
+    def delete(path = JsonPath::PATH_ALL)
+      _delete(_deep_copy, path)
+    end
+
+    def delete!(path = JsonPath::PATH_ALL)
+      _delete(@obj, path)
+    end
+
+    def compact(path = JsonPath::PATH_ALL)
+      _compact(_deep_copy, path)
+    end
+
+    def compact!(path = JsonPath::PATH_ALL)
+      _compact(@obj, path)
+    end
+
+    private
+
+    def _deep_copy
+      Marshal.load(Marshal.dump(@obj))
+    end
+
+    def _gsub(obj, path, replacement)
+      JsonPath.new(path)[obj, :substitute].each(&replacement)
+      Proxy.new(obj)
+    end
+
+    def _delete(obj, path)
+      JsonPath.new(path)[obj, :delete].each
+      obj = _remove(obj)
+      Proxy.new(obj)
+    end
+
+    def _remove(obj)
+      obj.each do |o|
+        if o.is_a?(Hash) || o.is_a?(Array)
+          _remove(o)
+          o.delete({})
+        end
+      end
+    end
+
+    def _compact(obj, path)
+      JsonPath.new(path)[obj, :compact].each
+      Proxy.new(obj)
+    end
+  end
+end

data/lib/jsonpath/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class JsonPath
+  VERSION = '1.1.6'
+end

data/lib/jsonpath.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'multi_json'
+require 'jsonpath/proxy'
+require 'jsonpath/dig'
+require 'jsonpath/enumerable'
+require 'jsonpath/version'
+require 'jsonpath/parser'
+
+# JsonPath: initializes the class with a given JsonPath and parses that path
+# into a token array.
+class JsonPath
+  PATH_ALL = '$..*'
+  MAX_NESTING_ALLOWED = 100
+
+  DEFAULT_OPTIONS = {
+    :default_path_leaf_to_null => false,
+    :symbolize_keys => false,
+    :use_symbols => false,
+    :allow_send => true,
+    :max_nesting => MAX_NESTING_ALLOWED
+  }
+
+  attr_accessor :path
+
+  def initialize(path, opts = {})
+    @opts = DEFAULT_OPTIONS.merge(opts)
+    set_max_nesting
+    scanner = StringScanner.new(path.strip)
+    @path = []
+    until scanner.eos?
+      if (token = scanner.scan(/\$\B|@\B|\*|\.\./))
+        @path << token
+      elsif (token = scanner.scan(/[$@\p{Alnum}:{}_ -]+/))
+        @path << "['#{token}']"
+      elsif (token = scanner.scan(/'(.*?)'/))
+        @path << "[#{token}]"
+      elsif (token = scanner.scan(/\[/))
+        @path << find_matching_brackets(token, scanner)
+      elsif (token = scanner.scan(/\]/))
+        raise ArgumentError, 'unmatched closing bracket'
+      elsif (token = scanner.scan(/\(.*\)/))
+        @path << token
+      elsif scanner.scan(/\./)
+        nil
+      elsif (token = scanner.scan(/[><=] \d+/))
+        @path.last << token
+      elsif (token = scanner.scan(/./))
+        @path.last << token
+      else
+        raise ArgumentError, "character '#{scanner.peek(1)}' not supported in query"
+      end
+    end
+  end
+
+  def find_matching_brackets(token, scanner)
+    count = 1
+    until count.zero?
+      if (t = scanner.scan(/\[/))
+        token << t
+        count += 1
+      elsif (t = scanner.scan(/\]/))
+        token << t
+        count -= 1
+      elsif (t = scanner.scan(/[^\[\]]+/))
+        token << t
+      elsif scanner.eos?
+        raise ArgumentError, 'unclosed bracket'
+      end
+    end
+    token
+  end
+
+  def join(join_path)
+    res = deep_clone
+    res.path += JsonPath.new(join_path).path
+    res
+  end
+
+  def on(obj_or_str, opts = {})
+    a = enum_on(obj_or_str).to_a
+    if symbolize_keys?(opts)
+      a.map! do |e|
+        e.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v; }
+      end
+    end
+    a
+  end
+
+  def self.fetch_all_path(obj)
+    all_paths = ['$']
+    find_path(obj, '$', all_paths, obj.class == Array)
+    return all_paths
+  end
+
+  def self.find_path(obj, root_key, all_paths, is_array = false)
+    obj.each do |key, value|
+      table_params = { key: key, root_key: root_key}
+      is_loop = value.class == Array || value.class == Hash
+      if is_loop
+        path_exp = construct_path(table_params)
+        all_paths << path_exp
+        find_path(value, path_exp, all_paths, value.class == Array)
+      elsif is_array
+        table_params[:index] = obj.find_index(key)
+        path_exp = construct_path(table_params)
+        find_path(key, path_exp, all_paths, key.class == Array) if key.class == Hash || key.class == Array
+        all_paths << path_exp
+      else
+        all_paths << construct_path(table_params)
+      end
+    end
+  end
+
+  def self.construct_path(table_row)
+    if table_row[:index]
+      return table_row[:root_key] + '['+ table_row[:index].to_s + ']'
+    else
+      return table_row[:root_key] + '.'+ table_row[:key]
+    end
+  end
+
+  def first(obj_or_str, *args)
+    enum_on(obj_or_str).first(*args)
+  end
+
+  def enum_on(obj_or_str, mode = nil)
+    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str, @opts), mode,
+                             @opts)
+  end
+  alias [] enum_on
+
+  def self.on(obj_or_str, path, opts = {})
+    new(path, opts).on(process_object(obj_or_str))
+  end
+
+  def self.for(obj_or_str)
+    Proxy.new(process_object(obj_or_str))
+  end
+
+  private
+
+  def self.process_object(obj_or_str, opts = {})
+    obj_or_str.is_a?(String) ? MultiJson.decode(obj_or_str, max_nesting: opts[:max_nesting]) : obj_or_str
+  end
+
+  def deep_clone
+    Marshal.load Marshal.dump(self)
+  end
+
+  def set_max_nesting
+    return unless @opts[:max_nesting].is_a?(Integer) && @opts[:max_nesting] > MAX_NESTING_ALLOWED
+    @opts[:max_nesting] = false
+  end
+
+  def symbolize_keys?(opts)
+    opts.fetch(:symbolize_keys, @opts&.dig(:symbolize_keys))
+  end
+end