darthjee-core_ext 1.7.3 → 1.7.4

data/spec/support/shared_examples/clean.rb

@@ -2,7 +2,7 @@
 
 shared_examples 'a hash clean method' do |method|
   context 'when hash has one level' do
-    let(:subject) do
+    subject(:hash) do
       { a: 1, b: nil, c: '', d: {} }
     end
 
@@ -11,12 +11,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has two levels' do
-    let(:subject) do
+    subject(:hash) do
       { a: 1, c: '', d: { e: 1 }, f: { g: { b: nil } } }
     end
 
@@ -25,12 +25,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has many levels' do
-    let(:subject) do
+    subject(:hash) do
       {
         a: 1,
         d: { e: { k: { l: { m: { n: 1 } } } } },
@@ -43,12 +43,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has one nil value and one valid value' do
-    let(:subject) do
+    subject(:hash) do
       { a: { b: 1, c: nil } }
     end
 
@@ -57,12 +57,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has arrays' do
-    let(:subject) do
+    subject(:hash) do
       { a: [] }
     end
 
@@ -71,12 +71,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has arrays with hashes' do
-    let(:subject) do
+    subject(:hash) do
       { a: [{ c: nil }] }
     end
 
@@ -85,12 +85,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has arrays with hashes with valid values' do
-    let(:subject) do
+    subject(:hash) do
       { a: [{ c: 1 }] }
     end
 
@@ -99,12 +99,12 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when hash has arrays with hashes with valid and invalid values' do
-    let(:subject) do
+    subject(:hash) do
       { a: [{ c: nil }, { d: 1 }] }
     end
 
@@ -113,14 +113,14 @@ shared_examples 'a hash clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 end
 
 shared_examples 'an array clean method' do |method|
   context 'when array has one level' do
-    let(:subject) do
+    subject(:hash) do
       [1, nil, '', {}, []]
     end
 
@@ -129,12 +129,12 @@ shared_examples 'an array clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 
   context 'when array has many levels' do
-    let(:subject) do
+    subject(:hash) do
       [
         1,
         nil,
@@ -149,7 +149,7 @@ shared_examples 'an array clean method' do |method|
     end
 
     it 'cleans the hash from empty and nil values' do
-      expect(subject.send(method)).to eq(expected)
+      expect(hash.send(method)).to eq(expected)
     end
   end
 end

data/spec/support/shared_examples/date.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
 shared_examples 'an object that knows how to calculate days between' do
-  let(:other_date) { subject.to_date + difference }
+  let(:other_date) { date.to_date + difference }
   let(:difference) { 1.year }
 
   context 'when other object is a date' do
     context 'when other date is one year ahead' do
-      it { expect(subject.days_between(other_date)).to eq(365) }
+      it { expect(date.days_between(other_date)).to eq(365) }
     end
 
     context 'when other date is one year behind' do
       let(:difference) { - 1.year }
 
-      it { expect(subject.days_between(other_date)).to eq(365) }
+      it { expect(date.days_between(other_date)).to eq(365) }
     end
 
     context 'when initial date is on a leap year' do
       let(:year) { 2016 }
 
       context 'when other date is one year ahead' do
-        it { expect(subject.days_between(other_date)).to eq(365) }
+        it { expect(date.days_between(other_date)).to eq(365) }
       end
 
       context 'when other date is one year behind' do
         let(:difference) { - 1.year }
 
-        it { expect(subject.days_between(other_date)).to eq(366) }
+        it { expect(date.days_between(other_date)).to eq(366) }
       end
     end
 
@@ -33,43 +33,48 @@ shared_examples 'an object that knows how to calculate days between' do
       let(:year) { 2015 }
 
       context 'when other date is one year ahead' do
-        it { expect(subject.days_between(other_date)).to eq(366) }
+        it { expect(date.days_between(other_date)).to eq(366) }
       end
 
       context 'when other date is one year behind' do
         let(:difference) { - 1.year }
 
-        it { expect(subject.days_between(other_date)).to eq(365) }
+        it { expect(date.days_between(other_date)).to eq(365) }
       end
     end
   end
 
   context 'when other date is a time' do
-    let(:other_date) { subject.to_date.to_time + difference }
+    let(:other_date) { date.to_date.to_time + difference }
 
     context 'when other date is one year and 10 hours ahead' do
       let(:difference) { 1.year + 10.hours }
-      it { expect(subject.days_between(other_date)).to eq(365) }
+
+      it { expect(date.days_between(other_date)).to eq(365) }
     end
 
     context 'when other date is one year and 25 hours ahead' do
       let(:difference) { 1.year + 25.hours }
-      it { expect(subject.days_between(other_date)).to eq(366) }
+
+      it { expect(date.days_between(other_date)).to eq(366) }
     end
 
     context 'when other date is one year and 23 hours ahead' do
       let(:difference) { 1.year + 23.hours }
-      it { expect(subject.days_between(other_date)).to eq(365) }
+
+      it { expect(date.days_between(other_date)).to eq(365) }
     end
 
     context 'when other date is one year and 10 hours behind' do
       let(:difference) { - 1.year - 10.hours }
-      it { expect(subject.days_between(other_date)).to eq(366) }
+
+      it { expect(date.days_between(other_date)).to eq(366) }
     end
 
     context 'when other date is almost one year behind (missing 10 hours)' do
       let(:difference) { -1.year + 10.hours }
-      it { expect(subject.days_between(other_date)).to eq(365) }
+
+      it { expect(date.days_between(other_date)).to eq(365) }
     end
   end
 end

data/spec/support/shared_examples/hash/chain_fetch.rb

@@ -50,7 +50,7 @@ shared_examples 'an object with capable of performing chain fetch' do
         end
       end
 
-      context 'but a default value block is given' do
+      context 'when a default value block is given' do
         let(:default_value) { 100 }
         let(:block) { proc { default_value } }
 
@@ -58,7 +58,7 @@ shared_examples 'an object with capable of performing chain fetch' do
           expect(result).to eq(default_value)
         end
 
-        context 'and the block logs the missing keys' do
+        context 'when the block logs the missing keys' do
           it 'hnadles the missing keys' do
             missing_keys = nil
             hash.chain_fetch(*keys) do |_, keys|
@@ -69,8 +69,9 @@ shared_examples 'an object with capable of performing chain fetch' do
           end
         end
 
-        context 'and the block uses the key for the return' do
+        context 'when the block uses the key for the return' do
           let(:block) { proc { |k| "returned #{k}" } }
+
           it 'hnadles the missing keys' do
             expect(result).to eq('returned x')
           end

data/spec/support/shared_examples/hash/chain_hash_keys_changer.rb

@@ -5,7 +5,7 @@ shared_examples 'a class with chain_change_key method' do
     { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
   end
 
-  describe :chain_change_keys do
+  describe '#chain_change_keys' do
     it_behaves_like 'a method that is able to chain change keys',
                     :chain_change_keys
     it 'does not affects the original hash' do
@@ -15,7 +15,7 @@ shared_examples 'a class with chain_change_key method' do
     end
   end
 
-  describe :ichain_change_keys! do
+  describe '#ichain_change_keys!' do
     it_behaves_like 'a method that is able to chain change keys',
                     :chain_change_keys!
 
@@ -28,8 +28,8 @@ shared_examples 'a class with chain_change_key method' do
 end
 
 shared_examples 'a method that is able to chain change keys' do |method|
-  let(:result) { hash.public_send(method, *transformations, options) }
-  let(:options) { {} }
+  let(:result)          { hash.public_send(method, *transformations, options) }
+  let(:options)         { {} }
   let(:transformations) { [:to_s] }
 
   context 'with simple level hash' do
@@ -37,12 +37,14 @@ shared_examples 'a method that is able to chain change keys' do |method|
 
     context 'with symbol transformation' do
       let(:transformations) { [:to_sym] }
-      let(:expected) { { a: 1, b: 2 } }
+      let(:expected)        { { a: 1, b: 2 } }
+
       it_behaves_like 'result is as expected'
     end
 
     context 'with string transformation' do
       let(:expected) { { 'a' => 1, 'b' => 2 } }
+
       it_behaves_like 'result is as expected'
     end
   end
@@ -62,12 +64,14 @@ shared_examples 'a method that is able to chain change keys' do |method|
 
       context 'with recursion' do
         let(:recursive) { true }
+
         it_behaves_like 'result is as expected'
       end
 
       context 'without recursion' do
         let(:recursive) { false }
         let(:expected) { { 'a' => 1, 'b' => { c: 3, 'd' => 4 } } }
+
         it_behaves_like 'result is as expected'
       end
     end
@@ -78,14 +82,17 @@ shared_examples 'a method that is able to chain change keys' do |method|
     let(:expected) do
       { 'a' => 1, 'b' => { 'c' => 2, 'd' => { 'e' => 3, 'f' => 4 } } }
     end
+
     it_behaves_like 'result is as expected'
   end
 
-  context 'calling with chained transformations' do
+  context 'when calling with chained transformations' do
     let(:transformations) { %i[to_s upcase to_sym] }
 
-    let(:hexpected) do
+    let(:expected) do
       { A: 1, B: 2, C: { D: 3, E: 4 }, F: [{ G: 5 }, { H: 6 }] }
     end
+
+    it_behaves_like 'result is as expected'
   end
 end

data/spec/support/shared_examples/hash/hash_keys_changer.rb

@@ -5,7 +5,7 @@ shared_examples 'a class with change_key method' do
     { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
   end
 
-  describe :change_keys do
+  describe '#change_keys' do
     it_behaves_like 'a method that is able to change keys', :change_keys
     it 'does not affects the original hash' do
       expect do
@@ -14,7 +14,7 @@ shared_examples 'a class with change_key method' do
     end
   end
 
-  describe :change_keys! do
+  describe '#change_keys!' do
     it_behaves_like 'a method that is able to change keys', :change_keys!
 
     it 'affects the original hash' do
@@ -38,12 +38,14 @@ shared_examples 'a method that is able to change keys' do |method|
         hash.public_send(method) { |k| "foo_#{k}" }
       end
       let(:expected) { { 'foo_a' => 1, 'foo_b' => 2 } }
+
       it_behaves_like 'result is as expected'
     end
 
     context 'with symbol transformation' do
-      let(:result) { foo_sym_transformation }
+      let(:result)   { foo_sym_transformation }
       let(:expected) { { foo_a: 1, foo_b: 2 } }
+
       it_behaves_like 'result is as expected'
     end
   end
@@ -57,6 +59,7 @@ shared_examples 'a method that is able to change keys' do |method|
 
     context 'when no options are given' do
       let(:options) { {} }
+
       it_behaves_like 'result is as expected'
     end
 
@@ -65,12 +68,14 @@ shared_examples 'a method that is able to change keys' do |method|
 
       context 'with recursion' do
         let(:recursive) { true }
+
         it_behaves_like 'result is as expected'
       end
 
       context 'without recursion' do
         let(:recursive) { false }
-        let(:expected) { { 'foo_a' => 1, 'foo_b' => { c: 3, 'd' => 4 } } }
+        let(:expected)  { { 'foo_a' => 1, 'foo_b' => { c: 3, 'd' => 4 } } }
+
         it_behaves_like 'result is as expected'
       end
     end
@@ -82,6 +87,7 @@ shared_examples 'a method that is able to change keys' do |method|
       { foo_a: 1, foo_b: { foo_c: 2, foo_d: { foo_e: 3, foo_f: 4 } } }
     end
     let(:result) { foo_sym_transformation }
+
     it_behaves_like 'result is as expected'
   end
 end

data/spec/support/shared_examples/hash/hash_transpose.rb

@@ -24,7 +24,7 @@ shared_examples 'a class with transpose method' do |method|
         expect(hash.public_send(method).public_send(method)).to eq(hash)
       end
 
-      context 'whe key is already a hash' do
+      context 'when key is already a hash' do
         let(:key) { { c: 2 } }
         let(:hash) { { key => sub_hash } }
 

data/spec/support/shared_examples/hash/keys_appender.rb

@@ -7,26 +7,31 @@ shared_examples 'a class with append_keys method' do
       expected = { foo_a: 1, 'foo_b' => 2 }
       expect(hash.prepend_to_keys('foo_')).to eq(expected)
     end
+
     it 'applies the block recursively' do
       hash = { 'a' => 1, b: { c: 3, 'd' => 4 } }
       expected = { 'foo_a' => 1, foo_b: { foo_c: 3, 'foo_d' => 4 } }
       expect(hash.prepend_to_keys('foo_')).to eq(expected)
     end
-    it 'changes type when type option is passed' do
+
+    it 'changes type to string when type string option is passed' do
       hash = { 'a' => 1, b: 2 }
       expected = { 'foo_a' => 1, 'foo_b' => 2 }
       expect(hash.prepend_to_keys('foo_', type: :string)).to eq(expected)
     end
-    it 'changes type when type option is passed' do
+
+    it 'changes type to symbol when type symbol option is passed' do
       hash = { 'a' => 1, b: 2 }
       expected = { foo_a: 1, foo_b: 2 }
       expect(hash.prepend_to_keys('foo_', type: :symbol)).to eq(expected)
     end
+
     it 'keep type when type option is passed as keep' do
       hash = { 'a' => 1, b: 2 }
       expected = { 'foo_a' => 1, foo_b: 2 }
       expect(hash.prepend_to_keys('foo_', type: :keep)).to eq(expected)
     end
+
     it 'applies to array as well' do
       hash = { 'a' => 1, b: [{ c: 2 }, { d: 3 }] }
       expected = { 'foo_a' => 1, foo_b: [{ foo_c: 2 }, { foo_d: 3 }] }
@@ -40,26 +45,31 @@ shared_examples 'a class with append_keys method' do
       expected = { a_bar: 1, 'b_bar' => 2 }
       expect(hash.append_to_keys('_bar')).to eq(expected)
     end
+
     it 'applies the block recursively' do
       hash = { 'a' => 1, b: { c: 3, 'd' => 4 } }
       expected = { 'a_bar' => 1, b_bar: { c_bar: 3, 'd_bar' => 4 } }
       expect(hash.append_to_keys('_bar')).to eq(expected)
     end
-    it 'changes type when type option is passed' do
+
+    it 'changes type to string when type string option is passed' do
       hash = { 'a' => 1, b: 2 }
       expected = { 'a_bar' => 1, 'b_bar' => 2 }
       expect(hash.append_to_keys('_bar', type: :string)).to eq(expected)
     end
-    it 'changes type when type option is passed' do
+
+    it 'changes type to symbol when type symbol option is passed' do
       hash = { 'a' => 1, b: 2 }
       expected = { a_bar: 1, b_bar: 2 }
       expect(hash.append_to_keys('_bar', type: :symbol)).to eq(expected)
     end
+
     it 'keep type when type option is passed as keep' do
       hash = { 'a' => 1, b: 2 }
       expected = { 'a_bar' => 1, b_bar: 2 }
       expect(hash.append_to_keys('_bar', type: :keep)).to eq(expected)
     end
+
     it 'applies to array as well' do
       hash = { 'a' => 1, b: [{ c: 2 }, { d: 3 }] }
       expected = { 'a_bar' => 1, b_bar: [{ c_bar: 2 }, { d_bar: 3 }] }