jsonpath 0.9.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '048116fe74d7b281fbcf58d8f5d1aa44c359267bf179e58376527032e58c0094'
-  data.tar.gz: 4d91c8953e2750322d486f372b165507c4f383a42c11d07987cc49630abea5b6
+  metadata.gz: ffcdd9076a2bd58ead93c850c8a1ed842a202e6db62314fb2b6c8fd5f8650fb5
+  data.tar.gz: 3d6624bd18086aa892f93bff141dd7bf33e516e02c3fd7e8828db13eb3a84436
 SHA512:
-  metadata.gz: fb899c515175b16b0f9c1001ae7525f14d086b4bf844779cef819c9e634511445c0ee1aa033c7e51c9419aa1de1e22ae8e4670e7fbaa162b27d5c819ebef0846
-  data.tar.gz: d303bb0188617e52133250571c43c0262b02cd1f586edb2d05683f30e6e26e17dfaeb81a3a62e40c4b838374e9b9354fbf012d03591fa7fb465549ff9148ddd8
+  metadata.gz: 492ed8f729cfdb038c2b0303f49bf2bf1bfb85bd4a7d6ae2e37c2b559bf288b73110db65b2c1642f4e1954cde213d10488ab996ad9261c108f253f03aeb41d12
+  data.tar.gz: 2642b36da6a171649a9b0dc2e973994a7d3268e71a62ea290e75f91bd7f7af621b0b0dd6d9fb6a1f7148943f2c5ce6965f8de0db69db4041bc973576b7694425

data/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: test
+on:
+- push
+- pull_request
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version:
+        - '2.6'
+        - '2.7'
+        - '3.2'
+        - '3.1'
+        - '3.0'
+        - 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

@@ -3,3 +3,8 @@ Gemfile.lock
 coverage/*
 doc/*
 .yardoc
+.DS_Store
+.idea
+vendor
+.tags
+*.gem

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2018-07-07 21:29:45 +0200 using RuboCop version 0.57.2.
+# on 2019-01-25 09:23:04 +0100 using RuboCop version 0.63.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -18,31 +18,32 @@ Lint/IneffectiveAccessModifier:
   Exclude:
     - 'lib/jsonpath.rb'
 
-# Offense count: 16
+# Offense count: 17
 Metrics/AbcSize:
-  Max: 54
+  Max: 60
 
 # Offense count: 2
 # Configuration parameters: CountComments, ExcludedMethods.
+# ExcludedMethods: refine
 Metrics/BlockLength:
-  Max: 33
+  Max: 37
 
 # Offense count: 1
 # Configuration parameters: CountBlocks.
 Metrics/BlockNesting:
   Max: 4
 
-# Offense count: 2
+# Offense count: 3
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 578
+  Max: 739
 
-# Offense count: 6
+# Offense count: 7
 Metrics/CyclomaticComplexity:
-  Max: 18
+  Max: 20
 
-# Offense count: 24
-# Configuration parameters: CountComments.
+# Offense count: 26
+# Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
   Max: 52
 
@@ -53,9 +54,16 @@ Metrics/ParameterLists:
 
 # Offense count: 6
 Metrics/PerceivedComplexity:
-  Max: 20
+  Max: 21
 
 # Offense count: 1
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: io, id, to, by, on, in, at, ip, db
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 15
 # Configuration parameters: AllowedChars.
 Style/AsciiComments:
   Exclude:
@@ -69,11 +77,12 @@ Style/Documentation:
     - 'lib/jsonpath/enumerable.rb'
     - 'lib/jsonpath/proxy.rb'
 
-# Offense count: 1
+# Offense count: 3
 # Configuration parameters: MinBodyLength.
 Style/GuardClause:
   Exclude:
     - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/parser.rb'
 
 # Offense count: 2
 # Cop supports --auto-correct.
@@ -81,16 +90,22 @@ Style/IfUnlessModifier:
   Exclude:
     - 'lib/jsonpath/enumerable.rb'
 
-# Offense count: 2
+# Offense count: 1
+Style/MultipleComparison:
+  Exclude:
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 3
 # Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, EnforcedStyle.
+# Configuration parameters: AutoCorrect, EnforcedStyle, IgnoredMethods.
 # SupportedStyles: predicate, comparison
 Style/NumericPredicate:
   Exclude:
     - 'spec/**/*'
     - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/parser.rb'
 
-# Offense count: 2
+# Offense count: 3
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, AllowInnerSlashes.
 # SupportedStyles: slashes, percent_r, mixed
@@ -98,15 +113,15 @@ Style/RegexpLiteral:
   Exclude:
     - 'lib/jsonpath/parser.rb'
 
-# Offense count: 3
+# Offense count: 4
 # Cop supports --auto-correct.
 Style/RescueModifier:
   Exclude:
     - 'lib/jsonpath/enumerable.rb'
     - 'lib/jsonpath/parser.rb'
 
-# Offense count: 71
+# Offense count: 89
 # Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
 Metrics/LineLength:
-  Max: 175
+  Max: 296

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,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"}'
@@ -155,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_path`` 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

@@ -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.6'
   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,20 +13,16 @@ 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'
   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