darthjee-core_ext 1.7.3 → 1.7.4

data/spec/integration/yard/darthjee/core_ext/hash_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash do
+  describe 'yard' do
+    describe '#chain_fetch' do
+      subject(:hash) do
+        {
+          a: {
+            b: { c: 1, d: 2 }
+          }
+        }
+      end
+
+      context 'when requesting keys that exist' do
+        it 'returns the value found' do
+          expect(hash.chain_fetch(:a, :b, :c)).to eq(1)
+        end
+      end
+
+      context 'when key is not found' do
+        context 'when no block is given' do
+          it do
+            expect { hash.chain_fetch(:a, :c, :d) }.to raise_error(KeyError)
+          end
+        end
+
+        context 'when a block is given' do
+          it do
+            expect { hash.chain_fetch(:a, :c, :d) { 10 } }.not_to raise_error
+          end
+
+          it 'returns the result of the block' do
+            result = hash.chain_fetch(:a, :c, :d) { |*args| args }
+            expect(result).to eq([:c, [:d]])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/array_spec.rb

@@ -129,8 +129,8 @@ describe Array do
   end
 
   describe '#as_hash' do
-    let(:array) { [1, 2, 3] }
-    let(:keys) { %w[a b c] }
+    let(:array)    { [1, 2, 3] }
+    let(:keys)     { %w[a b c] }
     let(:expected) { { 'a' => 1, 'b' => 2, 'c' => 3 } }
 
     it 'creates a hash using the array as value and the argument as keys' do
@@ -171,11 +171,13 @@ describe Array do
 
     context 'when block returns nil' do
       let(:block) { proc {} }
+
       it { expect(value).to be_nil }
     end
 
     context 'when block returns false' do
       let(:block) { proc { false } }
+
       it { expect(value).to be_nil }
     end
 
@@ -184,14 +186,17 @@ describe Array do
 
       it { expect(value).to eq('1') }
 
-      context 'but not for the first value' do
-        let(:transformer) { double(:transformer) }
+      context 'when first value returns nothing' do
         let(:block) { proc { |v| transformer.transform(v) } }
 
-        before do
-          allow(transformer).to receive(:transform) do |v|
-            v.to_s if v > 1
+        let(:transformer) do
+          DummyTransformer.new do |value|
+            value.to_s if value > 1
           end
+        end
+
+        before do
+          allow(transformer).to receive(:transform).and_call_original
           value
         end
 
@@ -204,10 +209,10 @@ describe Array do
   end
 
   describe '#random' do
-    it_behaves_like 'a method that returns a random element', :random
-
     let(:array) { [8, 4, 2] }
 
+    it_behaves_like 'a method that returns a random element', :random
+
     it 'removes an the returned element' do
       expect do
         array.random
@@ -216,14 +221,14 @@ describe Array do
   end
 
   describe '#random!' do
-    it_behaves_like 'a method that returns a random element', :random!
-
     let(:array) { [8, 4, 2] }
 
+    it_behaves_like 'a method that returns a random element', :random!
+
     it 'removes an the returned element' do
       expect do
         array.random!
-      end.to change { array.size }.by(-1)
+      end.to change(array, :size).by(-1)
     end
   end
 
@@ -233,11 +238,13 @@ describe Array do
 
     context 'when block returns nil' do
       let(:block) { proc {} }
+
       it { expect(filtered).to be_empty }
     end
 
     context 'when block returns false' do
       let(:block) { proc { false } }
+
       it { expect(filtered).to be_empty }
     end
 
@@ -246,14 +253,17 @@ describe Array do
 
       it { expect(filtered).to eq(array.map(&:to_s)) }
 
-      context 'but not for the first value' do
-        let(:transformer) { double(:transformer) }
+      context 'when first value returns nothing' do
         let(:block) { proc { |v| transformer.transform(v) } }
 
-        before do
-          allow(transformer).to receive(:transform) do |v|
-            v.to_s if v[:value] > 1
+        let(:transformer) do
+          DummyTransformer.new do |value|
+            value.to_s if value[:value] > 1
           end
+        end
+
+        before do
+          allow(transformer).to receive(:transform).and_call_original
           filtered
         end
 

data/spec/lib/class_spec.rb

@@ -4,10 +4,24 @@ require 'spec_helper'
 
 describe Class do
   describe '.default_value' do
-    subject { DefaultValueModel.new }
+    subject(:model) { DefaultValueModel.new }
 
     it 'accepts default value' do
