jsonpath 1.0.7 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a31bb2922acb2b1a6e84a6e640ee148eb1f40f9d8113751c6903149e472e99d9
-  data.tar.gz: ab119c28fe07e14bfab16e5e2905d59ccf7e8154d5ff817d14a9db92215f8bd2
+  metadata.gz: ab3e08744fe7f8ba3b64670fee8f75a0fa4c9b339de8257f64cdc7ea24f26965
+  data.tar.gz: 447ce47a7c5df36c2fa290da5aafc77304d5e8db9318cfcac2b97dd9ae8c9c8c
 SHA512:
-  metadata.gz: 4ede5f5c546e8ac46689b993ada2d6ed456ed9e9b1027023e421b8d27e99b3f785360a3fcf093a58be473a80ecca3485b709f23575be6b93fb71c2ae46f63966
-  data.tar.gz: 021a544e520b944266c276b3b79ca53e0311df7ade212655282e4f3f03b9bca18aba5858148dc7de8ec3ca91be67dbd2f5554c4b6a73273c094d94dc31f5aa71
+  metadata.gz: 5b458262f098ceea595a91a981136141d0ed3f7ef9782d8a205f619be1bb60a7234af11229527ed9fc9ef3baafec323ad33850d87b4dc389ac482c14bb4aa05f
+  data.tar.gz: d1756aa04d5e07de855439aa0a4895078ab5c3c2c90c4c9ec755ba1da2ffb3fe11e59d1819e03f6a82e8670fd810b1c895da150a9d24176ddf4a86a54705fcbf

data/.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: test
+on:
+- push
+- pull_request
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version:
+        - '2.5'
+        - '2.6'
+        - '2.7'
+        - ruby-head
+        - jruby-head
+        - truffleruby-head
+        runs-on:
+        - ubuntu-latest
+
+    runs-on: ${{ matrix.runs-on }}
+
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - run: bundle exec rake test

data/.gitignore

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

data/Gemfile

@@ -2,5 +2,5 @@
 
 source 'http://rubygems.org'
 gemspec
-gem 'rubocop', require: true, group: :test
+# gem 'rubocop', require: true, group: :test
 gem 'simplecov', require: false, group: :test

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,29 +111,77 @@ 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.
+
+### Querying ruby data structures
+
+If you have ruby hashes with symbolized keys as input, you
+can use `:use_symbols` to make JsonPath work fine on them too:
 
-For more usage examples and variations on paths, please visit the tests. There are some more complex ones as well.
+```ruby
+book = { title: "Sayings of the Century" }
+
+JsonPath.new('$.title').on(book)
+# => []
+
+JsonPath.new('$.title', use_symbols: true).on(book)
+# => ["Sayings of the Century"]
+```
 
