arstotzka 1.0.3 → 1.0.4

data/spec/integration/yard/arstotzka/wrapper_spec.rb

@@ -1,27 +1,43 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
+# frozen_string_literal: truie
 
 describe Arstotzka::Wrapper do
+  subject(:wrapper) { described_class.new(clazz: clazz, type: type) }
+
+  let(:type)  { nil }
+  let(:clazz) { nil }
+
   describe 'yard' do
     describe '#wrap' do
-      subject { described_class.new(clazz: clazz, type: type) }
-      let(:clazz) { nil }
-      let(:type) { nil }
-
-      context 'when definning clazz' do
+      context 'when clazz is defined' do
         let(:clazz) { Person }
+        let(:value) { 'john' }
+
+        it 'wraps value with the clazz' do
+          expect(wrapper.wrap(value)).to eq(Person.new(value))
+        end
+      end
+
+      context 'when type is defined' do
+        let(:type)  { :integer }
+        let(:value) { %w[10 20 30] }
 
-        it 'returns the valued wrapped in a class' do
-          expect(subject.wrap('John')).to eq(Person.new('John'))
+        it 'converts value to type' do
+          expect(wrapper.wrap(value)).to eq([10, 20, 30])
         end
       end
 
-      context 'when defing type' do
-        let(:type) { :integer }
+      context 'when type and class is defined' do
+        let(:type)    { :string }
+        let(:clazz)   { Request }
+        let(:value)   { { 'key' => 'value' } }
+        let(:request) { wrapper.wrap(value) }
+
+        it 'returns a wrapped object' do
+          expect(request).to be_a(Request)
+        end
 
-        it 'casts all values' do
-          expect(subject.wrap(%w[10 20 30])).to eq([10, 20, 30])
+        it 'casts before wrapping' do
+          expect(request.payload).to eq('{"key"=>"value"}')
         end
       end
     end

data/spec/integration/yard/arstotzka_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 
 describe Arstotzka do
-  describe :yard do
-    subject { Collector.new(hash) }
+  describe 'yard' do
+    subject(:collector) { Collector.new(hash) }
 
     let(:hash) { JSON.parse json }
     let(:json) do
@@ -65,37 +65,37 @@ describe Arstotzka do
 
     describe '#full_name' do
       it 'returns the full_name' do
-        expect(subject.full_name).to eq('Kelly Khan')
+        expect(collector.full_name).to eq('Kelly Khan')
       end
 
       it 'does not cache name' do
         expect do
           hash['person']['fullName'] = 'Robert'
-        end.to change(subject, :full_name).to('Robert')
+        end.to change(collector, :full_name).to('Robert')
       end
     end
 
     describe '#age' do
       it 'returns the age' do
-        expect(subject.age).to eq(32)
+        expect(collector.age).to eq(32)
       end
     end
 
     describe '#gender' do
       it 'returns person gender' do
-        expect(subject.gender).to eq(Collector::FEMALE)
+        expect(collector.gender).to eq(Collector::FEMALE)
       end
 
       it 'does caches gender' do
         expect do
           hash['person']['gender'] = 'man'
-        end.not_to change(subject, :gender)
+        end.not_to change(collector, :gender)
       end
     end
 
     describe '#car_names' do
       it 'returns the nick names of the cars' do
-        expect(subject.car_names).to eq(%w[Betty Roger Geronimo MissingName])
+        expect(collector.car_names).to eq(%w[Betty Roger Geronimo MissingName])
       end
     end
 
@@ -105,7 +105,7 @@ describe Arstotzka do
           Collector::Game.new(name: 'TheNextBigThing', played: 100.0),
           Collector::Game.new(name: 'Zelda', played: 90.0)
         ]
-        expect(subject.finished_games).to eq(expected)
+        expect(collector.finished_games).to eq(expected)
       end
     end
   end

data/spec/lib/arstotzka/builder_spec.rb

@@ -3,6 +3,10 @@
 require 'spec_helper'
 
 describe Arstotzka::Builder do
+  subject(:builder) do
+    described_class.new(attr_names, clazz, **full_options)
+  end
+
   let(:clazz) do
     Class.new.tap do |c|
       c.send(:attr_reader, :json)
@@ -20,19 +24,17 @@ describe Arstotzka::Builder do
   let(:instance)     { clazz.new(json) }
   let(:full_options) { described_class::DEFAULT_OPTIONS.merge(options) }
 
-  subject do
-    described_class.new(attr_names, clazz, **full_options)
-  end
-
   describe '#build' do