-      expect(subject.x).to eq(10)
+      expect(model.x).to eq(10)
+    end
+
+    context 'when changing the instance of default value' do
+      before do
+        model.array[1] = 30
+      end
+
+      it 'changes the value for the instance' do
+        expect(model.array).to eq([10, 30])
+      end
+
+      it 'changes the value for new instances' do
+        expect(model.class.new.array).to eq([10, 30])
+      end
     end
 
     it do
@@ -16,18 +30,105 @@ describe Class do
   end
 
   describe '.default_values' do
-    subject { DefaultValueModel.new }
+    subject(:model) { DefaultValueModel.new }
 
-    it 'accepts default values' do
-      expect(subject.y).to eq(20)
+    it 'accepts default values for first method' do
+      expect(model.y).to eq(20)
     end
 
-    it 'accepts default values' do
-      expect(subject.z).to eq(20)
+    it 'accepts default values for second method' do
+      expect(model.z).to eq(20)
     end
 
     it do
       expect(Object).not_to respond_to(:default_values)
     end
+
+    context 'when changing the instance of default value' do
+      before do
+        model.hash[:a] = 2
+      end
+
+      it 'changes the value for the instance' do
+        expect(model.hash).to eq(a: 2)
+      end
+
+      it 'changes the value for new instances' do
+        expect(model.class.new.hash).to eq(a: 2)
+      end
+
+      it 'changes the value for all methods' do
+        expect(model.json).to eq(a: 2)
+      end
+    end
+  end
+
+  describe '.default_reader' do
+    subject(:model) { DefaultReaderModel.new }
+
+    it 'returns the default value' do
+      expect(model.name).to eq('John')
+    end
+
+    context 'when the variable is set with a new value' do
+      before { model.name = 'Bob' }
+
+      it 'returns the new value' do
+        expect(model.name).to eq('Bob')
+      end
+    end
+
+    context 'when the variable is set to be false' do
+      before { model.name = false }
+
+      it do
+        expect(model.name).to be_falsey
+      end
+    end
+
+    context 'when the variable is set to be nil' do
+      before { model.name = nil }
+
+      it do
+        expect(model.name).to be_nil
+      end
+    end
+
+    context 'when changing the value of one instance' do
+      it 'does not change the value of other instances' do
+        expect { model.name = 'Bob' }
+          .not_to(change { model.class.new.name })
+      end
+    end
+
+    it do
+      expect(Object).not_to respond_to(:default_value)
+    end
+  end
+
+  describe '.default_readers' do
+    subject(:model) { DefaultReaderModel.new }
+
+    context 'when calling first method' do
+      it 'returns the default value' do
+        expect(model.cars).to eq(2)
+      end
+
+      context 'when the value is set with a new value' do
+        before { model.cars = 10 }
+
+        it 'returns the new value' do
+          expect(model.cars).to eq(10)
+        end
+
+        it 'does not affect second method' do
+          expect(model.houses).to eq(2)
+        end
+      end
+    end
+
+    it do
+      expect(Object).not_to respond_to(:default_readers)
+    end
   end
 end

data/spec/lib/darthjee/core_ext/hash/deep_hash_constructor_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::DeepHashConstructor do
-  let(:subject) { described_class.new('.') }
+  let(:subject)   { described_class.new('.') }
   let(:deep_hash) { subject.deep_hash(hash) }
 
   describe '.deep_hash' do

data/spec/lib/darthjee/core_ext/hash/key_changer_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::KeyChanger do
-  let(:subject) { described_class.new(hash) }
+  subject(:key_changer) { described_class.new(hash) }
 
   describe '#remap_keys!' do
     it_behaves_like 'a method that remaps the keys', :remap do
@@ -17,14 +17,14 @@ describe Darthjee::CoreExt::Hash::KeyChanger do
     let(:hash) { { keyUnderscore: 1 } }
 
     it 'underscore all the keys' do
-      expect(subject.underscore_keys).to eq(key_underscore: 1)
+      expect(key_changer.underscore_keys).to eq(key_underscore: 1)
     end
 
     context 'when hash is a many level hash' do
       let(:hash) { { keyUnderscore: { anotherKey: 1 } } }
 
       it 'underscore all the keys' do
-        result = subject.underscore_keys
+        result = key_changer.underscore_keys
         expect(result).to eq(key_underscore: { another_key: 1 })
       end
     end
@@ -34,14 +34,14 @@ describe Darthjee::CoreExt::Hash::KeyChanger do
 
       it 'underscore all the keys' do
         result = { key_underscore: [{ another_key: 1 }] }
