iso-jsonpath 1.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c58f2694eac62a528c76cbdd58c827a9269302570cf765ce4b65611696fac39
+  data.tar.gz: 8331f78eb483639bb0b453c3ec72887bfbf91692982454a1476608ca2d32d012
+SHA512:
+  metadata.gz: ede9bb040400866ea9a8f4674b86dc6b8d63c5774f984eb20c0a59238994a609fd5e2da42a6390d67d2e8133bb3e00acd8baa3650b8e452aa1cdfa65f3f7d74a
+  data.tar.gz: 4b3f0ca17ee3229794e06b620a12e975bdd67d655ca5b0f82c63ffdddd932cc2267864afe4833788bd2ea99c9c11293c5c3437f7e2b5b89230a1c5e5ea3f008b

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

@@ -0,0 +1,10 @@
+pkg/*
+Gemfile.lock
+coverage/*
+doc/*
+.yardoc
+.DS_Store
+.idea
+vendor
+.tags
+*.gem

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -0,0 +1,127 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# 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
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 15
+# Configuration parameters: AllowSafeAssignment.
+Lint/AssignmentInCondition:
+  Exclude:
+    - 'lib/jsonpath.rb'
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 1
+Lint/IneffectiveAccessModifier:
+  Exclude:
+    - 'lib/jsonpath.rb'
+
+# Offense count: 17
+Metrics/AbcSize:
+  Max: 60
+
+# Offense count: 2
+# Configuration parameters: CountComments, ExcludedMethods.
+# ExcludedMethods: refine
+Metrics/BlockLength:
+  Max: 37
+
+# Offense count: 1
+# Configuration parameters: CountBlocks.
+Metrics/BlockNesting:
+  Max: 4
+
+# Offense count: 3
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 739
+
+# Offense count: 7
+Metrics/CyclomaticComplexity:
+  Max: 20
+
+# Offense count: 26
+# Configuration parameters: CountComments, ExcludedMethods.
+Metrics/MethodLength:
+  Max: 52
+
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs.
+Metrics/ParameterLists:
+  Max: 6
+
+# Offense count: 6
+Metrics/PerceivedComplexity:
+  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:
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 2
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/proxy.rb'
+
+# Offense count: 3
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Exclude:
+    - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 2
+# Cop supports --auto-correct.
+Style/IfUnlessModifier:
+  Exclude:
+    - 'lib/jsonpath/enumerable.rb'
+
+# Offense count: 1
+Style/MultipleComparison:
+  Exclude:
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 3
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, EnforcedStyle, IgnoredMethods.
+# SupportedStyles: predicate, comparison
+Style/NumericPredicate:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 3
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, AllowInnerSlashes.
+# SupportedStyles: slashes, percent_r, mixed
+Style/RegexpLiteral:
+  Exclude:
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 4
+# Cop supports --auto-correct.
+Style/RescueModifier:
+  Exclude:
+    - 'lib/jsonpath/enumerable.rb'
+    - 'lib/jsonpath/parser.rb'
+
+# Offense count: 89
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 296

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+gemspec
+# gem 'rubocop', require: true, group: :test
+gem 'simplecov', require: false, group: :test

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Joshua Lin & Gergely Brautigam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,301 @@
+# 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 `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.
+
+### Library
+
+To use JsonPath as a library simply include and get goin'!
+
+```ruby
+require 'jsonpath'
+
+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 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.
+
+```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", "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, including those with conditional operators
+
+```ruby
+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.
+
+```ruby
+JsonPath.new('$..color').first(json)
+# => "red"
+```
+
+As well, we can directly create an `Enumerable` at any time using `#[]`. 
+
+```ruby
+enum = JsonPath.new('$..color')[json]
+# => #<JsonPath::Enumerable:...>
+enum.first
+# => "red"
+enum.any?{ |c| c == 'red' }
+# => true
+```
+
+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:
+
+```ruby
+book = { title: "Sayings of the Century" }
+
+JsonPath.new('$.title').on(book)
+# => []
+
+JsonPath.new('$.title', use_symbols: true).on(book)
+# => ["Sayings of the Century"]
+```
+
+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
+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.
+
+```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"}
+```
+
+### 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!
+
+## Running an individual test
+
+```ruby
+ruby -Ilib:../lib test/test_jsonpath.rb --name test_wildcard_on_intermediary_element_v6
+```

data/Rakefile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+desc 'run rubocop'
+task(:rubocop) do
+  require 'rubocop'
+  cli = RuboCop::CLI.new
+  cli.run
+end
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :test do
+  $LOAD_PATH << 'lib'
+  Dir['./test/**/test_*.rb'].each { |test| require test }
+end
+
+task default: %i[test rubocop]

data/bin/jsonpath

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

data/jsonpath.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), 'lib', 'jsonpath', 'version')
+
+Gem::Specification.new do |s|
+  s.name = 'iso-jsonpath'
+  s.version = JsonPath::VERSION
+  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/.'
+  s.email = ['joshbuddy@gmail.com', 'skarlso777@gmail.com']
+  s.extra_rdoc_files = ['README.md']
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'https://github.com/joshbuddy/jsonpath'
+  s.test_files = `git ls-files`.split("\n").select { |f| f =~ /^spec/ }
+  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 '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