-    it 'adds the reader' do
-      expect do
-        subject.build
-      end.to add_method(attr_name).to(clazz)
+    context 'when it is called' do
+      it 'adds the reader' do
+        expect do
+          builder.build
+        end.to add_method(attr_name).to(clazz)
+      end
     end
 
-    context 'after building' do
-      before { subject.build }
+    context 'with being previously called' do
+      before { builder.build }
 
       context 'when building several attributes' do
         let(:attr_names) { %i[id name age] }
@@ -47,19 +49,19 @@ describe Arstotzka::Builder do
           expect(instance.name).to be_nil
         end
 
-        context 'when json has the property' do
+        context 'when json has the property as symbol key' do
           let(:json) { { name: name } }
 
           it 'fetches the value' do
             expect(instance.name).to eq(name)
           end
+        end
 
-          context 'but key is a string' do
-            let(:json) { { 'name' => name } }
+        context 'when json has the property as string key' do
+          let(:json) { { 'name' => name } }
 
-            it 'fetches the value' do
-              expect(instance.name).to eq(name)
-            end
+          it 'fetches the value' do
+            expect(instance.name).to eq(name)
           end
         end
       end

data/spec/lib/arstotzka/crawler_spec.rb

@@ -3,23 +3,25 @@
 require 'spec_helper'
 
 describe Arstotzka::Crawler do
-  subject do
+  subject(:crawler) do
     described_class.new default_options.merge(options), &block
   end
+
   let(:block) { proc { |v| v } }
   let(:path) { '' }
   let(:default_options) { { path: path, case_type: :lower_camel } }
   let(:options) { {} }
   let(:json_file) { 'arstotzka.json' }
   let(:json) { load_json_fixture_file(json_file) }
-  let(:value) { subject.value(json) }
+  let(:value) { crawler.value(json) }
 
   context 'when no block is given' do
-    let(:path) { %w[user name] }
-    subject do
+    subject(:crawler) do
       described_class.new default_options.merge(options)
     end
 
+    let(:path) { %w[user name] }
+
     it 'retrieves attribute from base json' do
       expect(value).to eq(json['user']['name'])
     end
@@ -33,7 +35,7 @@ describe Arstotzka::Crawler do
     end
 
     context 'when calling twice' do
-      before { subject.value(json) }
+      before { crawler.value(json) }
 
       it 'can still crawl' do
         expect(value).to eq(json['user']['name'])
@@ -41,7 +43,7 @@ describe Arstotzka::Crawler do
     end
   end
 
-  context 'crawler finds a nil attribute' do
+  context 'when crawler finds a nil attribute' do
     let(:path) { %w[car model] }
 
     it 'returns nil' do
@@ -78,6 +80,7 @@ describe Arstotzka::Crawler do
 
       context 'when setting compact' do
         let(:options) { { compact: true } }
+
         it 'returns the missing values as nil' do
           expect(value).to eq([[1000.0]])
         end
@@ -123,13 +126,15 @@ describe Arstotzka::Crawler do
     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
 
+        before do
+          json['animals'].last['race'] = nil
+        end
+
         it 'eliminate nil values' do
           expect(value).to eq(expected)
         end
@@ -137,13 +142,15 @@ describe Arstotzka::Crawler do
 
       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
 
+        before do
+          json['animals'].last['race'] = nil
+        end
+
         it 'eliminate nil values' do
           expect(value).to eq(expected)
         end
@@ -253,7 +260,7 @@ describe Arstotzka::Crawler do
       expect(value).to eq(json[:id])
     end
 
-    context 'crawler finds a nil attribute' do
+    context 'when crawler finds a nil attribute' do
       let(:path) { %w[car model] }
 
       it 'returns nil' do
@@ -268,6 +275,7 @@ describe Arstotzka::Crawler do
 
   context 'when using key with false value' do
     let(:path) { ['has_money'] }
+
     before do
       json['hasMoney'] = false
     end

data/spec/lib/arstotzka/fetcher_spec.rb

@@ -3,13 +3,14 @@
 require 'spec_helper'
 
 describe Arstotzka::Fetcher do
-  let(:subject) do
+  subject(:fetcher) do
     described_class.new json, instance, options.merge(path: path)
   end
+
   let(:path) { '' }
   let(:instance) { Arstotzka::Fetcher::Dummy.new }
   let(:json) { load_json_fixture_file('arstotzka.json') }