-        expect(subject.underscore_keys).to eq(result)
+        expect(key_changer.underscore_keys).to eq(result)
       end
     end
 
-    context 'changes the hash' do
+    context 'when call changes the hash' do
       it 'underscore all the keys' do
         expect do
-          subject.underscore_keys
+          key_changer.underscore_keys
         end.to(change { hash })
       end
     end
@@ -51,7 +51,7 @@ describe Darthjee::CoreExt::Hash::KeyChanger do
         let(:hash) { { keyUnderscore: { anotherKey: 1 } } }
 
         it 'underscore all the keys' do
-          result = subject.underscore_keys(recursive: false)
+          result = key_changer.underscore_keys(recursive: false)
           expect(result).to eq(key_underscore: { anotherKey: 1 })
         end
       end
@@ -60,7 +60,7 @@ describe Darthjee::CoreExt::Hash::KeyChanger do
         let(:hash) { { keyUnderscore: [{ anotherKey: 1 }] } }
 
         it 'underscore all the keys' do
-          result = subject.underscore_keys(recursive: false)
+          result = key_changer.underscore_keys(recursive: false)
           expect(result).to eq(key_underscore: [{ anotherKey: 1 }])
         end
       end

data/spec/lib/darthjee/core_ext/hash/keys_sorter_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe Darthjee::CoreExt::Hash::KeysSorter do
   it_behaves_like 'a class with a keys sort method' do
     subject { described_class.new(hash, **options) }
+
     let(:result) { subject.sort }
   end
 end

data/spec/lib/darthjee/core_ext/hash/to_hash_mapper_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe Darthjee::CoreExt::Hash::ToHashMapper do
   it_behaves_like 'a hash with map_to_hash method' do
     subject { described_class.new(hash) }
+
     let(:mapped) { subject.map(&mapping_block) }
   end
 end

