json_parse 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad25f31480a214b84831cc94de6f493b4fa25dd9cf4cdc6a3547f46096319c38
+  data.tar.gz: f8d1dea85965fe7fcf1a1c1b007d3a7fada2d02ce01468ee193e462efdced2a6
+SHA512:
+  metadata.gz: 93f4605824ce3d8d22d1d0e226a651cf620d52158502a1d36bdd3b6031897499b65ad6884a5b1767678f291292486bf57ddfc6b428dba48831650c9dad423d2b
+  data.tar.gz: 70358538198a185ae3e41ca514db90e8dc09467d043169b620a691a15eb0a84679e50882900936d8bdd555070bf99d541f0e7b8da6187fb650c3828982ca260b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.idea/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.17.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in JsonParse.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    json_parse (0.1.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    concurrent-ruby (1.1.4)
+    diff-lcs (1.3)
+    i18n (1.1.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  json_parse!
+  rake (~> 10.0)
+  rspec (~> 3.2)
+
+BUNDLED WITH
+   1.17.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Grapevine Gizmos LLC
+
+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,149 @@
+# JsonParse
+
+JsonParse is a gem for use in Rails to discover and navigate json documents with simple dot notation, and to extract subtrees, nodes and values with a minimum of fuss.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'json_parse'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install JsonParse
+
+## Usage
+
+Load with Json string:
+
+`my_jsonstring= "{\"company_name\":\"Acme Industries\",\"company_id\":1085}"
+`
+`jp=JsonParse.new(my_jsonstring)`
+
+Load with a hash
+
+`jp=JsonParse.new({company_name: "Acme Industries", company_id: 1085})`
+
+Access an element using dot notation:
+
+`puts "#{jp.company_name} id: #{jp.company_id}`  #Acme Industries id: 1085
+
+Consider Json representation of a more complex object: (thanks to [cuberule.com](http://cuberule.com)!)
+
+`cuberule = "{\"rule\":\"cube\",\"authority\":\"http://cuberule.com\",\"specification\":{\"salad\":{\"sides\":0,\"examples\":[{\"name\":\"steak\",\"type\":\"salad\"},{\"name\":\"mashed potatoes\",\"type\":\"salad\"},{\"name\":\"fried rice\",\"type\":\"salad\"},{\"name\":\"poutine\",\"type\":\"salad\"}],\"name\":\"salad\"},\"toast\":{\"sides\":1,\"examples\":[{\"name\":\"pizza\",\"type\":\"toast\"},{\"name\":\"muffins\",\"type\":\"toast\"},{\"name\":\"salmon sushi\",\"type\":\"toast\"}],\"name\":\"toast\"},\"sandwich\":{\"sides\":2,\"examples\":[{\"name\":\"lasagna\",\"type\":\"sandwich\"},{\"name\":\"quesadilla\",\"type\":\"sandwich\"}],\"name\":\"sandwich\"},\"taco\":{\"sides\":3,\"examples\":[{\"name\":\"hot dog\",\"type\":\"taco\"},{\"name\":\"slice of pie\",\"type\":\"taco\"},{\"name\":\"subway sandwich\",\"type\":\"taco\"}],\"name\":\"taco\"},\"sushi\":{\"sides\":4,\"examples\":[{\"name\":\"pigs in a blanket\",\"type\":\"sushi\"},{\"name\":\"enchilada\",\"type\":\"sushi\"},{\"name\":\"felafel wrap\",\"type\":\"sushi\"}],\"name\":\"sushi\"},\"quiche\":{\"sides\":5,\"examples\":[{\"name\":\"cheesecake\",\"type\":\"quiche\"},{\"name\":\"soup in a breadbowl\",\"type\":\"quiche\"},{\"name\":\"key lime pie\",\"type\":\"quiche\"},{\"name\":\"deep-dish pizza\",\"type\":\"quiche\"}],\"name\":\"quiche\"},\"calzone\":{\"sides\":6,\"examples\":[{\"name\":\"burrito\",\"type\":\"calzone\"},{\"name\":\"corn dog\",\"type\":\"calzone\"},{\"name\":\"pop tart\",\"type\":\"calzone\"}],\"name\":\"calzone\"}}}"`
+
+Pretty printing the hash using jp.hash gives a comprehensible view.  
+
+
+`jp= JsonParse.new(cuberule)`  
+`puts pp jp.hash`
+```ruby
+{:rule=>"cube",
+ :authority=>"http://cuberule.com",
+ :specification=>
+  {:salad=>
+    {:sides=>0,
+     :examples=>
+      [{"name"=>"steak", "type"=>"salad"},
+       {"name"=>"mashed potatoes", "type"=>"salad"},
+       {"name"=>"fried rice", "type"=>"salad"},
+       {"name"=>"poutine", "type"=>"salad"}],
+     :name=>"salad"},
+   :toast=>
+    {:sides=>1,
+     :examples=>
+      [{"name"=>"pizza", "type"=>"toast"},
+       {"name"=>"muffins", "type"=>"toast"},
+       {"name"=>"salmon sushi", "type"=>"toast"}],
+     :name=>"toast"},
+   [...]
+   :calzone=>
+    {:sides=>6,
+     :examples=>
+      [{"name"=>"burrito", "type"=>"calzone"},
+       {"name"=>"corn dog", "type"=>"calzone"},
+       {"name"=>"pop tart", "type"=>"calzone"}],
+     :name=>"calzone"}}}
+
+```
+
+We can retrieve the value of any node by following the tree:
+```Ruby
+jp.specification.toast.sides
+=> 6
+jp.specification.calzone.examples[0].name'
+=>"burrito"
+````
+
+Obtain the keys to any branch of the json document using the `keys` method.  If the referenced element is a container of other elements, the keys it contains are returned by the keys method.  If the element contains an array, '[]' is returned. If the keys method is called on an element whose value is a scalar, an undefined method error will result.
+
+```
+`puts jp.specification.calzone.keys` 
+ => [:sides, :examples, :name]`
+   
+jp.specification.calzone.examples.keys
+=> "[]"
+jp.specification.calzone.sides.keys
+jp.specification.calzone.sides.keys 
+=> undefined method `keys' for 6:Integer
+```
+
+
+Dot notation is used to access the value of an element in the json docuemnt.  if the element is a key to another set of json elements, a new JsonParse is created and returned to the caller.
+  
+```Ruby
+branch=jp.specification.calzone #brach contains a new JsonParse object
+branch.keys  #[:sides, :examples, :names]
+branch.sides
+=> 6
+````
+If the referenced element contains an array, it will be retrieved as an array of JsonParse.  Its elements can be accessed by index.  The keys method can be used on the indexed element to reveal the available symbols.
+``` 
+examples = jp.specification.calzone.examples 
+puts examples[1].keys
+=>[:name, :type]
+
+puts "#{examples[1].name}  type:  #{examples[1].type}"
+=> "corn dog  type:  calzone"
+```
+
+JsonParse arrays can be interated with the `each` method.  
+```Ruby 
+jp.specification.salad.examples.each do |example| puts example.name end`
+
+steak  
+mashed potatoes   
+fried rice
+poutine
+```
+
+In additions to `keys`, JsonParse wraps the convenience methods `length` & `count` to return the number of keys in a document element, or the number of items in an array element. The `rootkey` method returns the name of the singular document root element (if present). 
+ 
+The `hash` and `json_string` methods return a hash and json representation of the object respectively.
+These methods can be useful to extract the relevant portion of a subbracnch and generate new json representation of just that branch.  The `source` method returns the string or hash supplied when the object was initialized.   
+
+Because some of these methods may also represent keys in a json string (viz. `count`, `keys`, `source`), if a matching key exists as an attribute name, the attribute value will be returned instead of the method's value. 
+Appending a '!' to the method name (viz `count!`, `keys!`, `hash!`) will return the intended method result irrespective of the presence of an identical key in the json document.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/JsonParse.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+ 

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "json_parse"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/json_parse.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "json_parse/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "json_parse"
+  spec.version       = JsonParse::VERSION
+  spec.authors       = ["Grapevine Gizmos LLC"]
+  spec.email         = ["grapevinegizmos@gmail.com"]
+
+  spec.summary       = "Easy to use JsonParser for Rails"
+  spec.description   = "Load JsonParse with a json string or hash, and then refer to elements with dot notation."
+  spec.homepage      = "https://github.com/grapevinegizmos/JsonParse"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/grapevinegizmos/JsonParse.git"
+    spec.metadata["changelog_uri"] = "https://github.com/grapevinegizmos/JsonParse.git"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_dependency "activesupport"
+end

data/lib/json_parse.rb

@@ -0,0 +1,310 @@
+require "json_parse/version"
+require "active_support/all"
+
+class JsonParse
+  include Enumerable
+  @jsonstring = nil
+  @rootkey = nil
+  @throwmissing = true #determines whether the parser throws an exception or returns nil if a key is not found.  Set to false after debugging!
+  @source = nil
+  @h = nil
+
+
+  def method_missing(m, *args)
+
+    #looks for top level keys and returns the value
+    a = args
+    if !(self.keys!.include?(m))
+      if @throwmissing
+        super
+      else
+        return nil
+      end
+    end
+    self._value(m)
+  end
+
+  # @return [JsonParse]
+  # @param [Object] symbol
+  def get_by_key(symbol)
+    method_missing(symbol.to_sym, nil)
+  end
+
+  def each(&block)
+    if self._check_for_keyword("each")
+      return _value(:each)
+    end
+    _each(&block)
+  end
+
+  def each!(&block)
+    _each(&block)
+  end
+
+  def length
+    if self._check_for_keyword("length")
+      return _value(:length)
+    end
+    @h.length
+  end
+
+  def length!
+    return _length
+  end
+
+  def keys!
+    _keys
+  end
+
+  def keys
+    if self._check_for_keyword("keys")
+      return self._value(:keys)
+    end
+    _keys
+  end
+
+  def source!
+    _source
+  end
+  def source
+    if self._check_for_keyword("keys")
+      return self._value(:keys)
+    end
+    _source
+  end
+
+  def add(key, value)
+    @h[key.to_sym] = value
+  end
+
+  def initialize(val, rootkey = nil, throwmissing = false) #, jsonstring = '{"root": {"name":"Josh Kramer", "age":60, "children": [{"name": "jack", "age": 21},{"name": "sally","age":14}],  "pets": ["ruby","buddy","fluffy"], "address": {"city" : "Bainbridge Island", "state" : "WA"}}}')
+    @source = val
+    if val.nil?
+      @h = {}
+      @rootkey = nil
+      return
+    end
+    @throwmissing = throwmissing
+    @rootkey = rootkey
+    if val.is_a?(JsonParse)
+      @h = val.hash
+      @rootkey = val.rootkey
+
+    end
+
+    if val.is_a?(Array)
+      retval = []
+      @rootkey = rootkey
+      val.each do |item|
+        if item.is_a?(Hash) || item.is_a?(Array)
+          retval.push(JsonParse.new(item))
+        else
+          retval.push(item);
+        end
+
+      end
+      @h = retval
+    end
+    if val.is_a?(Hash)
+      @h = val.symbolize_keys!
+      _discard_root #
+    end
+    if val.is_a?(String) #if it sa string, it should be a json string
+      _load(val)
+      @jsonstring = val
+    end
+
+    if @h.nil?
+      raise "an unusable object was provided to the initializer"
+    end
+
+  end
+
+
+  def rootkey
+    if self._check_for_keyword("rootkey")
+      return _value(:rootkey)
+    end
+    _rootkey
+  end
+  def rootkey!
+    _rootkey
+  end
+
+
+  def json_string
+    if self._check_for_keyword("json_string")
+      return _value(:json_string)
+    end
+    @h.to_json
+  end
+
+  def json_string!
+    _json_string
+  end
+
+
+
+  def contains_key(key = nil)
+    if key == nil && self._check_for_keyword("contains_key")
+      return _value(:contains_key)
+    end
+    @h.keys.include?(key)
+  end
+
+
+
+
+  def [](index)
+    if @h.is_a?(Array)
+      return @h[index]
+    end
+    nil
+
+  end
+
+  def count!
+    _count
+  end
+  def count
+    if self._check_for_keyword("hash")
+      return _value(:hash)
+    end
+    _count
+  end
+
+  def hash!
+    _hash
+  end
+  def hash
+    if self._check_for_keyword("hash")
+      return _value(:hash)
+    end
+   _hash
+  end
+
+  def _symbolize(h)
+    if self._check_for_keyword("_symbolize")
+      return _value("_symbolize")
+    end
+
+    h.symbolize_keys!
+    h.each do |k, v|
+      if v.is_a?(Hash)
+        self._symbolize(v)
+      end
+    end
+  end
+
+
+
+
+  def _check_for_keyword(keyword)
+    mykeys = []
+    if @h.is_a?(Hash)
+      mykeys = @h.keys
+    end
+    mykeys.include?(keyword.to_sym)
+  end
+
+
+  # @return (Hash)
+  # @param [String] jsonString
+  def _parse_json(jsonString)
+    v = ActiveSupport::JSON.decode(jsonString)
+  end
+
+  def _value(key)
+    if @h.is_a?(Array)
+      return @h[key]
+    end
+    if @h.key?(key.to_sym)
+      if @h[key].is_a?(Hash) || @h[key].is_a?(Array)
+        return JsonParse.new(@h[key], key)
+      else
+        retval = @h[key]
+
+        return retval
+      end
+    end
+  end
+
+
+  private
+
+  def _length
+    return @h.length
+  end
+
+
+  def _keys
+    if @h.is_a?(Hash)
+      return @h.keys
+    end
+    if @h.is_a?(Array)
+      return "[]"
+    else
+      return nil if @h.nil?
+      raise "expecting hash or array, got #{@h.class.name}"
+    end
+
+  end
+
+  def _each(&block)
+    if block_given?
+      @h.each(&block)
+    else
+      return nil
+    end
+  end
+
+  def _source
+    @source
+  end
+  def _hash
+    @h
+  end
+  def _count
+    @h.length
+  end
+
+  def _load(jsonstring)
+    if jsonstring.nil? && self._check_for_keyword("load")
+      return _value(:load)
+    end
+    # var [Hash] @h
+    @h = _parse_json(jsonstring)
+    self._symbolize(@h)
+    self._discard_root
+  end
+
+  def _json_string
+    @h.to_json
+  end
+  def _rootkey
+    @rootkey.to_s
+  end
+
+  def _discard_root()
+
+    h2 = {}
+
+    if @h.length == 1
+      @rootkey = @h.keys[0]
+
+      if @h.values[0].is_a?(Hash)
+        @h.values[0].each do |k, v|
+          h2[k] = v
+        end
+      end
+    end
+    if h2.length > 0
+      @h = h2
+
+    end
+  end
+
+
+
+end
+

data/lib/json_parse/version.rb

@@ -0,0 +1,3 @@
+class JsonParse
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: json_parse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Grapevine Gizmos LLC
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
+description: Load JsonParse with a json string or hash, and then refer to elements
+  with dot notation.
+email:
+- grapevinegizmos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- json_parse.gemspec
+- lib/json_parse.rb
+- lib/json_parse/version.rb
+homepage: https://github.com/grapevinegizmos/JsonParse
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/grapevinegizmos/JsonParse
+  source_code_uri: https://github.com/grapevinegizmos/JsonParse.git
+  changelog_uri: https://github.com/grapevinegizmos/JsonParse.git
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Easy to use JsonParser for Rails
+test_files: []