jsonpath 0.5.8 → 1.1.0

data/lib/jsonpath/enumerable.rb

@@ -1,95 +1,139 @@
+# frozen_string_literal: true
+
 class JsonPath
   class Enumerable
     include ::Enumerable
-    attr_reader :allow_eval
-    alias_method :allow_eval?, :allow_eval
+    include Dig
 
-    def initialize(path, object, mode, options = nil)
-      @path, @object, @mode, @options = path.path, object, mode, options
-      @allow_eval = @options && @options.key?(:allow_eval) ? @options[:allow_eval] : true
+    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 ? 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 '*', '..'
+      when '*', '..', '@'
         each(context, key, pos + 1, &blk)
       when '$'
         each(context, key, pos + 1, &blk) if node == @object
-      when '@'
-        each(context, key, pos + 1, &blk)
       when /^\[(.*)\]$/
-        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]
-              each(node, k, pos + 1, &blk) if node.key?(k)
-            end
-          when ??
-            raise "Cannot use ?(...) unless eval is enabled" unless allow_eval?
-            case node
-            when Hash, Array
-              (node.is_a?(Hash) ? node.keys : (0..node.size)).each do |e|
-                @_current_node = node[e]
-                if process_function_or_literal(sub_path[1, sub_path.size - 1])
-                  each(@_current_node, nil, pos + 1, &blk)
-                end
-              end
-            else
-              yield node if process_function_or_literal(sub_path[1, sub_path.size - 1])
-            end
+        handle_wildecard(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_wildecard(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
+
+          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
-            if node.is_a?(Array)
-              next if node.empty?
-              array_args = sub_path.split(':')
-              if array_args[0] == ?*
-                start_idx = 0
-                end_idx = node.size - 1
-              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))
-                next unless end_idx
-                if start_idx == end_idx
-                  next unless start_idx < node.size 
-                end
-              end
-              start_idx %= node.size
-              end_idx %= node.size
-              step = process_function_or_literal(array_args[2], 1)
-              next unless step
-              (start_idx..end_idx).step(step) {|i| each(node, i, pos + 1, &blk)}
-            end
+            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
-        end
-      else
-        if pos == (@path.size - 1) && node && allow_eval?
-          if eval("node #{@path[pos]}")
-            yield_value(blk, context, key)
+          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
 
-      if pos > 0 && @path[pos-1] == '..'
-        case node
-        when Hash  then node.each {|k, v| each(node, k, pos, &blk) }
-        when Array then node.each_with_index {|n, i| each(node, i, pos, &blk) }
+    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
 
-    private
     def yield_value(blk, context, key)
       case @mode
       when nil
-        blk.call(key ? context[key] : context)
+        blk.call(key ? dig_one(context, key) : context)
       when :compact
-        context.delete(key) if key && context[key].nil?
+        if key && context[key].nil?
+          key.is_a?(Integer) ? context.delete_at(key) : context.delete(key)
+        end
       when :delete
-        context.delete(key) if key
+        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])
@@ -100,36 +144,23 @@ class JsonPath
     end
 
     def process_function_or_literal(exp, default = nil)
-      if exp.nil?
-        default
-      elsif exp[0] == ?(
-        return nil unless allow_eval? && @_current_node
-        identifiers = /@?(\.(\w+))+/.match(exp)
-
-        if !identifiers.nil? && !@_current_node.methods.include?(identifiers[2].to_sym)
-          exp_to_eval = exp.dup
-          exp_to_eval[identifiers[0]] = identifiers[0].split('.').map{|el| el == '@' ? '@_current_node' : "['#{el}']"}.join
-          begin
-            return eval(exp_to_eval)
-          rescue StandardError # if eval failed because of bad arguments or missing methods
-            return default
-          end
-        end
+      return default if exp.nil? || exp.empty?
+      return Integer(exp) if exp[0] != '('
+      return nil unless @_current_node
 
-        # otherwise eval as is
-        # TODO: this eval is wrong, because hash accessor could be nil and nil cannot be compared with anything,
-        # for instance, @_current_node['price'] - we can't be sure that 'price' are in every node, but it's only in several nodes
-        # I wrapped this eval into rescue returning false when error, but this eval should be refactored.
+      identifiers = /@?((?<!\d)\.(?!\d)(\w+))+/.match(exp)
+      if !identifiers.nil? && !@_current_node.methods.include?(identifiers[2].to_sym)
+        exp_to_eval = exp.dup
+        exp_to_eval[identifiers[0]] = identifiers[0].split('.').map do |el|
+          el == '@' ? '@' : "['#{el}']"
+        end.join
         begin
-          eval(exp.gsub(/@/, '@_current_node'))
-        rescue
-          false
+          return JsonPath::Parser.new(@_current_node, @options).parse(exp_to_eval)
+        rescue StandardError
+          return default
         end
-      elsif exp.empty?
-        default
-      else
-        Integer(exp)
       end
+      JsonPath::Parser.new(@_current_node, @options).parse(exp)
     end
   end
 end

data/lib/jsonpath/parser.rb

@@ -0,0 +1,217 @@
+# 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@&*\/$%^?_]+'\]|\.[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 == '&&'
+          res &&= top[index + 1]
+        elsif item == '||'
+          res ||= top[index + 1]
+        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

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 class JsonPath
   class Proxy
     attr_reader :obj
-    alias_method :to_hash, :obj
+    alias to_hash obj
 
     def initialize(obj)
       @obj = obj
     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)