data/spec/lib/darthjee/core_ext/hash/value_changer_spec.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::ValueChanger do
+  subject(:changer) { described_class.new(options, &block) }
+
+  let(:block) { proc { |value| value.to_s.size } }
+
+  describe '#change' do
+    let(:options) { {} }
+
+    context 'when object is a Hash' do
+      let(:object) { { a: 22, b: 333 } }
+
+      it 'returns the hash with changed values' do
+        expect(changer.change(object)).to eq(a: 2, b: 3)
+      end
+    end
+
+    context 'when object is an array' do
+      let(:object) { [{ a: 22 }, { b: 333 }] }
+
+      it 'iterates over array' do
+        expect(changer.change(object)).to eq([{ a: 2 }, { b: 3 }])
+      end
+
+      it 'changes original array' do
+        expect { changer.change(object) }.to(change { object })
+      end
+
+      context 'when skiping recursion option' do
+        let(:options) { { recursive: false } }
+
+        it 'iterates over main array' do
+          expect(changer.change(object)).to eq([{ a: 2 }, { b: 3 }])
+        end
+      end
+
+      context 'when passing skip inner option as false' do
+        let(:options) { { skip_inner: false } }
+
+        it 'does not consider values as inner hashes' do
+          expect(changer.change(object)).to eq([{ a: 2 }, { b: 3 }])
+        end
+      end
+
+      context 'when passing skip inner false and skiping recursion option' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'does not consider values as inner hashes' do
+          expect(changer.change(object)).to eq([{ a: 2 }, { b: 3 }])
+        end
+      end
+    end
+
+    context 'when there is an inner hash' do
+      let(:object) { { a: { b: 333 } } }
+
+      it 'iterates over inner hash' do
+        expect(changer.change(object)).to eq(a: { b: 3 })
+      end
+
+      context 'when skiping recursion option' do
+        let(:options) { { recursive: false } }
+
+        it 'does not iterate over array' do
+          expect(changer.change(object)).to eq(a: { b: 333 })
+        end
+      end
+
+      context 'when passing skip inner option as false' do
+        let(:options) { { skip_inner: false } }
+
+        it 'apply change on inner hash' do
+          expect(changer.change(object)).to eq(a: 9)
+        end
+      end
+
+      context 'when passing skip inner false and skiping recursion option' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'applies the transformation before attempting recusrsive' do
+          expect(changer.change(object)).to eq(a: 9)
+        end
+      end
+    end
+
+    context 'when values are arrays' do
+      let(:object) { { a: [{ b: 333 }] } }
+
+      it 'iterates over array and inner hash' do
+        expect(changer.change(object)).to eq(a: [{ b: 3 }])
+      end
+
+      context 'when skiping recursion option' do
+        let(:options) { { recursive: false } }
+
+        it 'does not iterate over array' do
+          expect(changer.change(object)).to eq(a: [{ b: 333 }])
+        end
+      end
+
+      context 'when passing skip inner option as false' do
+        let(:options) { { skip_inner: false } }
+
+        it 'applies transformation over inner hash' do
+          expect(changer.change(object)).to eq(a: 11)
+        end
+      end
+
+      context 'when passing skip inner false and skiping recursion option' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'applies transformation before going recursive' do
+          expect(changer.change(object)).to eq(a: 11)
+        end
+      end
+    end
+
+    context 'when values are arrays within arrays' do
+      let(:object) { { a: [[100], [1000]] } }
+
+      it 'iterates over the inner arrays' do
+        expect(changer.change(object)).to eq(a: [[3], [4]])
+      end
+
+      context 'when skiping recursion option' do
+        let(:options) { { recursive: false } }
+
+        it 'does not iterate over array' do
+          expect(changer.change(object)).to eq(a: [[100], [1000]])
+        end
+      end
+
+      context 'when passing skip inner option as false' do
+        let(:options) { { skip_inner: false } }
+
+        it 'applies transformation over the whole array' do
+          expect(changer.change(object)).to eq(a: 15)
+        end
+      end
+
+      context 'when passing skip inner false and skiping recursion option' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'applies transformation before going recursive' do
+          expect(changer.change(object)).to eq(a: 15)
+        end
+      end
+    end
+
+    context 'when object is an array of arrays' do
+      let(:object) { [[{ a: 100 }], [{ b: { c: 1000 } }]] }
+
+      it 'iterates over the inner arrays' do
+        expect(changer.change(object)).to eq([[{ a: 3 }], [{ b: { c: 4 } }]])
+      end
+
+      context 'when skiping recursion option' do
+        let(:options) { { recursive: false } }
+
+        it 'stops recursive after the first hash' do
+          expected = [[{ a: 3 }], [{ b: { c: 1000 } }]]
+          expect(changer.change(object)).to eq(expected)
+        end
+      end
+
+      context 'when passing skip inner option as false' do
+        let(:options) { { skip_inner: false } }
+
+        it 'applies transformation on the first value of a hash' do
+          expect(changer.change(object)).to eq([[{ a: 3 }], [{ b: 10 }]])
+        end
+      end
+
+      context 'when passing skip inner false and skiping recursion option' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'applies transformation before going recursive' do
+          expect(changer.change(object)).to eq([[{ a: 3 }], [{ b: 10 }]])
+        end
+      end
+    end
+
+    context 'when transformation returns a hash and skip_inner is false' do
+      let(:object) { { a: [{ b: 333 }], c: { d: 10 }, e: [] } }
+      let(:options) { { skip_inner: false } }
+      let(:block) do
+        proc do |value|
+          value.is_a?(Array) ? { size: value.size } : value.to_s.size
+        end
+      end
+
+      it 'treat result of transformation as new hashes to be transformed' do
+        expected = { a: { size: 1 }, c: 8, e: { size: 1 } }
+        expect(changer.change(object)).to eq(expected)
+      end
+
+      context 'when skipping recursion' do
+        let(:options) { { skip_inner: false, recursive: false } }
+
+        it 'does not iterate over returned hash' do
+          expected = { a: { size: 1 }, c: 8, e: { size: 0 } }
+          expect(changer.change(object)).to eq(expected)
+        end
+      end
+    end
+
+    context 'when value is not an array but responds to #map' do
+      let(:array)  { [{ b: 22 }, { c: 333 }] }
+      let(:object) { { a: DummyIterator.new(array) } }
+
+      it 'iterates over array' do
+        expected = { a: [{ b: 2 }, { c: 3 }] }
+        expect(changer.change(object)).to eq(expected)
+      end
+
+      it 'does not change original array' do
+        expect { changer.change(object) }.not_to(change { array })
+      end
+    end
+
+    context 'when object is not an array but responds to #map' do
+      let(:array) { [{ b: 22 }, { c: 333 }] }
+      let(:object) { DummyIterator.new(array) }
+
+      it 'iterates over array' do
+        expected = [{ b: 2 }, { c: 3 }]
+        expect(changer.change(object)).to eq(expected)
+      end
+
+      it 'does not change original array' do
+        expect { changer.change(object) }.not_to(change { array })
+      end
+    end
+
+    context 'when object is not an array or hash' do
+      let(:object) { Object.new }
+
+      it 'returns object' do
+        expect(changer.change(object)).to eq(object)
+      end
+    end
+  end
+end