jsonpath 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 762aacec760a67a4097f47df701a1cec0f3f524ae016a2b724873c625c25672d
-  data.tar.gz: a3076196bc9d30f4cad3ee9c0ab3d58f9bedef4b7d17d7934e7e930c351ee1c0
+  metadata.gz: 27b1b5e54ebef03b9cde7f447c1dc6fb8e411b4a28f5039426c87782b250ab1a
+  data.tar.gz: ae08f25885125bde4f301d905b9c6446bf0e922516aabce101a4e90088fd6e68
 SHA512:
-  metadata.gz: 7894391f0693b7ebb3f3d8bca20dcf2eeb54af85e6ca268ff75fe120c64ae5e8ff09fa9a7b82cacbb8a5776d03dfa0f9bcc1f4716eea63988910cbb501d64236
-  data.tar.gz: c0f5c57d5c527a432a1c02fa728e32f8f8a7009efd0a31778b2766d97eba1e752ec1779e2d725fc233731f64541be72c9e896a511f312f8b5e3a4a1ed3e31a8d
+  metadata.gz: e4e778c37086407f3fb101b23c7f0507c48f0714ad2ae671d14ce52a2397e18f0f7433b8fa0fe651e503285002b4db1b70dad91ae4de1cf51b948f9ec736818b
+  data.tar.gz: b0dac82fcb16862190ae1405680d4779d6b3208d6ad31e25e5b0eb800877ca8bf56bae2789bac11452dfd872593071334205208bcb3a7320e3a8c0b94ba206c9

data/.gitignore

