jsonpath 1.0.2 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dc2dc97587acd71d6ac7b1d5a2cb178f1ee9938823ef924c12e2213adafea1a
-  data.tar.gz: bc9b02cbc4c0a68329c9a682ed344b544028e27ba3f63f5079824cd536192792
+  metadata.gz: a31bb2922acb2b1a6e84a6e640ee148eb1f40f9d8113751c6903149e472e99d9
+  data.tar.gz: ab119c28fe07e14bfab16e5e2905d59ccf7e8154d5ff817d14a9db92215f8bd2
 SHA512:
-  metadata.gz: a8834f4fdcd9d1a3ba41f9431297ce87b3cf8da93ef33c0f9cd69f4c3649d1948aa32de0184f00dd157497a5ef5ec459fcfdd6be8987480b337384fcbeb4bd16
-  data.tar.gz: 3e2370e1114d041f108804e33b409e21884d2ebf21d2745fd94b81ce054646538e2f5c4d5889109f166ce8fed1d2f522e02298608bc9e766cce163b690f88f23
+  metadata.gz: 4ede5f5c546e8ac46689b993ada2d6ed456ed9e9b1027023e421b8d27e99b3f785360a3fcf093a58be473a80ecca3485b709f23575be6b93fb71c2ae46f63966
+  data.tar.gz: 021a544e520b944266c276b3b79ca53e0311df7ade212655282e4f3f03b9bca18aba5858148dc7de8ec3ca91be67dbd2f5554c4b6a73273c094d94dc31f5aa71

data/.gitignore

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

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

@@ -123,6 +123,51 @@ For more usage examples and variations on paths, please visit the tests. There a
   end
 ```
 
+### 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"
+   }
+]
+```
+
 ### Running an individual test
 
 ```ruby

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

@@ -10,7 +10,7 @@ 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 = '$..*'
 
   attr_accessor :path
 
@@ -19,21 +19,23 @@ class JsonPath
     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 +48,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/enumerable.rb

@@ -28,6 +28,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,6 +44,18 @@ class JsonPath
 
     private
 
+    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) }
+      when Array
+        context.each_with_object([]) do |c, memo|
+          memo << c.select { |k| keys.include?(k) }
+        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]
@@ -48,7 +64,7 @@ class JsonPath
           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)
+          elsif node.respond_to?(k.to_s) && !Object.respond_to?(k.to_s)
             each(node, k, pos + 1, &blk)
           end
         when '?'
@@ -112,7 +128,6 @@ 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)

data/lib/jsonpath/parser.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require 'strscan'
-require 'to_regexp'
 
 class JsonPath
   # Parser parses and evaluates an expression passed to @_current_node.
   class Parser
+    REGEX = /\A\/(.+)\/([imxnesu]*)\z|\A%r{(.+)}([imxnesu]*)\z/
+
     def initialize(node)
       @_current_node = node
       @_expr_map = {}
@@ -46,29 +47,43 @@ class JsonPath
       end
     end
 
-    #  using a scanner break down the individual expressions and determine if
+    # Using a scanner break down the individual expressions and determine if
     # there is a match in the JSON for it or not.
     def parse_exp(exp)
       exp = exp.sub(/@/, '').gsub(/^\(/, '').gsub(/\)$/, '').tr('"', '\'').strip
+      exp.scan(/^\[(\d+)\]/) do |i|
+        next if i.empty?
+
+        index = Integer(i[0])
+        raise ArgumentError, 'Node does not appear to be an array.' unless @_current_node.is_a?(Array)
+        raise ArgumentError, "Index out of bounds for nested array. Index: #{index}" if @_current_node.size < index
+
+        @_current_node = @_current_node[index]
+        # Remove the extra '' and the index.
+        exp = exp.gsub(/^\[\d+\]|\[''\]/, '')
+      end
       scanner = StringScanner.new(exp)
       elements = []
       until scanner.eos?
-        if t = scanner.scan(/\['[a-zA-Z@&\*\/\$%\^\?_]+'\]|\.[a-zA-Z0-9_]+[?!]?/)
-          elements << t.gsub(/[\[\]'\.]|\s+/, '')
-        elsif t = scanner.scan(/(\s+)?[<>=!\-+][=~]?(\s+)?/)
+        if (t = scanner.scan(/\['[a-zA-Z@&*\/$%^?_]+'\]|\.[a-zA-Z0-9_]+[?!]?/))
+          elements << t.gsub(/[\[\]'.]|\s+/, '')
+        elsif (t = scanner.scan(/(\s+)?[<>=!\-+][=~]?(\s+)?/))
           operator = t
-        elsif t = scanner.scan(/(\s+)?'?.*'?(\s+)?/)
+        elsif (t = scanner.scan(/(\s+)?'?.*'?(\s+)?/))
           # If we encounter a node which does not contain `'` it means
           #  that we are dealing with a boolean type.