-  let(:value) { subject.fetch }
+  let(:value) { fetcher.fetch }
 
   context 'when fetching with no options' do
     let(:options) { {} }
@@ -21,7 +22,7 @@ describe Arstotzka::Fetcher do
 
     context 'when calling the method twice' do
       before do
-        subject.fetch
+        fetcher.fetch
       end
 
       it 'retrieves attribute from base json' do
@@ -31,8 +32,9 @@ describe Arstotzka::Fetcher do
 
     context 'when changing json value' do
       let!(:old_value) { json['id'] }
+
       before do
-        subject.fetch
+        fetcher.fetch
         json['id'] = 200
       end
 
@@ -49,14 +51,14 @@ describe Arstotzka::Fetcher do
       let(:options) { { flatten: true } }
 
       it 'returns the fetched value flattened' do
-        expect(subject.fetch).to eq((1..8).to_a)
+        expect(fetcher.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)
+          expect(fetcher.fetch).to eq(1)
         end
       end
     end
@@ -65,7 +67,7 @@ describe Arstotzka::Fetcher do
       let(:options) { { flatten: false } }
 
       it 'returns the fetched value non flattened' do
-        expect(subject.fetch).to eq(json)
+        expect(fetcher.fetch).to eq(json)
       end
     end
   end
@@ -76,7 +78,7 @@ describe Arstotzka::Fetcher do
     let(:options) { { after: :sum } }
 
     it 'applies after call ' do
-      expect(subject.fetch).to eq(325)
+      expect(fetcher.fetch).to eq(325)
     end
   end
 
@@ -88,11 +90,11 @@ describe Arstotzka::Fetcher do
     let(:wrapper) { Person }
 
     it 'wraps the result in an object' do
-      expect(subject.fetch).to be_a(wrapper)
+      expect(fetcher.fetch).to be_a(wrapper)
     end
 
     it 'sets the wrapper with the fetched value' do
-      expect(subject.fetch.name).to eq(name)
+      expect(fetcher.fetch.name).to eq(name)
     end
   end
 end

data/spec/lib/arstotzka/reader_spec.rb

@@ -4,26 +4,26 @@ require 'spec_helper'
 
 shared_examples 'reader fetchin value' do
   it do
-    expect { subject.read(json, index) }.not_to raise_error
+    expect { reader.read(json, index) }.not_to raise_error
   end
 
   it do
-    expect(subject.read(json, index)).not_to be_nil
+    expect(reader.read(json, index)).not_to be_nil
   end
 
   it 'returns the evaluated value' do
-    expect(subject.read(json, index)).to eq(expected)
+    expect(reader.read(json, index)).to eq(expected)
   end
 
-  context 'and the json has symbolized_keys' do
+  context 'when the json has symbolized_keys' do
     it 'returns the evaluated value' do
-      expect(subject.read(sym_json, index)).to eq(expected)
+      expect(reader.read(sym_json, index)).to eq(expected)
     end
   end
 end
 
 describe Arstotzka::Reader do
-  subject do
+  subject(:reader) do
     described_class.new(path: path, case_type: case_type)
   end
 
@@ -45,14 +45,14 @@ describe Arstotzka::Reader do
         let(:json) { full_json['user'] }
         let(:index) { 1 }
 
-        context 'to snake_case' do
+        context 'with snake_case type' do
           let(:path) { %w[user FullName] }
           let(:expected) { json['full_name'] }
 
           it_behaves_like 'reader fetchin value'
         end
 
-        context 'to upper_camel' do
+        context 'with upper_camel type' do
           let(:case_type) { :upper_camel }
           let(:path) { %w[user login_name] }
           let(:expected) { json['LoginName'] }
@@ -60,7 +60,7 @@ describe Arstotzka::Reader do
           it_behaves_like 'reader fetchin value'
         end
 
-        context 'to lower_camel' do
+        context 'with lower_camel type' do
           let(:case_type) { :lower_camel }
           let(:path) { %w[user birth_date] }
           let(:expected) { json['birthDate'] }
@@ -75,12 +75,12 @@ describe Arstotzka::Reader do
         let(:path) { %w[user password_reminder] }
 
         it do
-          expect(subject.read(json, index)).to be_nil
+          expect(reader.read(json, index)).to be_nil
         end
 
-        context 'but keys are symbol' do
+        context 'when keys are symbol' do
           it do
-            expect(subject.read(sym_json, index)).to be_nil
+            expect(reader.read(sym_json, index)).to be_nil
           end
         end
       end
