arstotzka 1.0.1 → 1.0.2

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::ClassMethods do
+  describe 'yard' do
+    let!(:instance) { klass.new(hash) }
+    let(:klass) do
+      Class.new(MyModel) do
+        include Arstotzka
+        expose :first_name, full_path: 'name.first'
+        expose :age, 'cars', type: :integer
+      end
+    end
+    let(:hash) do
+      {
+        'name' => { first: 'John', last: 'Williams' },
+        :age => '20',
+        'cars' => 2.0
+      }
+    end
+
+    describe '#first_name' do
+      it 'crawls into the hash to find the value of the first name' do
+        expect(instance.first_name).to eq('John')
+      end
+    end
+
+    describe '#age' do
+      it 'crawls into the hash to find the value of the age' do
+        expect(instance.age).to eq(20)
+      end
+
+      it do
+        expect(instance.age).to be_a(Integer)
+      end
+    end
+
+    describe '#cars' do
+      it 'crawls into the hash to find the value of the age' do
+        expect(instance.cars).to eq(2)
+      end
+
+      it do
+        expect(instance.cars).to be_a(Integer)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Crawler do
+  describe 'yard' do
+    subject do
+      described_class.new(path: path, **options)
+    end
+
+    let(:options) { {} }
+    let(:path)    { %w[person information first_name] }
+    let(:hash) do
+      {
+        person: {
+          'information' => {
+            'firstName' => 'John'
+          }
+        }
+      }
+    end
+
+    it 'crawls to find the value' do
+      expect(subject.value(hash)).to eq('John')
+    end
+
+    describe '#value' do
+      context 'when hash contains the path' do
+        it 'crawls to find the value' do
+          expect(subject.value(hash)).to eq('John')
+        end
+      end
+
+      context 'when we have an array of arrays' do
+        let(:path)    { %w[companies games hero_name] }
+        let(:options) { { compact: true, case_type: :snake } }
+        let(:hash) do
+          {
+            'companies' => [{
+              name: 'Lucas Pope',
+              games: [{
+                'name' => 'papers, please'
+              }, {
+                'name' => 'TheNextBigThing',
+                hero_name: 'Rakhar'
+              }]
+            }, {
+              name: 'Old Company'
+            }]
+          }
+        end
+
+        it 'crawls to find the value' do
+          expect(subject.value(hash)).to eq([['Rakhar']])
+        end
+
+        context 'and we set a default value' do
+          let(:options) { { compact: true, case_type: :snake, default: 'NO HERO' } }
+
+          it 'return default value for missed keys' do
+            expect(subject.value(hash)).to eq([['NO HERO', 'Rakhar'], 'NO HERO'])
+          end
+        end
+
+        context 'and we give a block' do
+          subject do
+            described_class.new(path: path, **options) { |value| value&.to_sym }
+          end
+
+          it 'returns the post processed values' do
+            expect(subject.value(hash)).to eq([[:Rakhar]])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Fetcher do
+  describe 'yard' do
+    describe '#fetch' do
+      subject { described_class.new(hash, instance, path: path, **options) }
+
+      let(:instance) { Account.new }
+      let(:path) { 'transactions' }
+      let(:options) do
+        {
+          clazz: Transaction,
+          after: :filter_income
+        }
+      end
+      let(:hash) do
+        {
+          transactions: [
+            { value: 1000.53, type: 'income' },
+            { value: 324.56,  type: 'outcome' },
+            { value: 50.23,   type: 'income' },
+            { value: 150.00,  type: 'outcome' },
+            { value: 10.23,   type: 'outcome' },
+            { value: 100.12,  type: 'outcome' },
+            { value: 101.00,  type: 'outcome' }
+          ]
+        }
+      end
+
+      describe 'incoming transactions' do
+        it 'returns only the income payments' do
+          expect(subject.fetch.count).to eq(2)
+        end
+
+        it 'returns Transactions' do
+          expect(subject.fetch.map(&:class).uniq).to eq([Transaction])
+        end
+
+        it 'returns results wrapped in Transactions' do
+          expected = [
+            Transaction.new(value: 1000.53, type: 'income'),
+            Transaction.new(value: 50.23, type: 'income')
+          ]
+          expect(subject.fetch).to eq(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Reader do
+  describe 'yard' do
+    subject { described_class.new(path: path, case_type: case_type) }
+
+    let(:path) { %w[person full_name] }
+    let(:case_type) { :snake }
+
+    describe '#read' do
+      let(:hash) do
+        {
+          full_name: 'John',
+          'Age' => 23,
+          'carCollection' => [
+            { maker: 'Ford', 'model' => 'Model A' },
+            { maker: 'BMW', 'model' => 'Jetta' }
+          ]
+        }
+      end
+
+      context 'when using snake_case' do
+        it 'fetches the value using snake case key' do
+          expect(subject.read(hash, 1)).to eq('John')
+        end
+
+        context 'when key is missing' do
+          let(:path) { %w[person car_collection model] }
+
+          it do
+            expect do
+              subject.read(hash, 1)
+            end.to raise_error(Arstotzka::Exception::KeyNotFound)
+          end
+        end
+      end
+
+      context 'when using lowerCamel' do
+        let(:case_type) { :lower_camel }
+        let(:path) { %w[person car_collection model] }
+
+        it 'fetches the value using lower camel case key' do
+          expected = [
+            { maker: 'Ford', 'model' => 'Model A' },
+            { maker: 'BMW', 'model' => 'Jetta' }
+          ]
+          expect(subject.read(hash, 1)).to eq(expected)
+        end
+      end
+
+      context 'when using UpperCamel' do
+        let(:case_type) { :upper_camel }
+        let(:path) { %w[person age] }
+
+        it 'fetches the value using uper camel case key' do
+          expect(subject.read(hash, 1)).to eq(23)
+        end
+      end
+    end
+
+    describe '#ended?' do
+      context 'when the fetches have not ended' do
+        it do
+          expect(subject.ended?(1)).to be_falsey
+        end
+      end
+
+      context 'when the fetches have ended' do
+        it do
+          expect(subject.ended?(2)).to be_truthy
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Wrapper do
+  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
+        let(:clazz) { Person }
+
+        it 'returns the valued wrapped in a class' do
+          expect(subject.wrap('John')).to eq(Person.new('John'))
+        end
+      end
+
+      context 'when defing type' do
+        let(:type) { :integer }
+
+        it 'casts all values' do
+          expect(subject.wrap(%w[10 20 30])).to eq([10, 20, 30])
+        end
+      end
+    end
+  end
+end

data/spec/lib/arstotzka/builder_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Arstotzka::Builder do
   let(:clazz) do
     Class.new.tap do |c|
       c.send(:attr_reader, :json)
-      c.send(:define_method, :initialize) do |json={}|
+      c.send(:define_method, :initialize) do |json = {}|
         @json = json
       end
     end
@@ -13,7 +15,7 @@ describe Arstotzka::Builder do
   let(:options) { {} }
   let(:name) { 'Robert' }
   let(:attr_name) { :name }
-  let(:attr_names) { [ attr_name ] }
+  let(:attr_names) { [attr_name] }
   let(:json) { {} }
   let(:instance) { clazz.new(json) }
 
@@ -25,14 +27,14 @@ describe Arstotzka::Builder do
     it 'adds the reader' do
       expect do
         subject.build
-      end.to change { clazz.new.respond_to?(attr_name) }
+      end.to add_method(attr_name).to(clazz)
     end
 
     context 'after building' do
       before { subject.build }
 
       context 'when building several attributes' do
-        let(:attr_names) { [ :id, :name, :age ] }
+        let(:attr_names) { %i[id name age] }
 
         it 'adds all the readers' do
           attr_names.each do |attr|

data/spec/lib/arstotzka/crawler_spec.rb

@@ -1,19 +1,32 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Arstotzka::Crawler do
-  let(:subject) do
+  subject 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(: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) }
 
