jsonpath 0.9.3 → 1.1.5

data/lib/jsonpath/enumerable.rb

@@ -3,6 +3,7 @@
 class JsonPath
   class Enumerable
     include ::Enumerable
+    include Dig
 
     def initialize(path, object, mode, options = {})
       @path = path.path
@@ -12,16 +13,25 @@ class JsonPath
     end
 
     def each(context = @object, key = nil, pos = 0, &blk)
-      node = key ? context[key] : context
+      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 '$'
-        each(context, key, pos + 1, &blk) if node == @object
+        if node == @object
+          each(context, key, pos + 1, &blk)
+        else
+          handle_wildcard(node, "['#{expr}']", context, key, pos, &blk)
+        end
       when /^\[(.*)\]$/
-        handle_wildecard(node, expr, context, key, pos, &blk)
+        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] != '..')
@@ -34,34 +44,54 @@ class JsonPath
 
     private
 
-    def handle_wildecard(node, expr, _context, _key, pos, &blk)
+    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 '\'', '"'
-          if node.is_a?(Hash)
-            k = sub_path[1, sub_path.size - 2]
-            node[k] ||= nil if @options[:default_path_leaf_to_null]
-            each(node, k, pos + 1, &blk) if node.key?(k)
+          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] && process_function_or_literal(array_args[1], -1) || (sub_path.count(':') == 0 ? start_idx : -1))
+
+            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!
@@ -72,13 +102,17 @@ class JsonPath
       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]
-          # exps = sub_path[1, sub_path.size - 1]
-          # if @_current_node.send("[#{exps.gsub(/@/, '@_current_node')}]")
           if process_function_or_literal(sub_path[1, sub_path.size - 1])
             each(@_current_node, nil, pos + 1, &blk)
           end
@@ -93,10 +127,9 @@ class JsonPath
     end
 
     def yield_value(blk, context, key)
-      key = Integer(key) rescue key if key
       case @mode
       when nil
-        blk.call(key ? context[key] : context)
+        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)
@@ -104,6 +137,8 @@ class JsonPath
       when :delete
         if key
           key.is_a?(Integer) ? context.delete_at(key) : context.delete(key)
+        else
+          context.replace({})
         end
       when :substitute
         if key
@@ -119,19 +154,17 @@ class JsonPath
       return Integer(exp) if exp[0] != '('
       return nil unless @_current_node
 
-      identifiers = /@?((?<!\d)\.(?!\d)(\w+))+/.match(exp)
-      if !identifiers.nil? && !@_current_node.methods.include?(identifiers[2].to_sym)
+      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
-        exp_to_eval[identifiers[0]] = identifiers[0].split('.').map do |el|
-          el == '@' ? '@' : "['#{el}']"
-        end.join
         begin
-          return JsonPath::Parser.new(@_current_node).parse(exp_to_eval)
+          return JsonPath::Parser.new(@_current_node, @options).parse(exp_to_eval)
         rescue StandardError
           return default
         end
       end
-      JsonPath::Parser.new(@_current_node).parse(exp)
+      JsonPath::Parser.new(@_current_node, @options).parse(exp)
     end
   end
 end

data/lib/jsonpath/parser.rb

@@ -1,67 +1,105 @@
 # frozen_string_literal: true
 
 require 'strscan'
-require 'to_regexp'
 
 class JsonPath
   # Parser parses and evaluates an expression passed to @_current_node.
   class Parser
-    def initialize(node)
+    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(/(&&)|(\|\|)/)
-      ret = parse_exp(exps.shift)
-      exps.each_with_index do |item, index|
-        case item
-        when '&&'
-          ret &&= parse_exp(exps[index + 1])
-        when '||'
-          ret ||= parse_exp(exps[index + 1])
-        end
+      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
-      ret
     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 scanner.scan(/\./)