-### Conditional Operators Are Also Supported
+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
-  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_class = Struct.new(:title)
+book = book_class.new("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)
+# => ["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"
 
-  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', 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:
+It's possible to select results once a query has been defined after the query. For
+example given this JSON data:
 
 ```bash
 {
@@ -168,15 +224,10 @@ It's possible to select results once a query has been defined after the query. F
 ]
 ```
 
-### Running an individual test
-
-```ruby
-ruby -Ilib:../lib test/test_jsonpath.rb --name test_wildcard_on_intermediary_element_v6
-```
-
 ### 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
@@ -188,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"}'
@@ -200,6 +253,49 @@ o = JsonPath.for(json).
 # => {"candy" => "big turks"}
 ```
 
+### Fetch all paths
+
+To fetch all possible paths in given json, you can use `fetch_all_paths` method.
+
+data:
+
+```bash
+{
+    "store": {
+        "book": [
+            {
+                "category": "reference",
+                "author": "Nigel Rees"
+            },
+            {
+                "category": "fiction",
+                "author": "Evelyn Waugh"
+            }
+        ]
+}
+```
+
+... and this query:
+
+```ruby
+JsonPath.fetch_all_path(data)
+```
+
+... the result will be:
+
+```bash
+["$", "$.store", "$.store.book", "$.store.book[0].category", "$.store.book[0].author", "$.store.book[0]", "$.store.book[1].category", "$.store.book[1].author", "$.store.book[1]"]
+```
+
+
+
 # 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

@@ -23,5 +23,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'code_stats'
   s.add_development_dependency 'minitest', '~> 2.2.0'
   s.add_development_dependency 'phocus'
+  s.add_development_dependency 'racc'
   s.add_development_dependency 'rake'
 end

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
 
@@ -47,11 +43,10 @@ class JsonPath
     def filter_context(context, keys)
       case context
       when Hash
-        # TODO: Change this to `slice(*keys)` when ruby version support is > 2.4
-        context.select { |k| keys.include?(k) }
+        dig_as_hash(context, keys)
       when Array
         context.each_with_object([]) do |c, memo|
-          memo << c.select { |k| keys.include?(k) }
+          memo << dig_as_hash(c, keys)
         end
       end
     end
@@ -61,16 +56,14 @@ class JsonPath
         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) && !Object.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] == '*'
@@ -130,7 +123,7 @@ class JsonPath
     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
         if key && context[key].nil?
           key.is_a?(Integer) ? context.delete_at(key) : context.delete(key)
@@ -158,16 +151,13 @@ class JsonPath
       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
-          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

@@ -5,11 +5,14 @@ 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)
+    def initialize(node, options)
       @_current_node = node
       @_expr_map = {}
+      @options = options
     end
 
     # parse will parse an expression in the following way.
@@ -65,7 +68,7 @@ class JsonPath
       scanner = StringScanner.new(exp)
       elements = []
       until scanner.eos?
-        if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_]+'\]|\.[a-zA-Z0-9_]+[?!]?/))
+        if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_]+'\]|\.[a-zA-Z0-9_]+[?]?/))
           elements << t.gsub(/[\[\]'.]|\s+/, '')
         elsif (t = scanner.scan(/(\s+)?[<>=!\-+][=~]?(\s+)?/))
           operator = t
@@ -91,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
@@ -156,9 +159,11 @@ class JsonPath
       res = bool_or_exp(top.shift)
       top.each_with_index do |item, index|
         if item == '&&'
-          res &&= top[index + 1]
+          next_value = bool_or_exp(top[index + 1])
+          res &&= next_value
         elsif item == '||'
-          res ||= top[index + 1]
+          next_value = bool_or_exp(top[index + 1])
+          res ||= next_value
         end
       end
 

data/lib/jsonpath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class JsonPath
-  VERSION = '1.0.7'
+  VERSION = '1.1.2'
 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'
@@ -12,10 +13,18 @@ require 'jsonpath/parser'
 class JsonPath
   PATH_ALL = '$..*'
 
+  DEFAULT_OPTIONS = {
+    :default_path_leaf_to_null => false,
+    :symbolize_keys => false,
+    :use_symbols => false,
+    :allow_send => true,
+    :max_nesting => 100
+  }
+
   attr_accessor :path
 
   def initialize(path, opts = {})
-    @opts = opts
+    @opts = DEFAULT_OPTIONS.merge(opts)
     scanner = StringScanner.new(path.strip)
     @path = []
     until scanner.eos?
@@ -78,13 +87,46 @@ class JsonPath
     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), mode,
+    JsonPath::Enumerable.new(self, self.class.process_object(obj_or_str, @opts), mode,
                              @opts)
   end
   alias [] enum_on
@@ -99,8 +141,8 @@ 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

data/test/test_jsonpath.rb

@@ -70,24 +70,60 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [@object['store']['book'][0], @object['store']['book'][2]], JsonPath.new("$..book[?(@['price'] < 10)]").on(@object)
     assert_equal [@object['store']['book'][0], @object['store']['book'][2]], JsonPath.new("$..book[?(@['price'] == 9)]").on(@object)
     assert_equal [@object['store']['book'][3]], JsonPath.new("$..book[?(@['price'] > 20)]").on(@object)
-    assert_equal [
-      @object['store']['book'][0],
-      @object['store']['book'][4],
-      @object['store']['book'][5],
-      @object['store']['book'][6]
-    ], JsonPath.new("$..book[?(@['category'] != 'fiction')]").on(@object)
+  end
+
+  def test_not_equals_operator
+    expected =
+      [
+        @object['store']['book'][0],
+        @object['store']['book'][4],
+        @object['store']['book'][5],
+        @object['store']['book'][6]
+      ]
+    assert_equal(expected, JsonPath.new("$..book[?(@['category'] != 'fiction')]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@['category']!=fiction)]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@.category!=fiction)]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@.category != 'fiction')]").on(@object))
   end
 
   def test_or_operator
     assert_equal [@object['store']['book'][1], @object['store']['book'][3]], JsonPath.new("$..book[?(@['price'] == 13 || @['price'] == 23)]").on(@object)
+    result = ["Sayings of the Century", "Sword of Honour", "Moby Dick", "The Lord of the Rings"]
+    assert_equal result, JsonPath.new("$..book[?(@.price==13 || @.price==9 || @.price==23)].title").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.price==9 || @.price==23 || @.price==13)].title").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.price==23 || @.price==13 || @.price==9)].title").on(@object)
+  end
+
+  def test_or_operator_with_not_equals
+    # Should be the same regardless of key style ( @.key vs @['key'] )
+    result = ['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'J. R. R. Tolkien', 'Lukyanenko']
+    assert_equal result, JsonPath.new("$..book[?(@['title']=='Osennie Vizity' || @['author']!='Lukyanenko')].author").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.title=='Osennie Vizity' || @.author != Lukyanenko )].author").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.title=='Osennie Vizity' || @.author!=Lukyanenko )].author").on(@object)
   end
 
   def test_and_operator
     assert_equal [], JsonPath.new("$..book[?(@['price'] == 13 && @['price'] == 23)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price>=13 && @.category==fiction && @.title==no_match)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.title==no_match && @.category==fiction && @.price==13)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price==13 && @.title==no_match && @.category==fiction)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price==13 && @.bad_key_name==true && @.category==fiction)]").on(@object)
+
+    expected = [@object['store']['book'][1]]
+    assert_equal expected, JsonPath.new("$..book[?(@['price'] < 23 && @['price'] > 9)]").on(@object)
+    assert_equal expected, JsonPath.new("$..book[?(@.price < 23 && @.price > 9)]").on(@object)
+
+    expected = ['Sword of Honour', 'The Lord of the Rings']
+    assert_equal expected, JsonPath.new("$..book[?(@.price>=13 && @.category==fiction)].title").on(@object)
+    assert_equal ['The Lord of the Rings'], JsonPath.new("$..book[?(@.category==fiction && @.isbn && @.price>9)].title").on(@object)
+    assert_equal ['Sayings of the Century'], JsonPath.new("$..book[?(@['price'] == 9 && @.author=='Nigel Rees')].title").on(@object)
+    assert_equal ['Sayings of the Century'], JsonPath.new("$..book[?(@['price'] == 9 && @.tags..asdf)].title").on(@object)
   end
 
-  def test_and_operator_with_more_results
-    assert_equal [@object['store']['book'][1]], JsonPath.new("$..book[?(@['price'] < 23 && @['price'] > 9)]").on(@object)
+  def test_and_operator_with_not_equals
+    expected = ['Nigel Rees']
+    assert_equal expected, JsonPath.new("$..book[?(@['price']==9 && @['category']!=fiction)].author").on(@object)
+    assert_equal expected, JsonPath.new("$..book[?(@.price==9 && @.category!=fiction)].author").on(@object)
   end
 
   def test_nested_grouping
@@ -130,6 +166,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 +218,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
@@ -508,11 +606,42 @@ class TestJsonpath < MiniTest::Unit::TestCase
         'name' => 'testname2'
       }]
     }
-    assert_equal [{ 'isTrue' => true, 'name' => 'testname1' }], JsonPath.new('$.data[?(@.isTrue)]').on(data)
+
+    # These queries should be equivalent
+    expected = [{ 'isTrue' => true, 'name' => 'testname1' }]
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue==true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue == true)]').on(data)
+
+    # These queries should be equivalent
+    expected = [{ 'isTrue' => false, 'name' => 'testname2' }]
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue != true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue!=true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue==false)]').on(data)
+  end
+
+  def test_and_operator_with_boolean_parameter_value
+    data = {
+      'data' => [{
+        'hasProperty1' => true,
+        'hasProperty2' => false,
+        'name' => 'testname1'
+      }, {
+        'hasProperty1' => false,
+        'hasProperty2' => true,
+        'name' => 'testname2'
+      }, {
+        'hasProperty1' => true,
+        'hasProperty2' => true,
+        'name' => 'testname3'
+      }]
+    }
+    assert_equal ['testname3'], JsonPath.new('$.data[?(@.hasProperty1 && @.hasProperty2)].name').on(data)
   end
 
   def test_regex_simple
     assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ /asdf/)]').on(@object)
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@=~/asdf/)]').on(@object)
   end
 
   def test_regex_simple_miss
@@ -849,7 +978,34 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
   end
 
-  def test_selecting_multiple_keys
+  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": {
@@ -874,7 +1030,7 @@ class TestJsonpath < MiniTest::Unit::TestCase
     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_with_filter
+  def test_selecting_multiple_keys_on_array_with_filter
     json = '
     {
       "store": {
@@ -925,6 +1081,32 @@ class TestJsonpath < MiniTest::Unit::TestCase
     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"
@@ -945,6 +1127,70 @@ class TestJsonpath < MiniTest::Unit::TestCase
     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 test_raise_max_nesting_error
+    json = {
+      a: {
+        b: {
+          c: {
+          }
+        }
+      }
+    }.to_json
+
+    assert_raises(MultiJson::ParseError) { JsonPath.new('$.a', max_nesting: 1).on(json) }
+  end
+
+  def test_with_max_nesting_false
+    json = {
+      a: {
+        b: {
+          c: {
+          }
+        }
+      }
+    }.to_json
+
+    assert_equal [{}], JsonPath.new('$.a.b.c', max_nesting: false).on(json)
+  end
+
   def example_object
     { 'store' => {
       'book' => [
@@ -999,4 +1245,19 @@ class TestJsonpath < MiniTest::Unit::TestCase
       '_links' => { 'self' => {} }
     } }
   end
+  
+  def test_fetch_all_path
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal ["$", "$.foo", "$.bar", "$.bar.baz", "$.bars", "$.bars[0].foo", "$.bars[0]", "$.bars[1].foo", "$.bars[1]", "$.bars[2]"], JsonPath.fetch_all_path(data)
+  end
 end

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.7
+  version: 1.1.2
 platform: ruby
 authors:
 - Joshua Hull
 - Gergely Brautigam
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-15 00:00:00.000000000 Z
+date: 2022-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -81,6 +81,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,11 +120,11 @@ extra_rdoc_files:
 - README.md
 files:
 - ".gemtest"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - Gemfile
 - LICENSE.md
 - README.md
@@ -118,17 +132,19 @@ 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: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -143,8 +159,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Ruby implementation of http://goessner.net/articles/JsonPath/
 test_files: []

data/.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-rvm:
-  - 2.5
-  - 2.6
-  - 2.7
-  - ruby-head
-  - jruby-head
-  - truffleruby-head