jsonpathv2 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42c5754087dca72b09158229ea91cb5041026c27
+  data.tar.gz: c0d184648b89b424eb5e87a5d2ea4d034290ac2e
+SHA512:
+  metadata.gz: 9fdb268247ff8e762fadad1875d9ce64f9c8884d72d7d2e1f4e35e06a5fa8fd0300b0ea1739931bfe0a4b675309db3675bc796692f457dba14adc51ed5bbac8e
+  data.tar.gz: be83d73bfa5b14d43f331067c99f806967f5f007f0bba985142be06bbf7af37391027abfd72cca38f62a781efb6ed2fa139c7b2e7b545f480eaffae39e38ddc5

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format doc
+--backtrace

data/.travis.yml

@@ -0,0 +1,10 @@
+before_install:
+  - gem update --system 2.3.0
+rvm:
+  # Disabling 1.9.3 build for now, until the issue with the
+  # native json gem is fixed.
+  # - 1.9.3
+  - 2.0.0
+  - 2.1.6
+  - 2.3.1
+  - jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+gemspec
+
+gem 'simplecov', :require => false, :group => :test

data/README.md

@@ -0,0 +1,139 @@
+# Travis Build
+[![Build Status](https://travis-ci.org/Skarlso/jsonpathv2.svg?branch=master)](https://travis-ci.org/Skarlso/jsonpathv2)
+
+# JsonPath - Origin
+
+This gem was forked, than re-written from this Gem: [JsonPath](https://github.com/joshbuddy/jsonpath). Since the original owner clearly abandoned that project, I took the liberty to fork it, and start fixing it. Please feel free to submit any issues you may encounter. PRs are very welcomed.
+
+# JsonPath
+
+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.
+
+## Usage
+
+### Command-line
+
+There is stand-alone usage through the binary `jsonpathv2`
+
+    jsonpathv2 [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 jsonpathv2 expression.
+
+### Library
+
+To use JsonPath as a library simply include and get goin'!
+
+~~~~~ {ruby}
+require 'jsonpathv2'
+
+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
+~~~~~
+
+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')
+~~~~~
+
+Now that we have a path, let's apply it to the object above.
+
+~~~~~ {ruby}
+path.on(json)
+# => [19.95, 8.95, 12.99, 8.99, 22.99]
+~~~~~
+
+Or on some other object ...
+
+~~~~~ {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.
+
+~~~~~ {ruby}
+JsonPath.on(json, '$..author')
+# => ["Nigel Rees", "Evelyn Waugh", "Herman Melville", "Tolkien"]
+~~~~~
+
+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"}
+#    ]
+~~~~~
+
+...and evals.
+
+~~~~~ {ruby}
+JsonPath.new('$..price[?(@ < 10)]').on(json)
+# => [8.95, 8.99]
+~~~~~
+
+There is a convenience method, `#first` that gives you the first element for a JSON object and path.
+
+~~~~~ {ruby}
+JsonPath.new('$..color').first(object)
+# => "red"
+~~~~~
+
+As well, we can directly create an `Enumerable` at any time using `#[]`.
+
+~~~~~ {ruby}
+enum = JsonPath.new('$..color')[object]
+# => #<JsonPath::Enumerable:...>
+enum.first
+# => "red"
+enum.any?{ |c| c == 'red' }
+# => true
+~~~~~
+
+You can optionally prevent eval from being called on sub-expressions by passing in :allow_eval => false to the constructor.
+
+### Manipulation
+
+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
+~~~~~
+
+The result will be
+
+~~~~~ {ruby}
+{'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:
+
+~~~~~ {ruby}
+json = '{"candy":"lollipop","noncandy":null,"other":"things"}'
+o = JsonPath.for(json).
+  gsub('$..candy') {|v| "big turks" }.
+  compact.
+  delete('$..other').
+  to_hash
+# => {"candy" => "big turks"}
+~~~~~

data/ROADMAP.md

@@ -0,0 +1,13 @@
+Roadmap for JsonPath
+====================
+
+
+*0.0.3*
+-------
+
+  * Refactor how tokens are handled in jsonpathv2.rb initialize.
+
+*0.0.2*
+-------
+
+  * Massive refactor of the huge complex case under Enumerable

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :test do
+  $LOAD_PATH << 'lib'
+  require 'minitest/autorun'
+  require 'phocus'
+  require 'jsonpathv2'
+  Dir['./test/**/test_*.rb'].each { |test| require test }
+end
+
+task default: :test

data/bin/jsonpathv2

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'jsonpathv2'
+require 'multi_json'
+
+def usage
+  puts "jsonpathv2 [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 jsonpathv2 expression."
+  exit!
+end
+
+usage unless ARGV[0]
+
+jsonpathv2 = JsonPath.new(ARGV[0])
+case ARGV[1]
+when nil # stdin
+  puts MultiJson.encode(jsonpathv2.on(MultiJson.decode(STDIN.read)))
+when String
+  puts MultiJson.encode(jsonpathv2.on(MultiJson.decode(File.exist?(ARGV[1]) ? File.read(ARGV[1]) : ARGV[1])))
+end

data/jsonpathv2.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require File.join(File.dirname(__FILE__), 'lib', 'jsonpathv2', 'version')
+
+Gem::Specification.new do |s|
+  s.name = 'jsonpathv2'
+  s.version = JsonPath::VERSION
+  s.required_rubygems_version =
+    Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Gergely Brautigam']
+  s.summary = 'Ruby implementation of http://goessner.net/articles/JsonPath/'
+  s.description = 'Ruby implementation of http://goessner.net/articles/JsonPath/.'
+  s.email = 'skarlso777@gmail.com'
+  s.extra_rdoc_files = ['README.md']
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'https://github.com/Skarlso/jsonpathv2'
+  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 = 'jsonpathv2'
+  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_development_dependency 'code_stats'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest', '~> 2.2.0'
+  s.add_development_dependency 'phocus'
+  s.add_development_dependency 'bundler'
+end

data/lib/jsonpathv2/enumerable.rb

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

data/lib/jsonpathv2/proxy.rb

@@ -0,0 +1,55 @@
+class JsonPath
+  class Proxy
+    attr_reader :obj
+    alias_method :to_hash, :obj
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def gsub(path, replacement = nil, &replacement_block)
+      _gsub(_deep_copy, path, replacement ? proc { replacement } : replacement_block)
+    end
+
+    def gsub!(path, replacement = nil, &replacement_block)
+      _gsub(@obj, path, replacement ? proc { replacement } : replacement_block)
+    end
+
+    def delete(path = JsonPath::PATH_ALL)
+      _delete(_deep_copy, path)
+    end
+
+    def delete!(path = JsonPath::PATH_ALL)
+      _delete(@obj, path)
+    end
+
+    def compact(path = JsonPath::PATH_ALL)
+      _compact(_deep_copy, path)
+    end
+
+    def compact!(path = JsonPath::PATH_ALL)
+      _compact(@obj, path)
+    end
+
+    private
+
+    def _deep_copy
+      Marshal.load(Marshal.dump(@obj))
+    end
+
+    def _gsub(obj, path, replacement)
+      JsonPath.new(path)[obj, :substitute].each(&replacement)
+      Proxy.new(obj)
+    end
+
+    def _delete(obj, path)
+      JsonPath.new(path)[obj, :delete].each
+      Proxy.new(obj)
+    end
+
+    def _compact(obj, path)
+      JsonPath.new(path)[obj, :compact].each
+      Proxy.new(obj)
+    end
+  end
+end

data/lib/jsonpathv2/version.rb

@@ -0,0 +1,3 @@
+class JsonPath
+  VERSION = '0.0.2'.freeze
+end

data/lib/jsonpathv2.rb

@@ -0,0 +1,92 @@
+require 'strscan'
+require 'multi_json'
+require 'jsonpathv2/proxy'
+require 'jsonpathv2/enumerable'
+require 'jsonpathv2/version'
+
+class JsonPath
+  PATH_ALL = '$..*'.freeze
+
+  attr_accessor :path
+
+  def initialize(path, opts = nil)
+    @opts = opts
+    scanner = StringScanner.new(path)
+    @path = []
+    until scanner.eos?
+      if token = scanner.scan(/\$|@|\*|\.\./)
+        @path << token
+      elsif token = scanner.scan(/[a-zA-Z0-9_-]+/)
+        @path << "['#{token}']"
+      elsif token = scanner.scan(/'(.*?)'/)
+        @path << "[#{token}]"
+      elsif token = scanner.scan(/\[/)
+        @path << find_matching_brackets(token, scanner)
+      elsif token = scanner.scan(/\]/)
+        raise ArgumentError, 'unmatched closing bracket'
+      elsif scanner.scan(/\./)
+        nil
+      elsif token = scanner.scan(/[><=] \d+/)
+        @path.last << token
+      elsif token = scanner.scan(/./)
+        @path.last << token
+      end
+    end
+  end
+
+  def find_matching_brackets(token, scanner)
+    count = 1
+    until count.zero?
+      if t = scanner.scan(/\[/)
+        token << t
+        count += 1
+      elsif t = scanner.scan(/\]/)
+        token << t
+        count -= 1
+      elsif t = scanner.scan(/[^\[\]]+/)
+        token << t
+      elsif scanner.eos?
+        raise ArgumentError, 'unclosed bracket'
+      end
+    end
+    token
+  end
+
+  def join(join_path)
+    res = deep_clone
+    res.path += JsonPath.new(join_path).path
+    res
+  end
+
+  def on(obj_or_str)
+    enum_on(obj_or_str).to_a
+  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,
+                             @opts)
+  end
+  alias_method :[], :enum_on
+
+  def self.on(obj_or_str, path, opts = nil)
+    new(path, opts).on(process_object(obj_or_str))
+  end
+
+  def self.for(obj_or_str)
+    Proxy.new(process_object(obj_or_str))
+  end
+
+  private
+
+  def self.process_object(obj_or_str)
+    obj_or_str.is_a?(String) ? MultiJson.decode(obj_or_str) : obj_or_str
+  end
+
+  def deep_clone
+    Marshal.load Marshal.dump(self)
+  end
+end

data/test/test_jsonpath.rb

@@ -0,0 +1,236 @@
+class TestJsonpath < MiniTest::Unit::TestCase
+
+  def setup
+    @object = example_object
+    @object2 = example_object
+  end
+
+  def test_bracket_matching
+    assert_raises(ArgumentError) {
+      JsonPath.new('$.store.book[0')
+    }
+    assert_raises(ArgumentError) {
+      JsonPath.new('$.store.book[0]]')
+    }
+    assert_equal [9], JsonPath.new('$.store.book[0].price').on(@object)
+  end
+
+  def test_lookup_direct_path
+    assert_equal 7, JsonPath.new('$.store.*').on(@object).first['book'].size
+  end
+
+  def test_lookup_missing_element
+    assert_equal [], JsonPath.new('$.store.book[99].price').on(@object)
+  end
+
+  def test_retrieve_all_authors
+    assert_equal [
+      @object['store']['book'][0]['author'],
+      @object['store']['book'][1]['author'],
+      @object['store']['book'][2]['author'],
+      @object['store']['book'][3]['author'],
+      @object['store']['book'][4]['author'],
+      @object['store']['book'][5]['author'],
+      @object['store']['book'][6]['author']
+    ], JsonPath.new('$..author').on(@object)
+  end
+
+  def test_retrieve_all_prices
+    assert_equal [
+      @object['store']['bicycle']['price'],
+      @object['store']['book'][0]['price'],
+      @object['store']['book'][1]['price'],
+      @object['store']['book'][2]['price'],
+      @object['store']['book'][3]['price']
+    ].sort, JsonPath.new('$..price').on(@object).sort
+  end
+
+  def test_recognize_array_splices
+    assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[0:1:1]').on(@object)
+    assert_equal [@object['store']['book'][1], @object['store']['book'][3], @object['store']['book'][5]], JsonPath.new('$..book[1::2]').on(@object)
+    assert_equal [@object['store']['book'][0], @object['store']['book'][2], @object['store']['book'][4], @object['store']['book'][6]], JsonPath.new('$..book[::2]').on(@object)
+    assert_equal [@object['store']['book'][0], @object['store']['book'][2]], JsonPath.new('$..book[:-5:2]').on(@object)
+    assert_equal [@object['store']['book'][5], @object['store']['book'][6]], JsonPath.new('$..book[5::]').on(@object)
+  end
+
+  def test_recognize_array_comma
+    assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[0,1]').on(@object)
+    assert_equal [@object['store']['book'][2], @object['store']['book'][6]], JsonPath.new('$..book[2,-1::]').on(@object)
+  end
+
+  def test_recognize_filters
+    assert_equal [@object['store']['book'][2], @object['store']['book'][3]], JsonPath.new("$..book[?(@['isbn'])]").on(@object)
+    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)
+  end
+
+  if RUBY_VERSION[/^1\.9/]
+    def test_recognize_filters_on_val
+      assert_equal [@object['store']['book'][1]['price'], @object['store']['book'][3]['price'], @object['store']['bicycle']['price']], JsonPath.new("$..price[?(@ > 10)]").on(@object)
+    end
+  end
+
+  def test_no_eval
+    assert_equal [], JsonPath.new('$..book[(@.length-2)]', :allow_eval => false).on(@object)
+  end
+
+  def test_paths_with_underscores
+    assert_equal [@object['store']['bicycle']['catalogue_number']], JsonPath.new('$.store.bicycle.catalogue_number').on(@object)
+  end
+
+  def test_path_with_hyphens
+    assert_equal [@object['store']['bicycle']['single-speed']], JsonPath.new('$.store.bicycle.single-speed').on(@object)
+  end
+
+  def test_paths_with_numbers
+    assert_equal [@object['store']['bicycle']['2seater']], JsonPath.new('$.store.bicycle.2seater').on(@object)
+  end
+
+  def test_recognize_array_with_evald_index
+    assert_equal [@object['store']['book'][2]], JsonPath.new('$..book[(@.length-5)]').on(@object)
+  end
+
+  def test_use_first
+    assert_equal @object['store']['book'][2], JsonPath.new('$..book[(@.length-5)]').first(@object)
+  end
+
+  def test_counting
+    assert_equal 49, JsonPath.new('$..*').on(@object).to_a.size
+  end
+
+  def test_space_in_path
+    assert_equal ['e'], JsonPath.new("$.'c d'").on({"a" => "a","b" => "b", "c d" => "e"})
+  end
+
+  def test_class_method
+    assert_equal JsonPath.new('$..author').on(@object), JsonPath.on(@object, '$..author')
+  end
+
+  def test_join
+    assert_equal JsonPath.new('$.store.book..author').on(@object), JsonPath.new('$.store').join('book..author').on(@object)
+  end
+
+  def test_gsub
+    @object2['store']['bicycle']['price'] += 10
+    @object2['store']['book'][0]['price'] += 10
+    @object2['store']['book'][1]['price'] += 10
+    @object2['store']['book'][2]['price'] += 10
+    @object2['store']['book'][3]['price'] += 10
+    assert_equal @object2, JsonPath.for(@object).gsub('$..price') { |p| p + 10 }.to_hash
+  end
+
+  def test_gsub!
+    JsonPath.for(@object).gsub!('$..price') { |p| p + 10 }
+    assert_equal 30, @object['store']['bicycle']['price']
+    assert_equal 19, @object['store']['book'][0]['price']
+    assert_equal 23, @object['store']['book'][1]['price']
+    assert_equal 19, @object['store']['book'][2]['price']
+    assert_equal 33, @object['store']['book'][3]['price']
+  end
+
+  def test_weird_gsub!
+    h = {'hi' => 'there'}
+    JsonPath.for(@object).gsub!('$.*') { |n| h }
+    assert_equal h, @object
+  end
+
+  def test_compact
+    h = {'hi' => 'there', 'you' => nil}
+    JsonPath.for(h).compact!
+    assert_equal({'hi' => 'there'}, h)
+  end
+
+  def test_delete
+    h = {'hi' => 'there', 'you' => nil}
+    JsonPath.for(h).delete!('*.hi')
+    assert_equal({'you' => nil}, h)
+  end
+
+  def test_wildcard
+    assert_equal @object['store']['book'].collect{|e| e['price']}.compact, JsonPath.on(@object, '$..book[*].price')
+  end
+
+  def test_wildcard_empty_array
+    object = @object.merge("bicycle" => { "tire" => [] })
+    assert_equal [], JsonPath.on(object, "$..bicycle.tire[*]")
+  end
+
+  def test_support_filter_by_array_childnode_value
+    assert_equal [@object['store']['book'][3]], JsonPath.new("$..book[?(@.price > 20)]").on(@object)
+  end
+
+  def test_support_filter_by_childnode_value_with_inconsistent_children
+    @object['store']['book'][0] = "string_instead_of_object"
+    assert_equal [@object['store']['book'][3]], JsonPath.new("$..book[?(@.price > 20)]").on(@object)
+  end
+
+  def test_support_filter_by_childnode_value_and_select_child_key
+    assert_equal [23], JsonPath.new("$..book[?(@.price > 20)].price").on(@object)
+  end
+
+  def test_support_filter_by_childnode_value_over_childnode_and_select_child_key
+    assert_equal ["Osennie Vizity"], JsonPath.new("$..book[?(@.written.year == 1996)].title").on(@object)
+  end
+
+  def test_support_filter_by_object_childnode_value
+    data = {
+      "data" => {
+        "type" => "users",
+        "id" => "123"
+      }
+    }
+    assert_equal [{"type"=>"users", "id"=>"123"}], JsonPath.new("$.data[?(@.type == 'users')]").on(data)
+    assert_equal [], JsonPath.new("$.data[?(@.type == 'admins')]").on(data)
+  end
+
+  def example_object
+    { 'store' => {
+      'book' => [
+        { 'category' => 'reference',
+          'author' => 'Nigel Rees',
+          'title' => 'Sayings of the Century',
+          'price' => 9 },
+        { 'category' => 'fiction',
+          'author' => 'Evelyn Waugh',
+          'title' => 'Sword of Honour',
+          'price' => 13 },
+        { 'category' => 'fiction',
+          'author' => 'Herman Melville',
+          'title' => 'Moby Dick',
+          'isbn' => '0-553-21311-3',
+          'price' => 9 },
+        { 'category' => 'fiction',
+          'author' => 'J. R. R. Tolkien',
+          'title' => 'The Lord of the Rings',
+          'isbn' => '0-395-19395-8',
+          'price' => 23 },
+        { 'category' => 'russian_fiction',
+          'author' => 'Lukyanenko',
+          'title' => 'Imperatory Illuziy',
+          'written' => {
+            'year' => 1995
+          } },
+        { 'category' => 'russian_fiction',
+          'author' => 'Lukyanenko',
+          'title' => 'Osennie Vizity',
+          'written' => {
+            'year' => 1996
+          } },
+        { 'category' => 'russian_fiction',
+          'author' => 'Lukyanenko',
+          'title' => 'Ne vremya dlya drakonov',
+          'written' => {
+            'year' => 1997
+          } }
+      ],
+      'bicycle' => {
+        'color' => 'red',
+        'price' => 20,
+        'catalogue_number' => 123_45,
+        'single-speed' => 'no',
+        '2seater' => 'yes'
+      }
+    } }
+  end
+end

data/test/test_jsonpath_bin.rb

@@ -0,0 +1,21 @@
+class TestJsonpathBin < MiniTest::Unit::TestCase
+  def setup
+    @runner = 'ruby -Ilib bin/jsonpathv2'
+    @original_dir = Dir.pwd
+    Dir.chdir(File.join(File.dirname(__FILE__), '..'))
+  end
+
+  def teardown
+    Dir.chdir(@original_dir)
+    `rm /tmp/test.json`
+  end
+
+  def test_stdin
+    assert_equal '["time"]', `echo '{"test": "time"}' | #{@runner} '$.test'`.strip
+  end
+
+  def test_stdin
+    File.open('/tmp/test.json', 'w') { |f| f << '{"test": "time"}' }
+    assert_equal '["time"]', `#{@runner} '$.test' /tmp/test.json`.strip
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: jsonpathv2
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Gergely Brautigam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: code_stats
+  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
+    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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: phocus
+  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: bundler
+  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'
+description: Ruby implementation of http://goessner.net/articles/JsonPath/.
+email: skarlso777@gmail.com
+executables:
+- jsonpathv2
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- ROADMAP.md
+- Rakefile
+- bin/jsonpathv2
+- jsonpathv2.gemspec
+- lib/jsonpathv2.rb
+- lib/jsonpathv2/enumerable.rb
+- lib/jsonpathv2/proxy.rb
+- lib/jsonpathv2/version.rb
+- test/test_jsonpath.rb
+- test/test_jsonpath_bin.rb
+homepage: https://github.com/Skarlso/jsonpathv2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: jsonpathv2
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of http://goessner.net/articles/JsonPath/
+test_files: []