json_parser 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 099520dbb41927983f35746666f093785c9e3e4a
-  data.tar.gz: c6952b7b2b128a298e4e54210760a58cfb3e5238
+  metadata.gz: aa3db49e4e788b1d0842fc1a76177a420dddea7a
+  data.tar.gz: 2e53eee8b60b49d2c789adc5da2aa415b83528c9
 SHA512:
-  metadata.gz: 4297d6a7cf28e3295ecc7a22e4573368774583970447a90803915a9334996a9755dbd07a80550f2108b7d8cf9c74d7eb821f1fa5faabc0d72f90f07d6c71c36e
-  data.tar.gz: 08e0851107751b1926997769d018a9c2714c68c3674bb1805aabe80b0d1c37a318e4d39d3145e59edafd04c77838ec06d3b9f8ec2c6cc08710db99ff17df7835
+  metadata.gz: c501a429649f8578db081111b1db7d07475f31645764277aed8f02ec834cece16b739fe5f5769ec41dfe46c02cd58db7e147fcf361a82114f616fa60b04c7264
+  data.tar.gz: bdf68e4a5fb504178908b51bbc992028b0442c4f9009db32c1e85c6f9de29cc13aeb676529e07c9937691708b150364a094dfc9316e959b4c6807cafc5520a56

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/Gemfile.lock

@@ -1,14 +1,7 @@
-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)
+    json_parser (1.0.0)
       activesupport
 
 GEM
@@ -35,6 +28,8 @@ GEM
     rspec-expectations (2.99.2)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.99.3)
+    safe_attribute_assignment (0.0.3)
+      activesupport
     simplecov (0.9.1)
       docile (~> 1.1.0)
       multi_json (~> 1.0)
@@ -52,5 +47,5 @@ DEPENDENCIES
   json_parser!
   rake
   rspec (~> 2.14)
-  safe_attribute_assignment (= 0.0.3)!
+  safe_attribute_assignment (= 0.0.3)
   simplecov

data/lib/concerns/options_parser.rb

@@ -0,0 +1,9 @@
+module OptionsParser
+  extend ActiveSupport::Concern
+
+  attr_reader :options
+
+  def options_object
+    @options_object ||= OpenStruct.new options
+  end
+end

data/lib/concerns/type_cast.rb

@@ -0,0 +1,15 @@
+module TypeCast
+  extend ActiveSupport::Concern
+
+  def to_integer(value)
+    value.to_i if value.present?
+  end
+
+  def to_string(value)
+    value.to_s
+  end
+
+  def to_float(value)
+    value.to_f if value.present?
+  end
+end

data/lib/json_parser.rb

@@ -4,7 +4,12 @@ require 'active_support/all'
 module JsonParser
   extend ActiveSupport::Concern
 
+  require 'concerns/type_cast'
+  require 'concerns/options_parser'
   require 'json_parser/version'
+  require 'json_parser/crawler'
+  require 'json_parser/wrapper'
   require 'json_parser/fetcher'
   require 'json_parser/class_methods'
+  require 'json_parser/class_methods/builder'
 end

data/lib/json_parser/class_methods.rb

@@ -1,4 +1,5 @@
 module JsonParser::ClassMethods
+
   def json_parse(*attr_names)
     options = {
       path: nil,
@@ -7,97 +8,13 @@ module JsonParser::ClassMethods
       cached: false,
       class: nil,
       compact: false,
-      after: nil,
-      case: :lower_camel
+      flatten: false,
+      after: false,
+      case: :lower_camel,
+      type: :none
     }.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/class_methods/builder.rb

@@ -0,0 +1,74 @@
+class JsonParser::ClassMethods::Builder
+  include OptionsParser
+
+  attr_reader :attr_names, :methods_def
+
+  delegate :path, :cached, :compact, :type, :after, to: :options_object
+
+  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 json_name
+    options[:json]
+  end
+
+  def full_path(attribute)
+    options[:full_path] || [path, attribute].compact.join('.')
+  end
+
+  def clazz
+    options[:class]
+  end
+
+  def case_type
+    options[:case]
+  end
+
+  def fetcher_options
+    options.slice(:compact, :after, :type, :flatten).merge({
+      clazz: clazz,
+      case_type: case_type
+    })
+  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)}', self, #{fetcher_options}
+      ).fetch
+    CODE
+  end
+
+  def cached_fetcher(attribute)
+    <<-CODE
+      @#{attribute} ||= #{attr_fetcher(attribute)}
+    CODE
+  end
+end