@@ -5,3 +5,6 @@ doc/*
 .yardoc
 .DS_Store
 .idea
+vendor
+.tags
+*.gem

data/.travis.yml

@@ -1,11 +1,8 @@
 language: ruby
 rvm:
-  - 2.3.8
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.5
+  - 2.6
+  - 2.7
   - ruby-head
   - jruby-head
-
-before_install:
-  - gem install bundler -v '< 2'
+  - truffleruby-head

data/README.md

@@ -4,8 +4,8 @@ This is an implementation of http://goessner.net/articles/JsonPath/.
 
 ## What is JsonPath?
 
-JsonPath is a way of addressing elements within a JSON object. Similar to xpath of yore, JsonPath lets you
-traverse a json object and manipulate or access it.
+JsonPath is a way of addressing elements within a JSON object. Similar to xpath
+of yore, JsonPath lets you traverse a json object and manipulate or access it.
 
 ## Usage
 
@@ -15,8 +15,8 @@ There is stand-alone usage through the binary `jsonpath`
 
     jsonpath [expression] (file|string)
 
-    If you omit the second argument, it will read stdin, assuming one valid JSON object
-    per line. Expression must be a valid jsonpath expression.
+    If you omit the second argument, it will read stdin, assuming one valid JSON
+    object per line. Expression must be a valid jsonpath expression.
 
 ### Library
 
@@ -40,8 +40,8 @@ json = <<-HERE_DOC
 HERE_DOC
 ```
 
-Now that we have a JSON object, let's get all the prices present in the object. We create an object for the path
-in the following way.
+Now that we have a JSON object, let's get all the prices present in the object.
+We create an object for the path in the following way.
 
 ```ruby
 path = JsonPath.new('$..price')
@@ -54,14 +54,15 @@ path.on(json)
 # => [19.95, 8.95, 12.99, 8.99, 22.99]
 ```
 
-Or on some other object ...
+Or reuse it later on some other object (thread safe) ...
 
 ```ruby
 path.on('{"books":[{"title":"A Tale of Two Somethings","price":18.88}]}')
 # => [18.88]
 ```
 
-You can also just combine this into one mega-call with the convenient `JsonPath.on` method.
+You can also just combine this into one mega-call with the convenient
+`JsonPath.on` method.
 
 ```ruby
 JsonPath.on(json, '$..author')
@@ -73,29 +74,36 @@ Of course the full JsonPath syntax is supported, such as array slices
 ```ruby
 JsonPath.new('$..book[::2]').on(json)
 # => [
-#      {"price"=>8.95, "category"=>"reference", "author"=>"Nigel Rees", "title"=>"Sayings of the Century"},
-#      {"price"=>8.99, "category"=>"fiction", "author"=>"Herman Melville", "title"=>"Moby Dick", "isbn"=>"0-553-21311-3"}
+#      {"price" => 8.95, "category" => "reference", "title" => "Sayings of the Century", "author" => "Nigel Rees"},
+#      {"price" => 8.99, "category" => "fiction", "isbn" => "0-553-21311-3", "title" => "Moby Dick", "author" => "Herman Melville","color" => "blue"},
 #    ]
 ```
 
-...and evals.
+...and evals, including those with conditional operators
 
 ```ruby
-JsonPath.new('$..price[?(@ < 10)]').on(json)
+JsonPath.new("$..price[?(@ < 10)]").on(json)
 # => [8.95, 8.99]
+
+JsonPath.new("$..book[?(@['price'] == 8.95 || @['price'] == 8.99)].title").on(json)
+# => ["Sayings of the Century", "Moby Dick"]
+
+JsonPath.new("$..book[?(@['price'] == 8.95 && @['price'] == 8.99)].title").on(json)
+# => []
 ```
 
-There is a convenience method, `#first` that gives you the first element for a JSON object and path.
+There is a convenience method, `#first` that gives you the first element for a
+JSON object and path.
 
 ```ruby
-JsonPath.new('$..color').first(object)
+JsonPath.new('$..color').first(json)
 # => "red"
 ```
 
 As well, we can directly create an `Enumerable` at any time using `#[]`. 
 
 ```ruby
-enum = JsonPath.new('$..color')[object]
+enum = JsonPath.new('$..color')[json]
 # => #<JsonPath::Enumerable:...>
 enum.first
 # => "red"
@@ -103,35 +111,123 @@ enum.any?{ |c| c == 'red' }
 # => true
 ```
 
-### More examples
+For more usage examples and variations on paths, please visit the tests. There
+are some more complex ones as well.
 
-For more usage examples and variations on paths, please visit the tests. There are some more complex ones as well.
+### Querying ruby data structures
 
-### Conditional Operators Are Also Supported
+If you have ruby hashes with symbolized keys as input, you
+can use `:use_symbols` to make JsonPath work fine on them too:
 
 ```ruby
-  def test_or_operator
-    assert_equal [@object['store']['book'][1], @object['store']['book'][3]], JsonPath.new("$..book[?(@['price'] == 13 || @['price'] == 23)]").on(@object)
-  end
+book = { title: "Sayings of the Century" }
 
-  def test_and_operator
-    assert_equal [], JsonPath.new("$..book[?(@['price'] == 13 && @['price'] == 23)]").on(@object)
-  end
+JsonPath.new('$.title').on(book)
+# => []
 
-  def test_and_operator_with_more_results
-    assert_equal [@object['store']['book'][1]], JsonPath.new("$..book[?(@['price'] < 23 && @['price'] > 9)]").on(@object)
-  end
+JsonPath.new('$.title', use_symbols: true).on(book)
+# => ["Sayings of the Century"]
 ```
 
-### Running an individual test
+JsonPath also recognizes objects responding to `dig` (introduced
+in ruby 2.3), and therefore works out of the box with Struct,
+OpenStruct, and other Hash-like structures:
 
 ```ruby
-ruby -Ilib:../lib test/test_jsonpath.rb --name test_wildcard_on_intermediary_element_v6
+book_class = Struct.new(:title)
+book = book_class.new("Sayings of the Century")
+
+JsonPath.new('$.title').on(book)
+# => ["Sayings of the Century"]
+```
+
+JsonPath is able to query pure ruby objects and uses `__send__`
+on them. The option is enabled by default in JsonPath 1.x, but
+we encourage to enable it explicitly:
+
+```ruby
+book_class = Class.new{ attr_accessor :title }
+book = book_class.new
+book.title = "Sayings of the Century"
+
+JsonPath.new('$.title', allow_send: true).on(book)
+# => ["Sayings of the Century"]
+```
+
+### Other available options
+
+By default, JsonPath does not return null values on unexisting paths.
+This can be changed using the `:default_path_leaf_to_null` option
+
+```ruby
+JsonPath.new('$..book[*].isbn').on(json)
+# => ["0-553-21311-3", "0-395-19395-8"]
+
+JsonPath.new('$..book[*].isbn', default_path_leaf_to_null: true).on(json)
+# => [nil, nil, "0-553-21311-3", "0-395-19395-8"]
+```
+
+When JsonPath returns a Hash, you can ask to symbolize its keys
+using the `:symbolize_keys` option
+
+```ruby
+JsonPath.new('$..book[0]').on(json)
+# => [{"category" => "reference", ...}]
+
+JsonPath.new('$..book[0]', symbolize_keys: true).on(json)
+# => [{category: "reference", ...}]
+```
+
+### Selecting Values
+
+It's possible to select results once a query has been defined after the query. For
+example given this JSON data:
+
+```bash
+{
+    "store": {
+        "book": [
+            {
+                "category": "reference",
+                "author": "Nigel Rees",
+                "title": "Sayings of the Century",
+                "price": 8.95
+            },
+            {
+                "category": "fiction",
+                "author": "Evelyn Waugh",
+                "title": "Sword of Honour",
+                "price": 12.99
+            }
+        ]
+}
+```
+
+... and this query:
+
+```ruby
+"$.store.book[*](category,author)"
+```
+
+... the result can be filtered as such:
+
+```bash
+[
+   {
+      "category" : "reference",
+      "author" : "Nigel Rees"
+   },
+   {
+      "category" : "fiction",
+      "author" : "Evelyn Waugh"
+   }
+]
 ```
 
 ### Manipulation
 
-If you'd like to do substitution in a json object, you can use `#gsub` or `#gsub!` to modify the object in place.
+If you'd like to do substitution in a json object, you can use `#gsub`
+or `#gsub!` to modify the object in place.
 
 ```ruby
 JsonPath.for('{"candy":"lollipop"}').gsub('$..candy') {|v| "big turks" }.to_hash
@@ -143,7 +239,9 @@ The result will be
 {'candy' => 'big turks'}
 ```
 
-If you'd like to remove all nil keys, you can use `#compact` and `#compact!`. To remove all keys under a certain path, use `#delete` or `#delete!`. You can even chain these methods together as follows:
+If you'd like to remove all nil keys, you can use `#compact` and `#compact!`.
+To remove all keys under a certain path, use `#delete` or `#delete!`. You can
+even chain these methods together as follows:
 
 ```ruby
 json = '{"candy":"lollipop","noncandy":null,"other":"things"}'
@@ -157,4 +255,11 @@ o = JsonPath.for(json).
 
 # Contributions
 
-Please feel free to submit an Issue or a Pull Request any time you feel like you would like to contribute. Thank you!
+Please feel free to submit an Issue or a Pull Request any time you feel like
+you would like to contribute. Thank you!
+
+## Running an individual test
+
+```ruby
+ruby -Ilib:../lib test/test_jsonpath.rb --name test_wildcard_on_intermediary_element_v6
+```

data/jsonpath.gemspec

@@ -5,10 +5,7 @@ require File.join(File.dirname(__FILE__), 'lib', 'jsonpath', 'version')
 Gem::Specification.new do |s|
   s.name = 'jsonpath'
   s.version = JsonPath::VERSION
-  if s.respond_to? :required_rubygems_version=
-    s.required_rubygems_version =
-      Gem::Requirement.new('>= 0')
-  end
+  s.required_ruby_version = '>= 2.5'
   s.authors = ['Joshua Hull', 'Gergely Brautigam']
   s.summary = 'Ruby implementation of http://goessner.net/articles/JsonPath/'
   s.description = 'Ruby implementation of http://goessner.net/articles/JsonPath/.'
@@ -16,17 +13,12 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ['README.md']
   s.files = `git ls-files`.split("\n")
   s.homepage = 'https://github.com/joshbuddy/jsonpath'
-  s.rdoc_options = ['--charset=UTF-8']
-  s.require_paths = ['lib']
-  s.rubygems_version = '1.3.7'
   s.test_files = `git ls-files`.split("\n").select { |f| f =~ /^spec/ }
-  s.rubyforge_project = 'jsonpath'
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.licenses    = ['MIT']
 
   # dependencies
   s.add_runtime_dependency 'multi_json'
-  s.add_runtime_dependency 'to_regexp', '~> 0.2.1'
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'code_stats'
   s.add_development_dependency 'minitest', '~> 2.2.0'

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'
@@ -10,30 +11,39 @@ require 'jsonpath/parser'
 # JsonPath: initializes the class with a given JsonPath and parses that path
 # into a token array.
 class JsonPath
-  PATH_ALL = '$..*'.freeze
+  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 = {})
-    @opts = opts
+    @opts = DEFAULT_OPTIONS.merge(opts)
     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(/[$@a-zA-Z0-9:{}_-]+/))
         @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(/./))
         begin
           @path.last << token
         rescue RuntimeError
@@ -46,13 +56,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'

data/lib/jsonpath/dig.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class JsonPath
+  module Dig
+
+    # Similar to what Hash#dig or Array#dig
+    def dig(context, *keys)
+      keys.inject(context){|memo,k|
+        dig_one(memo, k)
+      }
+    end
+
+    # Returns a hash mapping each key from keys
+    # to its dig value on context.
+    def dig_as_hash(context, keys)
+      keys.each_with_object({}) do |k, memo|
+        memo[k] = dig_one(context, k)
+      end
+    end
+
+    # Dig the value of k on context.
+    def dig_one(context, k)
+      case context
+      when Hash
+        context[@options[:use_symbols] ? k.to_sym : k]
+      when Array
+        context[k.to_i]
+      else
+        if context.respond_to?(:dig)
+          context.dig(k)
+        elsif @options[:allow_send]
+          context.__send__(k)
+        end
+      end
+    end
+
+    # Yields the block if context has a diggable
+    # value for k
+    def yield_if_diggable(context, k, &blk)
+      case context
+      when Array
+        nil
+      when Hash
+        k = @options[:use_symbols] ? k.to_sym : k
+        return yield if context.key?(k) || @options[:default_path_leaf_to_null]
+      else
+        if context.respond_to?(:dig)
+          digged = dig_one(context, k)
+          yield if !digged.nil? || @options[:default_path_leaf_to_null]
+        elsif @options[:allow_send] && context.respond_to?(k.to_s) && !Object.respond_to?(k.to_s)
+          yield
+        end
+      end
+    end
+
+  end
+end

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,12 +13,7 @@ class JsonPath
     end
 
     def each(context = @object, key = nil, pos = 0, &blk)
-      node =
-        if key
-          context.is_a?(Hash) || context.is_a?(Array) ? context[key] : context.__send__(key)
-        else
-          context
-        end
+      node = key ? dig_one(context, key) : context
       @_current_node = node
       return yield_value(blk, context, key) if pos == @path.size
 
@@ -28,6 +24,10 @@ class JsonPath
         each(context, key, pos + 1, &blk) if node == @object
       when /^\[(.*)\]$/
         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] != '..')
@@ -40,21 +40,30 @@ class JsonPath
 
     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]
-          if node.is_a?(Hash)
-            node[k] ||= nil if @options[:default_path_leaf_to_null]
-            each(node, k, pos + 1, &blk) if node.key?(k)
-          elsif node.respond_to?(k.to_s)
+          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] == '*'
@@ -112,10 +121,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)
@@ -147,12 +155,12 @@ class JsonPath
           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,14 +1,18 @@
 # 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.
@@ -65,19 +69,22 @@ class JsonPath
       elements = []
       until scanner.eos?
         if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_]+'\]|\.[a-zA-Z0-9_]+[?!]?/))
-          elements << t.gsub(/[\[\]'\.]|\s+/, '')
+          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
-                    else
-                      operator.to_s.strip == '=~' ? t.to_regexp : t.gsub(%r{^'|'$}, '').strip
-                    end
+          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}"
@@ -87,7 +94,7 @@ class JsonPath
       el = if elements.empty?
              @_current_node
            elsif @_current_node.is_a?(Hash)
-             @_current_node.dig(*elements)
+             dig(@_current_node, *elements)
            else
              elements.inject(@_current_node, &:__send__)
            end
@@ -102,6 +109,31 @@ class JsonPath
 
     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

data/lib/jsonpath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class JsonPath
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.1.0'
 end

data/test/test_jsonpath.rb

@@ -130,6 +130,50 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal ['value'], JsonPath.new('$.b').on(object)
   end
 
+  def test_works_on_object
+    klass = Class.new{
+      attr_reader :b
+      def initialize(b)
+        @b = b
+      end
+    }
+    object = klass.new("value")
+
+    assert_equal ["value"], JsonPath.new('$.b').on(object)
+  end
+
+  def test_works_on_object_can_be_disabled
+    klass = Class.new{
+      attr_reader :b
+      def initialize(b)
+        @b = b
+      end
+    }
+    object = klass.new("value")
+
+    assert_equal [], JsonPath.new('$.b', allow_send: false).on(object)
+  end
+
+  def test_works_on_diggable
+    klass = Class.new{
+      attr_reader :h
+      def initialize(h)
+        @h = h
+      end
+      def dig(*keys)
+        @h.dig(*keys)
+      end
+    }
+
+    object = klass.new('a' => 'some', 'b' => 'value')
+    assert_equal ['value'], JsonPath.new('$.b').on(object)
+
+    object = {
+      "foo" => klass.new('a' => 'some', 'b' => 'value')
+    }
+    assert_equal ['value'], JsonPath.new('$.foo.b').on(object)
+  end
+
   def test_works_on_non_hash_with_filters
     klass = Struct.new(:a, :b)
     first_object = klass.new('some', 'value')
@@ -138,6 +182,24 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal ['other value'], JsonPath.new('$[?(@.a == "next")].b').on([first_object, second_object])
   end
 
+  def test_works_on_hash_with_summary
+    object = {
+      "foo" => [{
+        "a" => "some",
+        "b" => "value"
+      }]
+    }
+    assert_equal [{ "b" => "value" }], JsonPath.new("$.foo[*](b)").on(object)
+  end
+
+  def test_works_on_non_hash_with_summary
+    klass = Struct.new(:a, :b)
+    object = {
+      "foo" => [klass.new("some", "value")]
+    }
+    assert_equal [{ "b" => "value" }], JsonPath.new("$.foo[*](b)").on(object)
+  end
+
   def test_recognize_array_with_evald_index
     assert_equal [@object['store']['book'][2]], JsonPath.new('$..book[(@.length-5)]').on(@object)
   end
@@ -511,15 +573,31 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [{ 'isTrue' => true, 'name' => 'testname1' }], JsonPath.new('$.data[?(@.isTrue)]').on(data)
   end
 
-  def test_regex
-    assert_equal [], JsonPath.new('$..book[?(@.author =~ /herman/)]').on(@object)
+  def test_regex_simple
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ /asdf/)]').on(@object)
+  end
+
+  def test_regex_simple_miss
+    assert_equal [], JsonPath.new('$.store.book..tags[?(@ =~ /wut/)]').on(@object)
+  end
+
+  def test_regex_r
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ %r{asdf})]').on(@object)
+  end
+
+  def test_regex_flags
     assert_equal [
       @object['store']['book'][2],
       @object['store']['book'][4],
       @object['store']['book'][5],
       @object['store']['book'][6]
     ], JsonPath.new('$..book[?(@.author =~ /herman|lukyanenko/i)]').on(@object)
-    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ /asdf/)]').on(@object)
+  end
+
+  def test_regex_error
+    assert_raises ArgumentError do
+      JsonPath.new('$.store.book..tags[?(@ =~ asdf)]').on(@object)
+    end
   end
 
   def test_regression_1
@@ -748,7 +826,7 @@ class TestJsonpath < MiniTest::Unit::TestCase
   end
 
   def test_runtime_error_frozen_string
-    skip('in ruby version below 2.2.0 this error is not raised') if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.0')
+    skip('in ruby version below 2.2.0 this error is not raised') if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.0') || Gem::Version.new(RUBY_VERSION) > Gem::Version::new('2.6')
     json = '
     {
       "test": "something"
@@ -833,6 +911,193 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
   end
 
+  def test_selecting_multiple_keys_on_hash
+    json = '
+    {
+      "category": "reference",
+      "author": "Nigel Rees",
+      "title": "Sayings of the Century",
+      "price": 8.95
+    }
+    '.to_json
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, '$.(category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_sub_hash
+    skip("Failing as the semantics of .(x,y) is unclear")
+    json = '
+    {
+      "book": {
+        "category": "reference",
+        "author": "Nigel Rees",
+        "title": "Sayings of the Century",
+        "price": 8.95
+      }
+    }
+    '.to_json
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, '$.book.(category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_array
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "category": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "category": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }, { 'category' => 'fiction', 'author' => 'Evelyn Waugh' }], JsonPath.on(json, '$.store.book[*](category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_array_with_filter
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "category": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "category": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](category,author)")
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](   category, author   )")
+  end
+
+  def test_selecting_multiple_keys_with_filter_with_space_in_catergory
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "cate gory": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "cate gory": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'cate gory' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](   cate gory, author   )")
+  end
+
+  def test_use_symbol_opt
+    json = {
+      store: {
+        book: [
+          {
+            category: "reference",
+            author: "Nigel Rees",
+            title: "Sayings of the Century",
+            price: 8.95
+          },
+          {
+            category: "fiction",
+            author: "Evelyn Waugh",
+            title: "Sword of Honour",
+            price: 12.99
+          }
+        ]
+      }
+    }
+    on = ->(path){ JsonPath.on(json, path, use_symbols: true) }
+    assert_equal ['reference', 'fiction'], on.("$.store.book[*].category")
+    assert_equal ['reference', 'fiction'], on.("$..category")
+    assert_equal ['reference'], on.("$.store.book[?(@['price'] == 8.95)].category")
+    assert_equal [{'category' => 'reference'}], on.("$.store.book[?(@['price'] == 8.95)](category)")
+  end
+
+  def test_object_method_send
+    j = {height: 5, hash: "some_hash"}.to_json
+    hs = JsonPath.new "$..send"
+    assert_equal([], hs.on(j))
+    hs = JsonPath.new "$..hash"
+    assert_equal(["some_hash"], hs.on(j))
+    hs = JsonPath.new "$..send"
+    assert_equal([], hs.on(j))
+    j = {height: 5, send: "should_still_work"}.to_json
+    hs = JsonPath.new "$..send"
+    assert_equal(['should_still_work'], hs.on(j))
+  end
+
+  def test_index_access_by_number
+    data = {
+      '1': 'foo'
+    }
+    assert_equal ['foo'], JsonPath.new('$.1').on(data.to_json)
+  end
+
+  def test_behavior_on_null_and_missing
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal [nil], JsonPath.new('$.foo').on(data)
+    assert_equal [nil], JsonPath.new('$.bar.baz').on(data)
+    assert_equal [], JsonPath.new('$.baz').on(data)
+    assert_equal [], JsonPath.new('$.bar.foo').on(data)
+    assert_equal [12, nil], JsonPath.new('$.bars[*].foo').on(data)
+  end
+
+  def test_default_path_leaf_to_null_opt
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal [nil], JsonPath.new('$.foo', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.bar.baz', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.baz', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.bar.foo', default_path_leaf_to_null: true).on(data)
+    assert_equal [12, nil, nil], JsonPath.new('$.bars[*].foo', default_path_leaf_to_null: true).on(data)
+  end
+
   def example_object
     { 'store' => {
       'book' => [

data/test/test_readme.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'phocus'
+require 'jsonpath'
+require 'json'
+
+class TestJsonpathReadme < MiniTest::Unit::TestCase
+
+  def setup
+    @json = <<-HERE_DOC
+    {"store":
+      {"bicycle":
+        {"price":19.95, "color":"red"},
+        "book":[
+          {"price":8.95, "category":"reference", "title":"Sayings of the Century", "author":"Nigel Rees"},
+          {"price":12.99, "category":"fiction", "title":"Sword of Honour", "author":"Evelyn Waugh"},
+          {"price":8.99, "category":"fiction", "isbn":"0-553-21311-3", "title":"Moby Dick", "author":"Herman Melville","color":"blue"},
+          {"price":22.99, "category":"fiction", "isbn":"0-395-19395-8", "title":"The Lord of the Rings", "author":"Tolkien"}
+        ]
+      }
+    }
+    HERE_DOC
+  end
+  attr_reader :json
+
+  def test_library_section
+    path = JsonPath.new('$..price')
+    assert_equal [19.95, 8.95, 12.99, 8.99, 22.99], path.on(json)
+    assert_equal [18.88], path.on('{"books":[{"title":"A Tale of Two Somethings","price":18.88}]}')
+    assert_equal ["Nigel Rees", "Evelyn Waugh", "Herman Melville", "Tolkien"], JsonPath.on(json, '$..author')
+    assert_equal [
+      {"price" => 8.95, "category" => "reference", "title" => "Sayings of the Century", "author" => "Nigel Rees"},
+      {"price" => 8.99, "category" => "fiction", "isbn" => "0-553-21311-3", "title" => "Moby Dick", "author" => "Herman Melville","color" => "blue"},
+    ], JsonPath.new('$..book[::2]').on(json)
+    assert_equal [8.95, 8.99], JsonPath.new("$..price[?(@ < 10)]").on(json)
+    assert_equal ["Sayings of the Century", "Moby Dick"], JsonPath.new("$..book[?(@['price'] == 8.95 || @['price'] == 8.99)].title").on(json)
+    assert_equal [], JsonPath.new("$..book[?(@['price'] == 8.95 && @['price'] == 8.99)].title").on(json)
+    assert_equal "red", JsonPath.new('$..color').first(json)
+  end
+
+  def test_library_section_enumerable
+    enum = JsonPath.new('$..color')[json]
+    assert_equal "red", enum.first
+    assert enum.any?{ |c| c == 'red' }
+  end
+
+  def test_ruby_structures_section
+    book = { title: "Sayings of the Century" }
+    assert_equal [], JsonPath.new('$.title').on(book)
+    assert_equal ["Sayings of the Century"], JsonPath.new('$.title', use_symbols: true).on(book)
+
+    book_class = Struct.new(:title)
+    book = book_class.new("Sayings of the Century")
+    assert_equal ["Sayings of the Century"], JsonPath.new('$.title').on(book)
+
+    book_class = Class.new{ attr_accessor :title }
+    book = book_class.new
+    book.title = "Sayings of the Century"
+    assert_equal ["Sayings of the Century"], JsonPath.new('$.title', allow_send: true).on(book)
+  end
+
+  def test_options_section
+    assert_equal ["0-553-21311-3", "0-395-19395-8"], JsonPath.new('$..book[*].isbn').on(json)
+    assert_equal [nil, nil, "0-553-21311-3", "0-395-19395-8"], JsonPath.new('$..book[*].isbn', default_path_leaf_to_null: true).on(json)
+
+    assert_equal ["price", "category", "title", "author"], JsonPath.new('$..book[0]').on(json).map(&:keys).flatten.uniq
+    assert_equal [:price, :category, :title, :author], JsonPath.new('$..book[0]').on(json, symbolize_keys: true).map(&:keys).flatten.uniq
+  end
+
+  def selecting_value_section
+    json = <<-HERE_DOC
+    {
+        "store": {
+            "book": [
+                {
+                    "category": "reference",
+                    "author": "Nigel Rees",
+                    "title": "Sayings of the Century",
+                    "price": 8.95
+                },
+                {
+                    "category": "fiction",
+                    "author": "Evelyn Waugh",
+                    "title": "Sword of Honour",
+                    "price": 12.99
+                }
+            ]
+    }
+    HERE_DOC
+    got = JsonPath.on(json, "$.store.book[*](category,author)")
+    expected = [
+       {
+          "category" => "reference",
+          "author" => "Nigel Rees"
+       },
+       {
+          "category" => "fiction",
+          "author" => "Evelyn Waugh"
+       }
+    ]
+    assert_equal expected, got
+  end
+
+  def test_manipulation_section
+    assert_equal({"candy" => "big turks"}, JsonPath.for('{"candy":"lollipop"}').gsub('$..candy') {|v| "big turks" }.to_hash)
+
+    json = '{"candy":"lollipop","noncandy":null,"other":"things"}'
+    o = JsonPath.for(json).
+      gsub('$..candy') {|v| "big turks" }.
+      compact.
+      delete('$..other').
+      to_hash
+    assert_equal({"candy" => "big turks"}, o)
+  end
+
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: jsonpath
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Joshua Hull
 - Gergely Brautigam
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-26 00:00:00.000000000 Z
+date: 2020-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -25,20 +25,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: to_regexp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -132,34 +118,35 @@ files:
 - bin/jsonpath
 - jsonpath.gemspec
 - lib/jsonpath.rb
+- lib/jsonpath/dig.rb
 - lib/jsonpath/enumerable.rb
 - lib/jsonpath/parser.rb
 - lib/jsonpath/proxy.rb
 - lib/jsonpath/version.rb
 - test/test_jsonpath.rb
 - test/test_jsonpath_bin.rb
+- test/test_readme.rb
 homepage: https://github.com/joshbuddy/jsonpath
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
-rdoc_options:
-- "--charset=UTF-8"
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Ruby implementation of http://goessner.net/articles/JsonPath/
 test_files: []