@@ -90,7 +90,7 @@ describe Arstotzka::Reader do
         let(:json) { { key: 'symbol', 'key' => 'string' } }
 
         it 'fetches the string key first' do
-          expect(subject.read(json, index)).to eq('string')
+          expect(reader.read(json, index)).to eq('string')
         end
       end
     end
@@ -100,7 +100,7 @@ describe Arstotzka::Reader do
 
       it do
         expect do
-          subject.read(json, index)
+          reader.read(json, index)
         end.to raise_error(Arstotzka::Exception::KeyNotFound)
       end
     end
@@ -110,13 +110,13 @@ describe Arstotzka::Reader do
     context 'when index is within path' do
       let(:index) { 1 }
 
-      it { expect(subject.ended?(index)).to be_falsey }
+      it { expect(reader).not_to be_ended(index) }
     end
 
     context 'when index is outside path' do
       let(:index) { 2 }
 
-      it { expect(subject.ended?(index)).to be_truthy }
+      it { expect(reader).to be_ended(index) }
     end
   end
 end

data/spec/lib/arstotzka/wrapper_spec.rb

@@ -30,15 +30,21 @@ describe Arstotzka::Wrapper do
 
       it 'creates new instance from given class' do
         expect(result).to be_a(OpenStruct)
+      end
+
+      it 'uses the given value on object initialization' do
         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
+        it 'returns an array' do
           expect(result).to be_a(Array)
-          expect(result.first).to be_a(OpenStruct)
+        end
+
+        it 'returns an array of objects of the given class' do
+          expect(result).to all(be_a(OpenStruct))
         end
       end
     end

data/spec/lib/arstotzka_spec.rb

@@ -35,6 +35,7 @@ describe Arstotzka do
   context 'when caching the value' do
     let(:attribute) { :age }
     let!(:old_value) { json['age'] }
+
     before do
       dummy.age
       json['age'] = old_value + 100
@@ -52,36 +53,38 @@ describe Arstotzka do
       expect(value).to be_a(House)
     end
 
-    it 'creates the object with the given json' do
+    it 'creates the object with a method that is instantiated using the hash' 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
+      it 'returns an array' do
         expect(value).to be_a(Array)
-        value.each do |object|
-          expect(object).to be_a(Game)
-        end
+      end
+
+      it 'returns an array of json wrapped' do
+        expect(value).to all(be_a(Game))
       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
+        it 'returns an array' 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(Game)
-            end
-          end
+        end
+
+        it 'returns an array of arrays' do
+          expect(value).to all(be_a(Array))
+        end
+
+        it 'wraps each end element' do
+          expect(value).to all(all(be_a(Game)))
         end
       end
     end
@@ -90,22 +93,19 @@ describe Arstotzka do
   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(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
+
+    it 'caches the resulting object' do
+      expect do
+        json['oldHouse'] = {}
+      end.not_to(change { dummy.old_house.age })
     end
   end
 

data/spec/support/models/car.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Car
+  attr_reader :model, :maker
+
+  def initialize(model:, maker:)
+    @model = model
+    @maker = maker
+  end
+end

data/spec/support/models/car_collector.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arstotzka
+  module TypeCast
+    def to_car(hash)
+      Car.new(hash.symbolize_keys)
+    end
+  end
+end
+
+class CarCollector
+  include Arstotzka
+
+  attr_reader :json
+
+  expose :cars, full_path: 'cars.unit', type: :car
+  def initialize(hash)
+    @json = hash
+  end
+end

data/spec/support/models/request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Request
+  attr_reader :payload
+
+  def initialize(payload)
+    @payload = payload
+  end
+end

data/spec/support/models/type_caster.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class TypeCaster
+  include Arstotzka
+
+  expose :age,     type: :integer, json: :@hash
+  expose :payload, type: :string, json: :@hash
+  expose :price,   type: :float, json: :@hash
+
+  def initialize(hash)
+    @hash = hash
+  end
+end

data/spec/support/shared_examples/wrapper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-shared_context 'a result that is type cast' do |types|
+shared_examples 'a result that is type cast' do |types|
   types.each do |type, clazz|
     context "with #{type} type" do
       let(:type) { type }
@@ -12,7 +12,7 @@ shared_context 'a result that is type cast' do |types|
   end
 end
 
-shared_context 'casts basic types' do
+shared_examples 'casts basic types' do
   it_behaves_like 'a result that is type cast',
                   integer: Integer,
                   float: Float,