json_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 099520dbb41927983f35746666f093785c9e3e4a
+  data.tar.gz: c6952b7b2b128a298e4e54210760a58cfb3e5238
+SHA512:
+  metadata.gz: 4297d6a7cf28e3295ecc7a22e4573368774583970447a90803915a9334996a9755dbd07a80550f2108b7d8cf9c74d7eb821f1fa5faabc0d72f90f07d6c71c36e
+  data.tar.gz: 08e0851107751b1926997769d018a9c2714c68c3674bb1805aabe80b0d1c37a318e4d39d3145e59edafd04c77838ec06d3b9f8ec2c6cc08710db99ff17df7835

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'safe_attribute_assignment', '0.0.3', git: 'git@github.com:Bidu/safe_attribute_assignment.git'
+end
+

data/Gemfile.lock

@@ -0,0 +1,56 @@
+GIT
+  remote: git@github.com:Bidu/safe_attribute_assignment.git
+  revision: 7ccb0c0f56a1c5f8d3f844144d7b4148069bc2a0
+  specs:
+    safe_attribute_assignment (0.0.3)
+      activesupport
+
+PATH
+  remote: .
+  specs:
+    json_parser (0.1.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    i18n (0.7.0)
+    json (1.8.2)
+    minitest (5.5.1)
+    multi_json (1.10.1)
+    rake (10.4.2)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.3)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  json_parser!
+  rake
+  rspec (~> 2.14)
+  safe_attribute_assignment (= 0.0.3)!
+  simplecov

data/Guardfile

@@ -0,0 +1,13 @@
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, all_after_pass: true, all_on_start: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Bidu.com.br
+
+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,2 @@
+# json_parser
+Hash/Json Parser 

data/Rakefile

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

data/json_parser.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json_parser"
+  spec.version       = JsonParser::VERSION
+  spec.authors       = ["Bidu Dev's Team"]
+  spec.email         = ["dev@bidu.com.br"]
+  spec.summary       = "Json Parser"
+  spec.description   = spec.description
+  spec.homepage      = "https://github.com/Bidu/json_parser"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f)  }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport'
+
+  spec.add_development_dependency 'safe_attribute_assignment'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency 'simplecov'
+end

data/lib/json_parser.rb

@@ -0,0 +1,10 @@
+require 'active_support'
+require 'active_support/all'
+
+module JsonParser
+  extend ActiveSupport::Concern
+
+  require 'json_parser/version'
+  require 'json_parser/fetcher'
+  require 'json_parser/class_methods'
+end

data/lib/json_parser/class_methods.rb

@@ -0,0 +1,103 @@
+module JsonParser::ClassMethods
+  def json_parse(*attr_names)
+    options = {
+      path: nil,
+      json: :json,
+      full_path: nil,
+      cached: false,
+      class: nil,
+      compact: false,
+      after: nil,
+      case: :lower_camel
+    }.merge(attr_names.extract_options!)
+
+    builder = Builder.new(attr_names, self, options)
+    builder.build
+  end
+
+  class Builder
+    attr_reader :attr_names, :options, :methods_def
+
+    def initialize(attr_names, instance, options)
+      @attr_names = attr_names
+      @instance = instance
+      @options = options
+      @methods_def = []
+      init
+    end
+
+    def build
+      methods_def.each do |method_def|
+        @instance.module_eval(method_def, __FILE__, __LINE__ + 1)
+      end
+    end
+
+    private
+
+    def init
+      attr_names.each do |attr|
+        add_attr(attr)
+      end
+    end
+
+    def path
+      options[:path]
+    end
+
+    def json_name
+      options[:json]
+    end
+
+    def full_path(attribute)
+      options[:full_path] || [path, attribute].compact.join('.')
+    end
+
+    def cached
+      options[:cached]
+    end
+
+    def clazz
+      options[:class]
+    end
+
+    def compact
+      options[:compact]
+    end
+
+    def after
+      options[:after] ? ":#{options[:after]}" : false
+    end
+
+    def case_type
+      options[:case]
+    end
+
+    def add_attr(attribute)
+      @methods_def << <<-CODE
+        def #{attribute}
+          #{cached ? cached_fetcher(attribute) : attr_fetcher(attribute)}
+        end
+      CODE
+    end
+
+    def attr_fetcher(attribute)
+      <<-CODE
+        JsonParser::Fetcher.new(
+          #{json_name}, '#{full_path(attribute)}', {
+            instance: self,
+            class: #{clazz || 'nil'},
+            compact: #{compact || 'false'},
+            after: #{after},
+            case_type: :#{case_type}
+          }
+        ).fetch
+      CODE
+    end
+
+    def cached_fetcher(attribute)
+      <<-CODE
+        @#{attribute} ||= #{attr_fetcher(attribute)}
+      CODE
+    end
+  end
+end