+  context 'when no block is given' do
+    let(:path) { %w[user name] }
+    subject do
+      described_class.new default_options.merge(options)
+    end
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['user']['name'])
+    end
+  end
+
   context 'when parsing with a path' do
-    let(:path) { %w(user name) }
+    let(:path) { %w[user name] }
 
     it 'retrieves attribute from base json' do
       expect(value).to eq(json['user']['name'])
@@ -29,7 +42,7 @@ describe Arstotzka::Crawler do
   end
 
   context 'crawler finds a nil attribute' do
-    let(:path) { %w(car model) }
+    let(:path) { %w[car model] }
 
     it 'returns nil' do
       expect(value).to be_nil
@@ -42,7 +55,7 @@ describe Arstotzka::Crawler do
 
   context 'when there is an array of arrays' do
     let(:json_file) { 'accounts.json' }
-    let(:path) { %w(banks accounts balance) }
+    let(:path) { %w[banks accounts balance] }
 
     it 'returns the values as array of arrays' do
       expect(value).to eq([[1000.0, 1500.0], [50.0, -500.0]])
@@ -74,7 +87,7 @@ describe Arstotzka::Crawler do
 
   context 'when json is empty' do
     let(:json) { nil }
-    let(:path) { %w(car model) }
+    let(:path) { %w[car model] }
 
     it 'returns nil' do
       expect(value).to be_nil