data/lib/json_parser/crawler.rb

@@ -0,0 +1,53 @@
+class JsonParser::Crawler
+  include OptionsParser
+
+  attr_reader :post_process, :path
+
+  delegate :case_type, :compact, to: :options_object
+
+  def initialize(path, options = {}, &block)
+    @options = options
+    @path = path.map { |p| change_case(p) }
+    @post_process = block
+  end
+
+  def crawl(json, index = 0)
+    return nil if json.nil?
+    return wrap(json) if is_ended?(index)
+    return crawl_array(json, index) if json.is_a? Array
+
+    crawl(fetch(json, index), index + 1)
+  end
+
+  private
+
+  def fetch(json, index)
+    key = path[index]
+    json.key?(key) ? json[key] : json[key.to_sym]
+  end
+
+  def is_ended?(index)
+    index >= path.size
+  end
+
+  def wrap(json)
+    post_process.call(json)
+  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, index)
+    array.map { |j| crawl(j, index) }.tap do |a|
+      a.compact! if compact
+    end
+  end
+end

data/lib/json_parser/fetcher.rb

@@ -1,72 +1,51 @@
 class JsonParser::Fetcher
-  attr_reader :path, :json, :options
+  include OptionsParser
 
-  def initialize(json, path, options = {})
+  attr_reader :path, :json, :instance
+
+  delegate :after, :flatten, to: :options_object
+  delegate :wrap, to: :wrapper
+  delegate :crawl, to: :crawler
+
+  def initialize(json, path, instance, options = {})
     @path = path.to_s.split('.')
     @json = json
+    @instance = instance
     @options = options
   end
 
   def fetch
-    value = crawl(json, path)
+    value = crawl(json)
+    value.flatten! if flatten && value.respond_to?(:flatten!)
     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
+  def crawler
+    @crawler ||= buidl_crawler
   end
 
-  def crawl_array(array, path)
-    array.map { |j| crawl(j, path) }.tap do |a|
-      a.compact! if compact
+  def buidl_crawler
+    JsonParser::Crawler.new(path, crawler_options) do |value|
+      wrap(value)
     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]
+  def crawler_options
+    options.slice(:case_type, :compact)
   end
 
-  def instance
-    options[:instance]
+  def wrapper
+    @wrapper ||= build_wrapper
   end
 
-  def compact
-    options[:compact]
+  def build_wrapper
+    JsonParser::Wrapper.new(wrapper_options)
   end
 
-  def case_type
-    options[:case_type]
+  def wrapper_options
+    options.slice(:clazz, :type)
   end
-end
+end

data/lib/json_parser/version.rb

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

data/lib/json_parser/wrapper.rb

@@ -0,0 +1,30 @@
+class JsonParser::Wrapper
+  include OptionsParser
+  include TypeCast
+
+  delegate :clazz, :type, to: :options_object
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def wrap(value)
+    return value.map { |v| wrap v } if value.is_a?(Array)
+
+    value = cast(value) if has_type? && !value.nil?
+    return if value.nil?
+
+    value = clazz.new(value) if clazz
+    value
+  end
+
+  private
+
+  def has_type?
+    type.present? && type != :none
+  end
+
+  def cast(value)
+    send("to_#{type}", value)
+  end
+end