data/lib/json_parser/fetcher.rb

@@ -0,0 +1,72 @@
+class JsonParser::Fetcher
+  attr_reader :path, :json, :options
+
+  def initialize(json, path, options = {})
+    @path = path.to_s.split('.')
+    @json = json
+    @options = options
+  end
+
+  def fetch
+    value = crawl(json, path)
+    value = instance.send(after, value) if after
+    value
+  end
+
+  private
+
+  def crawl(json, path)
+    return nil if json.nil?
+    return wrap(json) if path.empty?
+    return crawl_array(json, path) if json.is_a? Array
+
+    key = change_case(path[0])
+    value = json.key?(key) ? json[key] : json[key.to_sym]
+    crawl(value, path[1,path.size])
+  end
+
+  def change_case(key)
+    case case_type
+    when :lower_camel
+      key.camelize(:lower)
+    when :upper_camel
+      key.camelize(:upper)
+    when :snake
+      key.underscore
+    end
+  end
+
+  def crawl_array(array, path)
+    array.map { |j| crawl(j, path) }.tap do |a|
+      a.compact! if compact
+    end
+  end
+
+  def wrap(json)
+    return json unless clazz
+    return clazz.new json unless json.is_a? Array
+    json.map { |v| wrap v }.tap do |j|
+      j.compact! if compact
+    end
+  end
+
+  def clazz
+    options[:class]
+  end
+
+  def after
+    options[:after]
+  end
+
+  def instance
+    options[:instance]
+  end
+
+  def compact
+    options[:compact]
+  end
+
+  def case_type
+    options[:case_type]
+  end
+end

data/lib/json_parser/version.rb

@@ -0,0 +1,3 @@
+module JsonParser
+  VERSION = '0.1.0'
+end

data/spec/fixtures/json_parser.json

@@ -0,0 +1,39 @@
+{
+  "id": 100,
+  "user": {
+    "name": "usuario"
+  },
+  "age": 20,
+  "father": {
+    "name": "father full name"
+  },
+  "hasMoney": true,
+  "house": {
+    "age": 20,
+    "value": 1000,
+    "floors": 3
+  },
+  "oldHouse": {
+    "age": 30,
+    "value": 500,
+    "floors": 1
+  },
+  "games": [
+    {
+      "name": "zelda",
+      "publisher": "nintendo"
+    }, {
+      "name": "mario",
+      "publisher": "nintendo"
+    }, {
+      "name": "sonic",
+      "publisher": "sega"
+    }
+  ],
+  "animals":[
+    {"race": {"species": {"name": "European squid"}}},
+    {"race": {"species": {"name": "Macaque monkey"}}},
+    {"race": {"species": {"name": "Mexican redknee tarantula"}}}
+  ]
+
+}

data/spec/lib/json_parser_spec.rb