@@ -94,7 +107,7 @@ describe Arstotzka::Crawler do
   end
 
   context 'when dealing with json inside arrays' do
-    let(:path) { %w(animals race species name)}
+    let(:path) { %w[animals race species name] }
     let(:expected) do
       ['European squid', 'Macaque monkey', 'Mexican redknee tarantula']
     end
@@ -111,7 +124,7 @@ describe Arstotzka::Crawler do
       context 'with compact option as false' do
         let(:options) { { compact: false } }
         before do
-          json["animals"].last['race'] = nil
+          json['animals'].last['race'] = nil
         end
         let(:expected) do
           ['European squid', 'Macaque monkey', nil]
@@ -125,7 +138,7 @@ describe Arstotzka::Crawler do
       context 'with compact option' do
         let(:options) { { compact: true } }
         before do
-          json["animals"].last['race'] = nil
+          json['animals'].last['race'] = nil
         end
         let(:expected) do
           ['European squid', 'Macaque monkey']
@@ -141,7 +154,7 @@ describe Arstotzka::Crawler do
   context 'with default option' do
     let(:default_value) { 'NotFound' }
     let(:options) { { default: default_value } }
-    let(:path) { %w(projects name) }
+    let(:path) { %w[projects name] }
 
     context 'when there is a key missing' do
       it 'returns the default value' do
@@ -163,7 +176,7 @@ describe Arstotzka::Crawler do
 
     context 'when the key is not missing but the value is nil' do
       let(:json_file) { 'person.json' }
-      let(:path) { %w(user name) }
+      let(:path) { %w[user name] }
 
       it { expect(value).to be_nil }
 
@@ -182,7 +195,7 @@ describe Arstotzka::Crawler do
 
     context 'when the key last key is missing but the value is nil' do
       let(:json_file) { 'person.json' }
-      let(:path) { %w(user nick_name) }
+      let(:path) { %w[user nick_name] }
 
       it 'returns the default value' do
         expect(value).to eq(default_value)
@@ -203,7 +216,7 @@ describe Arstotzka::Crawler do
 
     context 'when the node is missing but default has the same node' do
       let(:default_value) { { node: { value: 1 } } }
-      let(:path) { %w(node node node) }
+      let(:path) { %w[node node node] }
       let(:json) { {} }
 
       it 'does not crawl through default value' do
@@ -214,7 +227,7 @@ describe Arstotzka::Crawler do
 
   context 'when using a snake case' do
     let(:json) { { snake_cased: 'snake', snakeCased: 'Camel' }.stringify_keys }
-    let(:path) { [ 'snake_cased' ] }
+    let(:path) { ['snake_cased'] }
     let(:options) { { case_type: :snake } }
 
     it 'fetches from snake cased fields' do
@@ -224,7 +237,7 @@ describe Arstotzka::Crawler do
 
   context 'when using a upper camel case' do
     let(:json) { { UpperCase: 'upper', upperCase: 'lower' }.stringify_keys }
-    let(:path) { [ 'upper_case' ] }
+    let(:path) { ['upper_case'] }
     let(:options) { { case_type: :upper_camel } }
 
     it 'fetches from upper camel cased fields' do
@@ -234,14 +247,14 @@ describe Arstotzka::Crawler do
 
   context 'when using a symbol keys' do
     let(:json) { load_json_fixture_file('arstotzka.json').symbolize_keys }
-    let(:path) { [ 'id' ] }
+    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) }
+      let(:path) { %w[car model] }
 
       it 'returns nil' do
         expect(value).to be_nil