@@ -32,8 +34,9 @@ class JsonPath
     end
 
     private
+
     def _deep_copy
-      Marshal::load(Marshal::dump(@obj))
+      Marshal.load(Marshal.dump(@obj))
     end
 
     def _gsub(obj, path, replacement)
@@ -43,12 +46,22 @@ 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)
     end
   end
-end
+end

data/lib/jsonpath/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsonPath
-  VERSION = '0.5.8'
-end
+  VERSION = '1.1.0'
+end

data/lib/jsonpath.rb

@@ -1,58 +1,74 @@
+# 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 = '$..*'
 
+  DEFAULT_OPTIONS = {
+    :default_path_leaf_to_null => false,
+    :symbolize_keys => false,
+    :use_symbols => false,
+    :allow_send => true
+  }
+
   attr_accessor :path
 
-  def initialize(path, opts = nil)
-    @opts = opts
-    scanner = StringScanner.new(path)
+  def initialize(path, opts = {})
+    @opts = DEFAULT_OPTIONS.merge(opts)
+    scanner = StringScanner.new(path.strip)
     @path = []
-    while not scanner.eos?
-      if token = scanner.scan(/\$/)
-        @path << token
-      elsif token = scanner.scan(/@/)
+    until scanner.eos?
+      if (token = scanner.scan(/\$\B|@\B|\*|\.\./))
         @path << token
-      elsif token = scanner.scan(/[a-zA-Z0-9_-]+/)
+      elsif (token = scanner.scan(/[$@a-zA-Z0-9:{}_-]+/))
         @path << "['#{token}']"
-      elsif token = scanner.scan(/'(.*?)'/)
+      elsif (token = scanner.scan(/'(.*?)'/))
         @path << "[#{token}]"
-      elsif token = scanner.scan(/\[/)
-        count = 1
-        while !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
-        @path << token
-      elsif token = scanner.scan(/\]/)
+      elsif (token = scanner.scan(/\[/))
+        @path << find_matching_brackets(token, scanner)
+      elsif (token = scanner.scan(/\]/))
         raise ArgumentError, 'unmatched closing bracket'
-      elsif token = scanner.scan(/\.\./)
+      elsif (token = scanner.scan(/\(.*\)/))
         @path << token
       elsif scanner.scan(/\./)
         nil
-      elsif token = scanner.scan(/\*/)
-        @path << token
-      elsif token = scanner.scan(/[><=] \d+/)
-        @path.last << token
-      elsif token = scanner.scan(/./)
+      elsif (token = scanner.scan(/[><=] \d+/))
         @path.last << token
+      elsif (token = scanner.scan(/./))
+        begin
+          @path.last << token
+        rescue RuntimeError
+          raise ArgumentError, "character '#{token}' not supported in query"
+        end
+      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)
@@ -61,8 +77,14 @@ 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 opts[:symbolize_keys]
+      a.map! do |e|
+        e.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v; }
+      end
+    end
+    a
   end
 
   def first(obj_or_str, *args)
@@ -70,12 +92,13 @@ class JsonPath
   end
 
   def enum_on(obj_or_str, mode = nil)
-    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str), mode, @opts)
+    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str), mode,
+                             @opts)
   end
-  alias_method :[], :enum_on
+  alias [] enum_on
 
-  def self.on(obj_or_str, path, opts = nil)
-    self.new(path, opts).on(process_object(obj_or_str))
+  def self.on(obj_or_str, path, opts = {})
+    new(path, opts).on(process_object(obj_or_str))
   end
 
   def self.for(obj_or_str)
@@ -83,6 +106,7 @@ class JsonPath
   end
 
   private
+
   def self.process_object(obj_or_str)
     obj_or_str.is_a?(String) ? MultiJson.decode(obj_or_str) : obj_or_str
   end