@@ -0,0 +1,317 @@
+require 'spec_helper'
+
+describe JsonParser do
+  class JsonParser::House
+    include JsonParser
+    include ::SafeAttributeAssignment
+    attr_reader :json
+
+    json_parse :age, :value, :floors
+
+    def initialize(json)
+      @json = json
+    end
+  end
+
+  class JsonParser::Game
+    include JsonParser
+    include SafeAttributeAssignment
+    attr_reader :json
+
+    json_parse :name, :publisher
+
+    def initialize(json)
+      @json = json
+    end
+  end
+
+  class JsonParser::Dummy
+    include JsonParser
+    attr_reader :json
+
+    json_parse :id
+    json_parse :name, path: 'user'
+    json_parse :model, path: 'car'
+    json_parse :father_name, full_path: 'father.name'
+    json_parse :age, cached: true
+    json_parse :has_money
+    json_parse :house, class: JsonParser::House
+    json_parse :old_house, class: JsonParser::House, cached: true
+    json_parse :games, class: JsonParser::Game
+    json_parse :species_name, full_path: 'animals.race.species.name', compact: true
+    json_parse :games_filtered, class: JsonParser::Game, after: :filter_games, full_path: 'games'
+
+    def initialize(json)
+      @json = json
+    end
+
+    def filter_games(games)
+      games.select do |g|
+        g.publisher != 'sega'
+      end
+    end
+  end
+
+  let(:dummy) { JsonParser::Dummy.new(json) }
+  let(:json) { load_json_fixture_file('json_parser.json') }
+  let(:value) { dummy.public_send(attribute) }
+
+  context 'when parser is configured with no options' do
+    let(:attribute) { :id }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['id'])
+    end
+
+    context 'when calling the method twice' do
+      before do
+        dummy.public_send(attribute)
+      end
+
+      it 'retrieves attribute from base json' do
+        expect(value).to eq(json['id'])
+      end
+    end
+
+    context 'when changing json value' do
+      let!(:old_value) { json['id'] }
+      before do
+        dummy.id
+        json['id'] = 200
+      end
+      it 'retrieves the new value' do
+        expect(value).not_to eq(old_value)
+      end
+    end
+  end
+
+  context 'when parser is configured with a path' do
+    let(:attribute) { :name }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['user']['name'])
+    end
+  end
+
+  context 'parser finds a nil attribute' do
+    let(:attribute) { :model }
+
+    it 'returns nil' do
+      expect(value).to be_nil
+    end
+
+    it do
+      expect { value }.not_to raise_error
+    end
+  end
+
+  context 'when json is instead of empty' do
+    let(:json) { nil }
+    let(:attribute) { :model }
+
+    it 'returns nil' do
+      expect(value).to be_nil
+    end
+
+    it do
+      expect { value }.not_to raise_error
+    end
+  end
+
+  context 'when configuring full path' do
+    let(:attribute) { :father_name }
+
+    it 'returns nil' do
+      expect(value).to eq(json['father']['name'])
+    end
+  end
+
+  context 'when caching the value' do
+    let(:attribute) { :age }
+    let!(:old_value) { json['age'] }
+    before do
+      dummy.age
+      json['age'] = old_value + 100
+    end
+
+    it 'returns cached value' do
+      expect(value).to eq(old_value)
+    end
+  end
+
+  context 'with an snake case option' do
+    let(:attribute) { :has_money }
+
+    it 'returns camel cased value' do
+      expect(value).to eq(json['hasMoney'])
+    end
+  end
+
+  context 'when wrapping it with a class' do
+    let(:attribute) { :house }
+
+    it 'returns an onject wrap' do
+      expect(value).to be_a(JsonParser::House)
+    end
+
+    it 'creates the object with the given json' do
+      expect(value.age).to eq(json['house']['age'])
+      expect(value.value).to eq(json['house']['value'])
+      expect(value.floors).to eq(json['house']['floors'])
+    end
+
+    context 'when dealing with an array' do
+      let(:attribute) { :games }
+
+      it 'returns an array of json wrapped' do
+        expect(value).to be_a(Array)
+        value.each do |object|
+          expect(object).to be_a(JsonParser::Game)
+        end
+      end
+
+      context 'when dealing with multiple level arrays' do
+        let(:attribute) { :games }
+        before do
+          json['games'].map! { |j| [j] }
+        end
+
+        it 'returns an array of json wrapped' do
+          expect(value).to be_a(Array)
+          value.each do |object|
+            expect(object).to be_a(Array)
+            object.each do |game|
+              expect(game).to be_a(JsonParser::Game)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'when wrapping it with a class and caching' do
+    let(:attribute) { :old_house }
+    let!(:old_value) { json['oldHouse'] }
+    before do
+      dummy.old_house
+      json['oldHouse'] = {}
+    end
+
+    it 'returns an onject wrap' do
+      expect(value).to be_a(JsonParser::House)
+    end
+
+    it 'creates the object with the given json' do
+      expect(value.age).not_to eq(json['oldHouse']['age'])
+      expect(value.age).to eq(old_value['age'])
+      expect(value.value).not_to eq(json['oldHouse']['value'])
+      expect(value.value).to eq(old_value['value'])
+      expect(value.floors).not_to eq(json['oldHouse']['floors'])
+      expect(value.floors).to eq(old_value['floors'])
+    end
+  end
+
+  context 'when dealing with json inside arrays' do
+    let(:attribute) { :species_name }
+    let(:expected) do
+      ['European squid', 'Macaque monkey', 'Mexican redknee tarantula']
+    end
+
+    it do
+      expect(value).to be_a(Array)
+    end
+
+    it 'parses them mapping arrays as sub parse' do
+      expect(value).to eq(expected)
+    end
+
+    context 'when there are nil values and compact is true' do
+      before do
+        json["animals"].last['race'] = nil
+      end
+      let(:expected) do
+        ['European squid', 'Macaque monkey']
+      end
+
+      it 'eliminate nil values' do
+        expect(value).to eq(expected)
+      end
+    end
+  end
+
+  context 'when passing an after filter' do
+    let(:attribute) { :games_filtered }
+
+    it 'applies the filter after parsing the json' do
+      expect(value.map(&:publisher)).not_to include('sega')
+    end
+  end
+
+  context 'when using a snake case' do
+    class JsonParser::Dummy
+      json_parse :snake_cased, case: :snake
+    end
+
+    let(:json) { { snake_cased: 'snake', snakeCased: 'Camel' }.stringify_keys }
+    let(:attribute) { :snake_cased }
+
+    it 'fetches from snake cased fields' do
+      expect(value).to eq('snake')
+    end
+  end
+
+  context 'when using a upper camel case' do
+    class JsonParser::Dummy
+      json_parse :upper_case, case: :upper_camel
+    end
+
+    let(:json) { { UpperCase: 'upper', upperCase: 'lower' }.stringify_keys }
+    let(:attribute) { :upper_case }
+
+    it 'fetches from upper camel cased fields' do
+      expect(value).to eq('upper')
+    end
+  end
+
+  context 'when using a symbol keys' do
+    let(:json) { load_json_fixture_file('json_parser.json').symbolize_keys }
+    let(:attribute) { :id }
+
+    it 'fetches from symbol keys' do
+      expect(value).to eq(json[:id])
+    end
+
+    context 'parser finds a nil attribute' do
+      let(:attribute) { :model }
+
+      it 'returns nil' do
+        expect(value).to be_nil
+      end
+
+      it do
+        expect { value }.not_to raise_error
+      end
+    end
+  end
+
+  context 'when using key with false value' do
+    let(:attribute) { :has_money }
+    before do
+      json['hasMoney'] = false
+    end
+
+    context 'with string keys' do
+      it { expect(value).to be_falsey }
+      it { expect(value).not_to be_nil }
+    end
+
+    context 'with symbol keys' do
+      before do
+        json.symbolize_keys!
+      end
+
+      it { expect(value).to be_falsey }
+      it { expect(value).not_to be_nil }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'json_parser'
+require 'safe_attribute_assignment'
+
+support_files = File.expand_path("spec/support/**/*.rb")
+Dir[support_files].each { |file| require file  }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.filter_run_excluding :integration unless ENV['ALL']
+
+  config.order = 'random'
+
+  config.before do
+  end
+end

data/spec/support/fixture_helpers.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+
+module FixtureHelpers
+  def load_fixture_file(filename)
+      File.read (['./spec/', 'fixtures', filename].join('/'))
+  end
+
+  def load_json_fixture_file(filename)
+    cached_json_fixture_file(filename)
+  end
+
+  private
+
+  def cached_json_fixture_file(filename)
+      ActiveSupport::JSON.decode(load_fixture_file(filename))
+  end
+end
+
+RSpec.configuration.include FixtureHelpers

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: json_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bidu Dev's Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-08 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: safe_attribute_assignment
+  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: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: ''
+email:
+- dev@bidu.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- json_parser.gemspec
+- lib/json_parser.rb
+- lib/json_parser/class_methods.rb
+- lib/json_parser/fetcher.rb
+- lib/json_parser/version.rb
+- spec/fixtures/json_parser.json
+- spec/lib/json_parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixture_helpers.rb
+homepage: https://github.com/Bidu/json_parser
+licenses: []
+metadata: {}
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Json Parser
+test_files:
+- spec/fixtures/json_parser.json
+- spec/lib/json_parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixture_helpers.rb