darthjee-core_ext 1.7.3 → 1.7.4

data/lib/darthjee/core_ext/version.rb

@@ -2,6 +2,6 @@
 
 module Darthjee
   module CoreExt
-    VERSION = '1.7.3'
+    VERSION = '1.7.4'
   end
 end

data/spec/integration/yard/{array → darthjee/core_ext/array}/hash_builder_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Darthjee::CoreExt::Array::HashBuilder do
   describe 'yard' do
     describe '#build' do
-      subject { described_class.new(values, keys) }
+      subject(:builder) { described_class.new(values, keys) }
 
       let(:values) { [10, 20, 30] }
       let(:keys)   { %i[a b c] }
 
       it 'builds a hash pairing the keys and values' do
-        expect(subject.build).to eq(
+        expect(builder.build).to eq(
           a: 10, b: 20, c: 30
         )
       end
@@ -22,7 +22,7 @@ describe Darthjee::CoreExt::Array::HashBuilder do
         let(:keys)   { hash.keys }
 
         it 'rebuilds the original hash' do
-          expect(subject.build).to eq(hash)
+          expect(builder.build).to eq(hash)
         end
       end
     end

data/spec/integration/yard/darthjee/core_ext/class/default_value_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe Class do
+  describe 'yard' do
+    subject(:instance) { klass.new }
+
+    describe '#default_value' do
+      let(:klass) do
+        Class.new do
+          default_value :name, 'John'
+        end
+      end
+
+      context 'when calling method' do
+        it 'returns the same value always' do
+          expect(instance.name).to eq('John')
+        end
+
+        it 'returns the same instance accros instances of the class' do
+          expect(instance.name).not_to be_equal('John')
+          expect(instance.name).to be_equal(klass.new.name)
+        end
+      end
+    end
+
+    describe '#default_values' do
+      let(:klass) do
+        Class.new do
+          default_values :name, :nick_name, 'John'
+        end
+      end
+
+      context 'when calling method' do
+        it 'returns the same value always for first method' do
+          expect(instance.name).to eq('John')
+        end
+
+        it 'returns the same value always for second method' do
+          expect(instance.nick_name).to eq('John')
+        end
+
+        it 'returns the same instance accros instances of the class' do
+          expect(instance.name).not_to be_equal('John')
+          expect(instance.name).to be_equal(klass.new.name)
+        end
+
+        it 'returns the same instance for all methods' do
+          expect(instance.nick_name).not_to be_equal('John')
+          expect(instance.name).to be_equal(instance.nick_name)
+        end
+      end
+    end
+
+    describe '#default_reader' do
+      let(:klass) do
+        Class.new do
+          attr_writer :name
+          default_reader :name, 'John Doe'
+        end
+      end
+
+      context 'when calling method' do
+        it 'returns the default value' do
+          expect(instance.name).to eq('John Doe')
+        end
+
+        context 'when setting the variable' do
+          before { instance.name = 'Joe' }
+
+          it 'returns the new value' do
+            expect(instance.name).to eq('Joe')
+          end
+        end
+
+        context 'when setting the variable to be nil' do
+          before { instance.name = nil }
+
+          it 'returns nil' do
+            expect(instance.name).to be_nil
+          end
+        end
+
+        context 'when setting a variable in one instance' do
+          before { klass.new.name = 'Bob' }
+
+          it 'does not change the value in the other' do
+            expect(instance.name).to eq('John Doe')
+          end
+        end
+      end
+    end
+
+    describe '.default_readers' do
+      let(:klass) do
+        Class.new do
+          attr_writer :cars, :houses
+          default_readers :cars, :houses, 'none'
+        end
+      end
+
+      context 'when calling first method' do
+        it 'returns the default value' do
+          expect(instance.cars).to eq('none')
+        end
+
+        context 'when setting the variable' do
+          before { instance.cars = ['volvo'] }
+
+          it 'returns the new value' do
+            expect(instance.cars).to eq(['volvo'])
+          end
+
+          it 'does not change the value of the second method' do
+            expect(instance.houses).to eq('none')
+          end
+        end
+
+        context 'when setting the variable to be nil' do
+          before { instance.cars = nil }
+
+          it 'returns nil' do
+            expect(instance.cars).to be_nil
+          end
+        end
+
+        context 'when setting a variable in one instance' do
+          before { klass.new.cars = ['volvo'] }
+
+          it 'does not change the value in the other' do
+            expect(instance.cars).to eq('none')
+          end
+        end
+
+        it 'returns the same instance for all methods' do
+          expect(instance.cars).not_to be_equal('none')
+          expect(instance.cars).to be_equal(instance.houses)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/{date → darthjee/core_ext/date}/days_between_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Date do
   describe 'yard' do
     describe '#days_between' do
-      subject { Date.new(2018, 11, 21) }
+      subject(:date) { described_class.new(2018, 11, 21) }
 
       context 'when checking against another date' do
-        let(:other_date) { Date.new(2019, 11, 21) }
+        let(:other_date) { described_class.new(2019, 11, 21) }
 
         it 'returns the days between' do
-          expect(subject.days_between(other_date)).to eq(365)
+          expect(date.days_between(other_date)).to eq(365)
         end
       end
 
       context 'when cheking agains a 4 years apart date' do
-        let(:other_date) { Date.new(2014, 11, 21) }
+        let(:other_date) { described_class.new(2014, 11, 21) }
 
         it 'returns the days between' do
-          expect(subject.days_between(other_date)).to eq(1461)
+          expect(date.days_between(other_date)).to eq(1461)
         end
       end
 
@@ -27,7 +27,7 @@ describe Date do
         let(:time) { Time.new(2017, 11, 21, 12, 0, 0) }
 
         it 'ignores the hours' do
-          expect(subject.days_between(time)).to eq(365)
+          expect(date.days_between(time)).to eq(365)
         end
       end
     end

data/spec/integration/yard/darthjee/core_ext/hash/cameliazable_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::Cameliazable do
+  describe 'camlize_keys' do
+    subject(:hash) do
+      { first_key: 1, 'second_key' => 2 }
+    end
+
+    context 'when no option is given' do
+      it 'camelize all keys' do
+        result = hash.camelize_keys
+        expect(result).to eq(FirstKey: 1, 'SecondKey' => 2)
+      end
+    end
+
+    context 'when passing uppercase_first_letter option' do
+      it 'camelize all keys' do
+        result = hash.camelize_keys(uppercase_first_letter: false)
+        expect(result).to eq(firstKey: 1, 'secondKey' => 2)
+      end
+    end
+  end
+
+  describe '#lower_camelize_keys' do
+    subject(:hash) do
+      { first_key: 1, 'second_key' => 2 }
+    end
+
+    it 'camelize all keys' do
+      result = hash.lower_camelize_keys
+      expect(result).to eq(firstKey: 1, 'secondKey' => 2)
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/hash/chain_fetcher_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::ChainFetcher do
+  let(:hash) do
+    {
+      a: {
+        b: { c: 1, d: 2 }
+      }
+    }
+  end
+
+  context 'when not giving a block' do
+    subject(:fetcher) do
+      described_class.new(hash, *keys)
+    end
+
+    context 'when keys are found' do
+      let(:keys) { %i[a b c] }
+
+      it 'returns the value found' do
+        expect(fetcher.fetch).to eq(1)
+      end
+    end
+
+    context 'when key is not found' do
+      let(:keys) { %i[a c d] }
+
+      it do
+        expect { fetcher.fetch }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  context 'when giving a block' do
+    subject(:fetcher) do
+      described_class.new(hash, *keys) { |*args| args }
+    end
+
+    context 'when keys are not found' do
+      let(:keys) { %i[a c d] }
+
+      it do
+        expect { fetcher.fetch }.not_to raise_error
+      end
+
+      it 'returns the result of the block' do
+        expect(fetcher.fetch).to eq([:c, [:d]])
+      end
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/hash/key_changeable_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::KeyChangeable do
+  describe '#remap_keys' do
+    subject(:hash) { { a: 1, b: 2 } }
+
+    it 'remaps the keys' do
+      expect(hash.remap_keys(a: :b, b: :c)).to eq(b: 1, c: 2)
+    end
+  end
+
+  describe '#change_keys' do
+    subject(:hash) { { '1' => 1, '2' => { '3' => 2 } } }
+
+    context 'when not passing options' do
+      let(:result) do
+        hash.change_keys do |k|
+          (k.to_i + 1).to_s.to_sym
+        end
+      end
+
+      it 'uses the block to change the keys' do
+        expect(result).to eq('2': 1, '3': { '4': 2 })
+      end
+    end
+
+    context 'when passing recursive option' do
+      let(:result) do
+        hash.change_keys(recursive: false) do |k|
+          (k.to_i + 1).to_s.to_sym
+        end
+      end
+
+      it 'uses the block to change the keys' do
+        expect(result).to eq('2': 1, '3': { '3' => 2 })
+      end
+    end
+  end
+
+  describe '#chain_change_keys' do
+    subject(:hash) { { first: 1, second: 2 } }
+
+    it 'uses the block to change the keys' do
+      result = hash.chain_change_keys(:to_s, :size, :to_s, :to_sym)
+      expect(result).to eq('5': 1, '6': 2)
+    end
+  end
+end

data/spec/integration/yard/{hash → darthjee/core_ext/hash}/transformable_spec.rb

@@ -6,6 +6,7 @@ describe Hash do
   describe 'yard' do
     describe '#exclusive_merge' do
       subject(:hash) { { a: 1, b: 2, c: 3 } }
+
       let(:other)    { { b: 4, 'c' => 5, e: 6 } }
 
       it 'merges only the existing keys' do
@@ -21,6 +22,7 @@ describe Hash do
 
     describe '#exclusive_merge' do
       subject(:hash) { { a: 1, b: 2, c: 3 } }
+
       let(:other)    { { b: 4, 'c' => 5, e: 6 } }
 
       it 'merges only the existing keys' do
@@ -38,11 +40,13 @@ describe Hash do
   describe '#map_to_hash' do
     subject(:hash) { { a: 'word', b: 'bigword', c: 'c' } }
 
-    it 'remaps the values keeping the original keys' do
-      new_hash = hash.map_to_hash do |key, value|
+    let(:new_hash) do
+      hash.map_to_hash do |key, value|
         "#{key}->#{value.size}"
       end
+    end
 
+    it 'remaps the values keeping the original keys' do
       expect(new_hash).to eq(
         a: 'a->4',
         b: 'b->7',
@@ -60,7 +64,7 @@ describe Hash do
 
     context 'when squashing the result of a deep hash' do
       let(:person_data) { { 'person.name' => 'John', 'person.age' => 23 } }
-      let(:person) { person_data.to_deep_hash }
+      let(:person)      { person_data.to_deep_hash }
 
       it 'is the reverse operation' do
         expect(person.squash).to eq(person_data)

data/spec/integration/yard/darthjee/core_ext/hash/value_changer_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::ValueChanger do
+  describe 'yard' do
+    subject(:changer) { described_class.new(options, &block) }
+
+    describe '#initialize' do
+      let(:options) { { recursive: false, skip_inner: false } }
+      let(:block)   { proc(&:class) }
+      let(:hash)    { { a: 1, b: { c: 2 }, d: [{ e: 1 }] } }
+
+      it 'initialize options' do
+        expect(changer.change(hash)).to eq(
+          a: Integer, b: Hash, d: Array
+        )
+      end
+    end
+
+    describe '#change' do
+      let(:options) { {} }
+      let(:block) { proc { |value| value.to_s.size } }
+
+      context 'when object is a Hash' do
+        let(:hash) { { a: 15, b: { c: 2 }, d: [{ e: 100 }] } }
+
+        it 'transforms values' do
+          expect(changer.change(hash)).to eq(
+            a: 2, b: { c: 1 }, d: [{ e: 3 }]
+          )
+        end
+
+        context 'when not skipping inner' do
+          let(:options) { { skip_inner: false } }
+
+          it 'transforms values' do
+            expect(changer.change(hash)).to eq(
+              a: 2, b: 7, d: 11
+            )
+          end
+        end
+
+        context 'when skipping recursive' do
+          let(:options) { { recursive: false } }
+
+          it 'transforms values' do
+            expect(changer.change(hash)).to eq(
+              a: 2, b: { c: 2 }, d: [{ e: 100 }]
+            )
+          end
+        end
+      end
+
+      context 'when object is an array' do
+        let(:array) { [15, { c: 2 }, [{ e: 100 }]] }
+
+        it 'transforms values' do
+          expect(changer.change(array)).to eq(
+            [2, { c: 1 }, [{ e: 3 }]]
+          )
+        end
+      end
+    end
+  end
+end