-          operand = if t == 'true'
-                      true
-                    elsif t == 'false'
-                      false
-                    else
-                      operator.to_s.strip == '=~' ? t.to_regexp : t.gsub(%r{^'|'$}, '').strip
-                    end
-        elsif t = scanner.scan(/\/\w+\//)
-        elsif t = scanner.scan(/.*/)
+          operand =
+            if t == 'true'
+              true
+            elsif t == 'false'
+              false
+            elsif operator.to_s.strip == '=~'
+              parse_regex(t)
+            else
+              t.gsub(%r{^'|'$}, '').strip
+            end
+        elsif (t = scanner.scan(/\/\w+\//))
+        elsif (t = scanner.scan(/.*/))
           raise "Could not process symbol: #{t}"
         end
       end
@@ -78,9 +93,7 @@ class JsonPath
            elsif @_current_node.is_a?(Hash)
              @_current_node.dig(*elements)
            else
-             elements.inject(@_current_node) do |agg, key|
-               agg.__send__(key)
-             end
+             elements.inject(@_current_node, &:__send__)
            end
 
       return (el ? true : false) if el.nil? || operator.nil?
@@ -93,6 +106,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
@@ -117,10 +155,9 @@ class JsonPath
       top = top.map(&:strip)
       res = bool_or_exp(top.shift)
       top.each_with_index do |item, index|
-        case item
-        when '&&'
+        if item == '&&'
           res &&= top[index + 1]
-        when '||'
+        elsif item == '||'
           res ||= top[index + 1]
         end
       end
@@ -129,9 +166,9 @@ class JsonPath
       # and the closing index will be the last index. To avoid
       # off-by-one errors we simply return the result at that point.
       if closing_index + 1 >= str.length && opening_index == 0
-        return res.to_s
+        res.to_s
       else
-        return "#{str[0..opening_index - 1]}#{res}#{str[closing_index + 1..str.length]}"
+        "#{str[0..opening_index - 1]}#{res}#{str[closing_index + 1..str.length]}"
       end
     end
 

data/lib/jsonpath/proxy.rb

@@ -10,11 +10,11 @@ class JsonPath
     end
 
     def gsub(path, replacement = nil, &replacement_block)
-      _gsub(_deep_copy, path, replacement ? proc { replacement } : replacement_block)
+      _gsub(_deep_copy, path, replacement ? proc(&method(:replacement)) : replacement_block)
     end
 
     def gsub!(path, replacement = nil, &replacement_block)
-      _gsub(@obj, path, replacement ? proc { replacement } : replacement_block)
+      _gsub(@obj, path, replacement ? proc(&method(:replacement)) : replacement_block)
     end
 
     def delete(path = JsonPath::PATH_ALL)

data/lib/jsonpath/version.rb

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

data/test/test_jsonpath.rb

@@ -511,15 +511,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 +764,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"
@@ -804,6 +820,131 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal expected, JsonPath.for(a.to_json).delete('$.itemList[1:6:2]').to_hash
   end
 
+  def test_nested_values
+    json = '
+    {
+      "phoneNumbers": [
+        [{
+          "type"  : "iPhone",
+          "number": "0123-4567-8888"
+        }],
+        [{
+          "type"  : "home",
+          "number": "0123-4567-8910"
+        }]
+      ]
+    }
+    '.to_json
+    assert_equal [[{ 'type' => 'home', 'number' => '0123-4567-8910' }]], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
+    assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[2].type == 'home')]")
+    json = '
+    {
+      "phoneNumbers":
+        {
+          "type"  : "iPhone",
+          "number": "0123-4567-8888"
+        }
+    }
+    '.to_json
+    assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
+  end
+
+  def test_selecting_multiple_keys
+    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_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_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 example_object
     { 'store' => {
       'book' => [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonpath
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.7
 platform: ruby
 authors:
 - Joshua Hull
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-16 00:00:00.000000000 Z
+date: 2020-12-15 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
@@ -143,22 +129,21 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: 
-rdoc_options:
-- "--charset=UTF-8"
+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.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of http://goessner.net/articles/JsonPath/