data/spec/lib/json_parser/crawler_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe JsonParser::Crawler do
+  let(:subject) do
+    described_class.new path, default_options.merge(options), &block
+  end
+  let(:block) { proc { |v| v } }
+  let(:path) { '' }
+  let(:default_options) { { case_type: :lower_camel} }
+  let(:options) { {} }
+  let(:json) { load_json_fixture_file('json_parser.json') }
+  let(:value) { subject.crawl(json) }
+
+  context 'when parsing with a path' do
+    let(:path) { %w(user name) }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['user']['name'])
+    end
+  end
+
+  context 'crawler finds a nil attribute' do
+    let(:path) { %w(car 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 empty' do
+    let(:json) { nil }
+    let(:path) { %w(car model) }
+
+    it 'returns nil' do
+      expect(value).to be_nil
+    end
+
+    it do
+      expect { value }.not_to raise_error
+    end
+  end
+
+  context 'with an snake case path' do
+    let(:path) { ['has_money'] }
+
+    it 'returns camel cased value' do
+      expect(value).to eq(json['hasMoney'])
+    end
+  end
+
+  context 'when dealing with json inside arrays' do
+    let(:path) { %w(animals race 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' do
+      context 'with compact option as false' do
+        let(:options) { { compact: false } }
+        before do
+          json["animals"].last['race'] = nil
+        end
+        let(:expected) do
+          ['European squid', 'Macaque monkey', nil]
+        end
+
+        it 'eliminate nil values' do
+          expect(value).to eq(expected)
+        end
+      end
+
+      context 'with compact option' do
+        let(:options) { { compact: true } }
+        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
+  end
+
+  context 'when using a snake case' do
+    let(:json) { { snake_cased: 'snake', snakeCased: 'Camel' }.stringify_keys }
+    let(:path) { [ 'snake_cased' ] }
+    let(:options) { { case_type: :snake } }
+
+    it 'fetches from snake cased fields' do
+      expect(value).to eq('snake')
+    end
+  end
+
+  context 'when using a upper camel case' do
+    let(:json) { { UpperCase: 'upper', upperCase: 'lower' }.stringify_keys }
+    let(:path) { [ 'upper_case' ] }
+    let(:options) { { case_type: :upper_camel } }
+
+    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(:path) { [ 'id' ] }
+
+    it 'fetches from symbol keys' do
+      expect(value).to eq(json[:id])
+    end
+
+    context 'crawler finds a nil attribute' do
+      let(:path) { %w(car 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(:path) { ['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/lib/json_parser/fetcher_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe JsonParser::Fetcher do
+  class JsonParser::Fetcher::Dummy
+  end
+
+  let(:subject) do
+    described_class.new json, path, instance, default_options.merge(options)
+  end
+  let(:path) { '' }
+  let(:default_options) { { case_type: :snake} }
+  let(:instance) { JsonParser::Fetcher::Dummy.new }
+  let(:json) { load_json_fixture_file('json_parser.json') }
+  let(:value) { subject.fetch }
+
+  context 'when fetching with no options' do
+    let(:options) { {} }
+    let(:path) { 'id' }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['id'])
+    end
+
+    context 'when calling the method twice' do
+      before do
+        subject.fetch
+      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
+        subject.fetch
+        json['id'] = 200
+      end
+
+      it 'retrieves the new value' do
+        expect(value).not_to eq(old_value)
+      end
+    end
+  end
+
+  describe 'flatten options' do
+    let(:json) { [[[1,2],[3,4]],[[5,6],[7,8]]] }
+
+    context 'when flatten option is true' do
+      let(:options) { { flatten: true } }
+
+      it 'returns the fetched value flattened' do
+        expect(subject.fetch).to eq((1..8).to_a)
+      end
+
+      context 'when value is not an array' do
+        let(:json) { 1 }
+
+        it 'returns the fetched value flattened' do
+          expect(subject.fetch).to eq(1)
+        end
+      end
+    end
+
+    context 'when flatten option is false' do
+      let(:options) { { flatten: false } }
+
+      it 'returns the fetched value non flattened' do
+        expect(subject.fetch).to eq(json)
+      end
+    end
+  end
+end

data/spec/lib/json_parser/wrapper_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe JsonParser::Wrapper do
+
+  class JsonParser::Wrapper::DummyWrapper
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  let(:options) { {} }
+  let(:subject) { described_class.new options }
+  let(:hash) { { a: 1 } }
+
+  describe '#wrap' do
+    let(:value) { hash }
+    let(:result) { subject.wrap(value) }
+
+    context 'with default options' do
+      it 'does not change the json value' do
+        expect(result).to eq(value)
+      end
+
+      context 'with an array as value' do
+        let(:value) { [hash] }
+
+        it 'does not change the array' do
+          expect(result).to eq(value)
+        end
+      end
+    end
+
+    context 'with clazz otpion' do
+      let(:options) { { clazz: OpenStruct } }
+
+      it 'creates new instance from given class' do
+        expect(result).to be_a(OpenStruct)
+        expect(result.a).to eq(hash[:a])
+      end
+
+      context 'with an array as value' do
+        let(:value) { [hash] }
+
+        it 'returns an array of objects of the given class' do
+          expect(result).to be_a(Array)
+          expect(result.first).to be_a(OpenStruct)
+        end
+      end
+    end
+
+    context 'with type otpion' do
+      let(:type) { :integer }
+      let(:value) { '1' }
+      let(:options) { { type: type } }
+      let(:cast) { result }
+
+      it_behaves_like 'casts basic types'
+
+      context 'when processing an array' do
+        let(:value) { [1.0] }
+        let(:cast) { result.first }
+
+        it_behaves_like 'casts basic types'
+
+        it do
+          expect(result).to be_a(Array)
+        end
+      end
+
+      context 'with nil value' do
+        let(:value) { nil }
+
+        it do
+          expect(result).to be_nil
+        end
+
+        context 'when passing clazz parameter' do
+          let(:options) { { type: type, clazz: JsonParser::Wrapper::DummyWrapper } }
+
+          it do
+            expect(result).to be_nil
+          end
+        end
+      end
+
+      context 'with blank value' do
+        let(:value) { '' }
+
+        it_behaves_like 'a result that is type cast', {
+          integer: NilClass,
+          float: NilClass,
+          string: String
+        }
+
+        context 'when passing clazz parameter' do
+          let(:options) { { type: type, clazz: JsonParser::Wrapper::DummyWrapper } }
+
+          it_behaves_like 'a result that is type cast', {
+            integer: NilClass,
+            float: NilClass,
+            string: JsonParser::Wrapper::DummyWrapper
+          }
+        end
+      end
+
+      context 'when passing clazz parameter' do
+        let(:value) { 1 }
+        let(:options) { { type: type, clazz: JsonParser::Wrapper::DummyWrapper } }
+        let(:cast) { result.value }
+
+        it_behaves_like 'casts basic types'
+
+        it 'wraps the result inside the given class' do
+          expect(result).to be_a(JsonParser::Wrapper::DummyWrapper)
+        end
+      end
+
+      context 'with none for type' do
+        let(:type) { :none }
+        let(:value) { 1.0 }
+
+        it 'does not cast the value' do
+          expect(result).to eq(value)
+        end
+      end
+    end
+  end
+end

data/spec/lib/json_parser_spec.rb

@@ -31,14 +31,11 @@ describe JsonParser do
 
     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)
@@ -62,27 +59,6 @@ describe JsonParser do
     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
@@ -93,31 +69,6 @@ describe JsonParser do
     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 }
 
@@ -139,14 +90,6 @@ describe JsonParser do
     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 }
 
@@ -211,34 +154,6 @@ describe JsonParser do
     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 }
 
@@ -247,71 +162,16 @@ describe JsonParser do
     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
+  context 'when casting the result' 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
+      json_parse :float_value, type: :float
     end
-  end
 
-  context 'when using key with false value' do
-    let(:attribute) { :has_money }
-    before do
-      json['hasMoney'] = false
-    end
+    let(:json) { { floatValue: '1' } }
+    let(:attribute) { :float_value }
 
-    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 }
+    it do
+      expect(value).to be_a(Float)
     end
   end
 end

data/spec/support/shared_examples/wrapper.rb

@@ -0,0 +1,19 @@
+shared_context 'a result that is type cast' do |types|
+  types.each do |type, clazz|
+    context "with #{type} type" do
+      let(:type) { type }
+
+      it do
+        expect(cast).to be_a(clazz)
+      end
+    end
+  end
+end
+
+shared_context 'casts basic types' do
+  it_behaves_like 'a result that is type cast', {
+    integer: Integer,
+    float: Float,
+    string: String
+  }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Bidu Dev's Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -102,6 +102,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -109,14 +110,23 @@ files:
 - README.md
 - Rakefile
 - json_parser.gemspec
+- lib/concerns/options_parser.rb
+- lib/concerns/type_cast.rb
 - lib/json_parser.rb
 - lib/json_parser/class_methods.rb
+- lib/json_parser/class_methods/builder.rb
+- lib/json_parser/crawler.rb
 - lib/json_parser/fetcher.rb
 - lib/json_parser/version.rb
+- lib/json_parser/wrapper.rb
 - spec/fixtures/json_parser.json
+- spec/lib/json_parser/crawler_spec.rb
+- spec/lib/json_parser/fetcher_spec.rb
+- spec/lib/json_parser/wrapper_spec.rb
 - spec/lib/json_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixture_helpers.rb
+- spec/support/shared_examples/wrapper.rb
 homepage: https://github.com/Bidu/json_parser
 licenses: []
 metadata: {}
@@ -136,12 +146,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Json Parser
 test_files:
 - spec/fixtures/json_parser.json
+- spec/lib/json_parser/crawler_spec.rb
+- spec/lib/json_parser/fetcher_spec.rb
+- spec/lib/json_parser/wrapper_spec.rb
 - spec/lib/json_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixture_helpers.rb
+- spec/support/shared_examples/wrapper.rb