-          sym = scanner.scan(/\w+/)
-          op = scanner.scan(/./)
-          num = scanner.scan(/\d+/)
-          return @_current_node.send(sym.to_sym).send(op.to_sym, num.to_i)
-        end
-        if t = scanner.scan(/\['[a-zA-Z@&\*\/\$%\^\?_]+'\]+/)
-          elements << t.gsub(/\[|\]|'|\s+/, '')
-        elsif t = scanner.scan(/(\s+)?[<>=][=~]?(\s+)?/)
+        if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_]+'\]|\.[a-zA-Z0-9_]+[?]?/))
+          elements << t.gsub(/[\[\]'.]|\s+/, '')
+        elsif (t = scanner.scan(/(\s+)?[<>=!\-+][=~]?(\s+)?/))
           operator = t
-        elsif t = scanner.scan(/(\s+)?'?.*'?(\s+)?/)
+        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
-                    else
-                      operator.strip == '=~' ? t.to_regexp : t.delete("'").strip
-                    end
-        elsif t = scanner.scan(/\/\w+\//)
-        elsif t = scanner.scan(/.*/)
+          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
-             dig(elements, @_current_node)
+             elements.inject(@_current_node, &:__send__)
            end
-      return false if el.nil?
-      return true if operator.nil? && el
+
+      return (el ? true : false) if el.nil? || operator.nil?
 
       el = Float(el) rescue el
       operand = Float(operand) rescue operand
@@ -71,13 +109,111 @@ class JsonPath
 
     private
 
-    # @TODO: Remove this once JsonPath no longer supports ruby versions below 2.3
-    def dig(keys, hash)
-      return nil unless hash.is_a? Hash
-      return nil unless hash.key?(keys.first)
-      return hash.fetch(keys.first) if keys.size == 1
-      prev = keys.shift
-      dig(keys, hash.fetch(prev))
+    # /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

@@ -10,11 +10,11 @@ class JsonPath
     end
 
     def gsub(path, replacement = nil, &replacement_block)
-      _gsub(_deep_copy, path, replacement ? proc { replacement } : 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 { replacement } : replacement_block)
+      _gsub(@obj, path, replacement ? proc(&method(:replacement)) : replacement_block)
     end
 
     def delete(path = JsonPath::PATH_ALL)
@@ -46,9 +46,19 @@ class JsonPath
 
     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)

data/lib/jsonpath/version.rb

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

data/lib/jsonpath.rb

@@ -3,6 +3,7 @@
 require 'strscan'
 require 'multi_json'
 require 'jsonpath/proxy'
+require 'jsonpath/dig'
 require 'jsonpath/enumerable'
 require 'jsonpath/version'
 require 'jsonpath/parser'
@@ -11,30 +12,44 @@ require 'jsonpath/parser'
 # 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 = opts
+    @opts = DEFAULT_OPTIONS.merge(opts)
+    set_max_nesting
     scanner = StringScanner.new(path.strip)
     @path = []
     until scanner.eos?
-      if token = scanner.scan(/\$\B|@\B|\*|\.\./)
+      if (token = scanner.scan(/\$\B|@\B|\*|\.\./))
         @path << token
-      elsif token = scanner.scan(/[\$@a-zA-Z0-9:_-]+/)
+      elsif (token = scanner.scan(/[$@\p{Alnum}:{}_ -]+/))
         @path << "['#{token}']"
-      elsif token = scanner.scan(/'(.*?)'/)
+      elsif (token = scanner.scan(/'(.*?)'/))
         @path << "[#{token}]"
-      elsif token = scanner.scan(/\[/)
+      elsif (token = scanner.scan(/\[/))
         @path << find_matching_brackets(token, scanner)
-      elsif token = scanner.scan(/\]/)
+      elsif (token = scanner.scan(/\]/))
         raise ArgumentError, 'unmatched closing bracket'
+      elsif (token = scanner.scan(/\(.*\)/))
+        @path << token
       elsif scanner.scan(/\./)
         nil
-      elsif token = scanner.scan(/[><=] \d+/)
+      elsif (token = scanner.scan(/[><=] \d+/))
         @path.last << token
-      elsif token = scanner.scan(/./)
+      elsif (token = scanner.scan(/./))
         @path.last << token
+      else
+        raise ArgumentError, "character '#{scanner.peek(1)}' not supported in query"
       end
     end
   end
@@ -42,13 +57,13 @@ class JsonPath
   def find_matching_brackets(token, scanner)
     count = 1
     until count.zero?
-      if t = scanner.scan(/\[/)
+      if (t = scanner.scan(/\[/))
         token << t
         count += 1
-      elsif t = scanner.scan(/\]/)
+      elsif (t = scanner.scan(/\]/))
         token << t
         count -= 1
-      elsif t = scanner.scan(/[^\[\]]+/)
+      elsif (t = scanner.scan(/[^\[\]]+/))
         token << t
       elsif scanner.eos?
         raise ArgumentError, 'unclosed bracket'
@@ -63,8 +78,47 @@ class JsonPath
     res
   end
 
-  def on(obj_or_str)
-    enum_on(obj_or_str).to_a
+  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)
@@ -72,7 +126,7 @@ class JsonPath
   end
 
   def enum_on(obj_or_str, mode = nil)
-    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str), mode,
+    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str, @opts), mode,
                              @opts)
   end
   alias [] enum_on
@@ -87,11 +141,20 @@ class JsonPath
 
   private
 
-  def self.process_object(obj_or_str)
-    obj_or_str.is_a?(String) ? MultiJson.decode(obj_or_str) : obj_or_str
+  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