darthjee-core_ext 1.7.4 → 3.0.0

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+shared_examples 'a method that returns a deep hash' do
+  subject(:hash) do
+    {
+      'person.name' => 'Some name',
+      'person.age' => 22,
+      'status' => :success,
+      'vehicle.fuel' => 'GASOLINE',
+      'vehicle.doors' => 4
+    }
+  end
+
+  let(:args) { [] }
+
+  let(:expected) do
+    {
+      'person' => { 'name' => 'Some name', 'age' => 22 },
+      'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 },
+      'status' => :success
+    }
+  end
+
+  it 'build a deep hash' do
+    expect(result).to eq(expected)
+  end
+
+  context 'with indexed keys' do
+    subject(:hash) do
+      {
+        'person[0].name' => 'First person',
+        'person[0].age' => 22,
+        'person[1].name' => 'Second person',
+        'person[1].age' => 27,
+        'device[0]' => 'GEAR_LOCK',
+        'device[1]' => 'GPS',
+        'zipCode' => '122345-123'
+      }
+    end
+
+    let(:expected) do
+      {
+        'person' => [
+          { 'name' => 'First person', 'age' => 22 },
+          { 'name' => 'Second person', 'age' => 27 }
+        ],
+        'device' => %w[GEAR_LOCK GPS],
+        'zipCode' => '122345-123'
+      }
+    end
+
+    it 'build a deep hash with arrays' do
+      expect(result).to eq(expected)
+    end
+  end
+
+  context 'with a n level hash' do
+    subject(:hash) do
+      {
+        'quote_request.personal.person.name' => 'Some name',
+        'quote_request.personal.person.age' => 22,
+        'quote_request.insurance.vehicle.fuel' => 'GASOLINE',
+        'quote_request.insurance.vehicle.doors' => 4,
+        'request.status' => :success,
+        'trials' => 3
+      }
+    end
+
+    let(:expected) do
+      {
+        'quote_request' => {
+          'personal' => {
+            'person' => { 'name' => 'Some name', 'age' => 22 }
+          },
+          'insurance' => {
+            'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 }
+          }
+        },
+        'request' => { 'status' => :success },
+        'trials' => 3
+      }
+    end
+
+    it 'build a deep hash with arrays' do
+      expect(result).to eq(expected)
+    end
+  end
+
+  context 'with a n level hash and arrays' do
+    subject(:hash) do
+      {
+        'quote_request.personal.person[0].name' => 'Some name 1',
+        'quote_request.personal.person[0].age' => 22,
+        'quote_request.personal.person[1].name' => 'Some name 2',
+        'quote_request.personal.person[1].age' => 23,
+        'request[0].status.clazz' => 'String',
+        'request[1].status.clazz' => 'Integer',
+        'request[2].status.clazz' => 'Date',
+        'trials' => 3
+      }
+    end
+
+    let(:expected) do
+      {
+        'quote_request' => {
+          'personal' => {
+            'person' => [
+              { 'name' => 'Some name 1', 'age' => 22 },
+              { 'name' => 'Some name 2', 'age' => 23 }
+            ]
+          }
+        },
+        'request' => [
+          { 'status' => { 'clazz' => 'String' } },
+          { 'status' => { 'clazz' => 'Integer' } },
+          { 'status' => { 'clazz' => 'Date' } }
+        ],
+        'trials' => 3
+      }
+    end
+
+    it 'build a deep hash with arrays' do
+      expect(result).to eq(expected)
+    end
+  end
+
+  context 'with custom separator' do
+    subject(:hash) do
+      {
+        'person_name' => 'Some name',
+        'person_age' => 22,
+        'status' => :success,
+        'vehicle_fuel' => 'GASOLINE',
+        'vehicle_doors' => 4
+      }
+    end
+
+    let(:args) { ['_'] }
+
+    it 'build a deep hash with arrays' do
+      expect(result).to eq(expected)
+    end
+  end
+
+  context 'with custom separator on n level deep hash' do
+    subject(:hash) do
+      {
+        'person_name_clazz' => 'String'
+      }
+    end
+
+    let(:args) { ['_'] }
+
+    let(:expected) do
+      {
+        'person' => {
+          'name' => { 'clazz' => 'String' }
+        }
+      }
+    end
+
+    it 'build a deep hash with arrays' do
+      expect(result).to eq(expected)
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ end
 
 shared_examples 'a method that is able to change keys' do |method|
   let(:foo_sym_transformation) do
-    hash.public_send(method) { |k| "foo_#{k}".to_sym }
+    hash.public_send(method) { |k| :"foo_#{k}" }
   end
 
   context 'with simple level hash' do
@@ -52,7 +52,7 @@ shared_examples 'a method that is able to change keys' do |method|
 
   context 'with recursive hash' do
     let(:hash) { { 'a' => 1, b: { c: 3, 'd' => 4 } } }
-    let(:result) { hash.public_send(method, options) { |k| "foo_#{k}" } }
+    let(:result) { hash.public_send(method, **options) { |k| "foo_#{k}" } }
     let(:expected) do
       { 'foo_a' => 1, 'foo_b' => { 'foo_c' => 3, 'foo_d' => 4 } }
     end
@@ -64,7 +64,7 @@ shared_examples 'a method that is able to change keys' do |method|
     end
 
     context 'when options are given' do
-      let(:options) { { recursive: recursive } }
+      let(:options) { { recursive: } }
 
       context 'with recursion' do
         let(:recursive) { true }

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

@@ -2,22 +2,67 @@
 
 require 'spec_helper'
 
-shared_examples 'a class that has a method to squash a hash' do
-  describe '#squash' do
-    let(:hash) { { a: { b: 1, c: { d: 2 } } } }
+shared_examples 'a method to squash a hash' do |joiner = '.'|
+  let(:hash) { { a: { b: 1, c: { d: 2 } } } }
+
+  context 'with hash values' do
+    let(:key1) { %w[a b].join(joiner) }
+    let(:key2) { %w[a c d].join(joiner) }
 
     it 'flattens the hash' do
-      expect(squashed).to eq('a.b' => 1, 'a.c.d' => 2)
+      expect(squashed).to eq(key1 => 1, key2 => 2)
     end
 
     it { expect { hash.squash }.not_to(change { hash }) }
+  end
 
-    context 'with array value' do
-      let(:hash) { { a: { b: [1, { x: 3, y: { z: 4 } }] } } }
+  context 'with simple array value' do
+    let(:hash) do
+      {
+        'person' => %w[John Wick]
+      }
+    end
+
+    it 'squash also hash' do
+      expect(squashed).to eq(
+        'person[0]' => 'John',
+        'person[1]' => 'Wick'
+      )
+    end
+  end
+
+  context 'with array containing hashes' do
+    let(:hash) { { a: { b: [1, { x: 3, y: { z: 4 } }] } } }
+    let(:key)  { %w[a b].join(joiner) }
+
+    let(:expected) do
+      {
+        "#{key}[0]" => 1,
+        "#{key}[1]#{joiner}x" => 3,
+        "#{key}[1]#{joiner}y#{joiner}z" => 4
+      }
+    end
 
-      it 'flattens the hash' do
-        expect(squashed).to eq('a.b' => [1, { x: 3, y: { z: 4 } }])
-      end
+    it 'flattens the hash' do
+      expect(squashed).to eq(expected)
+    end
+  end
+
+  context 'with array containing arrays' do
+    let(:hash) { { a: { b: [[11, 12], [21, 22]] } } }
+    let(:key)  { %w[a b].join(joiner) }
+
+    let(:expected) do
+      {
+        "#{key}[0][0]" => 11,
+        "#{key}[0][1]" => 12,
+        "#{key}[1][0]" => 21,
+        "#{key}[1][1]" => 22
+      }
+    end
+
+    it 'flattens the hash' do
+      expect(squashed).to eq(expected)
     end
   end
 end

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

@@ -10,6 +10,10 @@ shared_examples 'a class with a keys sort method' do
       it 'sorts keys as symbols' do
         expect(result).to eq(a: 2, b: 1)
       end
+
+      it 'sorts keys' do
+        expect(result.keys).to eq(%i[a b])
+      end
     end
 
     context 'when keys are strings' do
@@ -18,6 +22,10 @@ shared_examples 'a class with a keys sort method' do
       it 'sorts keys as string' do
         expect(result).to eq('a' => 2, 'b' => 1)
       end
+
+      it 'sorts keys' do
+        expect(result.keys).to eq(%w[a b])
+      end
     end
 
     context 'when there is a nested hash' do
@@ -27,6 +35,14 @@ shared_examples 'a class with a keys sort method' do
         it 'sorts keys recursively' do
           expect(result).to eq(a: { c: 4, d: 3 }, b: 1)
         end
+
+        it 'sorts keys' do
+          expect(result.keys).to eq(%i[a b])
+        end
+
+        it 'sorts inner keys' do
+          expect(result[:a].keys).to eq(%i[c d])
+        end
       end
 
       context 'when recursive option is given' do
@@ -35,6 +51,14 @@ shared_examples 'a class with a keys sort method' do
         it 'sorts keys recursively when argumen is passed' do
           expect(result).to eq(a: { c: 4, d: 3 }, b: 1)
         end
+
+        it 'sorts keys' do
+          expect(result.keys).to eq(%i[a b])
+        end
+
+        it 'sorts inner keys' do
+          expect(result[:a].keys).to eq(%i[c d])
+        end
       end
 
       context 'when no recursive option is given' do
@@ -43,24 +67,260 @@ shared_examples 'a class with a keys sort method' do
         it 'does not sorts keys recursively when argumen is passed' do
           expect(result).to eq(a: { d: 3, c: 4 }, b: 1)
         end
+
+        it 'sorts keys' do
+          expect(result.keys).to eq(%i[a b])
+        end
+
+        it 'does not sort inner keys' do
+          expect(result[:a].keys).to eq(%i[d c])
+        end
+
+        it 'does not change inner hash' do
+          expect { result }.not_to change(hash[:a], :keys)
+        end
       end
     end
 
     context 'when it is deep nestled' do
-      let(:hash) { { b: 1, a: { d: 2, c: { e: 3, f: 4 } } } }
+      let(:hash) { { b: 1, a: { d: 2, c: { f: 3, e: 4 } } } }
 
       it 'sort recursevely on many levels' do
-        expected = { a: { c: { f: 4, e: 3 }, d: 2 }, b: 1 }
-        expect(hash.sort_keys(recursive: true)).to eq(expected)
+        expected = { a: { c: { f: 3, e: 4 }, d: 2 }, b: 1 }
+        expect(result).to eq(expected)
+      end
+
+      it 'sorts keys' do
+        expect(result.keys).to eq(%i[a b])
+      end
+
+      it 'sorts inner keys' do
+        expect(result[:a].keys).to eq(%i[c d])
+      end
+
+      it 'sorts deeper inner keys' do
+        expect(result[:a][:c].keys).to eq(%i[e f])
       end
     end
 
     context 'when it has a nestled array' do
-      let(:hash) { { b: 1, a: { d: 2, c: [{ e: 3, f: 4 }] } } }
+      let(:hash) { { b: 1, a: { d: 2, c: [{ f: 3, e: 4 }] } } }
 
       it 'applies to arrays as well' do
-        expected = { a: { c: [{ f: 4, e: 3 }], d: 2 }, b: 1 }
-        expect(hash.sort_keys(recursive: true)).to eq(expected)
+        expected = { a: { c: [{ f: 3, e: 4 }], d: 2 }, b: 1 }
+        expect(result).to eq(expected)
+      end
+
+      it 'sorts keys' do
+        expect(result.keys).to eq(%i[a b])
+      end
+
+      it 'sorts inner keys' do
+        expect(result[:a].keys).to eq(%i[c d])
+      end
+
+      it 'does not sort array deeper inner keys' do
+        expect(result[:a][:c].map(&:keys)).to eq([%i[f e]])
+      end
+
+      it 'does not change array deeper inner hash' do
+        expect { result }.not_to(change { hash[:a][:c].map(&:keys) })
+      end
+    end
+  end
+end
+
+shared_examples 'a class with a keys sort method that changes original' do
+  describe '#sort_keys' do
+    let(:options) { {} }
+
+    context 'when keys are symbols' do
+      let(:hash) { { b: 1, a: 2 } }
+
+      it 'changes original hash' do
+        expect { result }.to change(hash, :keys)
+          .from(%i[b a]).to(%i[a b])
+      end
+    end
+
+    context 'when keys are strings' do
+      let(:hash) { { 'b' => 1, 'a' => 2 } }
+
+      it 'changes original hash' do
+        expect { result }.to change(hash, :keys)
+          .from(%w[b a]).to(%w[a b])
+      end
+    end
+
+    context 'when there is a nested hash' do
+      let(:hash) { { b: 1, a: { d: 3, c: 4 } } }
+
+      context 'when no option is given' do
+        it 'changes original hash' do
+          expect { result }.to change(hash, :keys)
+            .from(%i[b a]).to(%i[a b])
+        end
+
+        it 'changes inner hash' do
+          expect { result }.to change(hash[:a], :keys)
+            .from(%i[d c]).to(%i[c d])
+        end
+      end
+
+      context 'when recursive option is given' do
+        let(:options) { { recursive: true } }
+
+        it 'changes original hash' do
+          expect { result }.to change(hash, :keys)
+            .from(%i[b a]).to(%i[a b])
+        end
+
+        it 'changes inner hash' do
+          expect { result }.to change(hash[:a], :keys)
+            .from(%i[d c]).to(%i[c d])
+        end
+      end
+
+      context 'when no recursive option is given' do
+        let(:options) { { recursive: false } }
+
+        it 'changes original hash' do
+          expect { result }.to change(hash, :keys)
+            .from(%i[b a]).to(%i[a b])
+        end
+
+        it 'does not change inner hash' do
+          expect { result }.not_to change(hash[:a], :keys)
+        end
+      end
+    end
+
+    context 'when it is deep nestled' do
+      let(:hash) { { b: 1, a: { d: 2, c: { f: 3, e: 4 } } } }
+
+      it 'changes original hash' do
+        expect { result }.to change(hash, :keys)
+          .from(%i[b a]).to(%i[a b])
+      end
+
+      it 'changes inner hash' do
+        expect { result }.to change(hash[:a], :keys)
+          .from(%i[d c]).to(%i[c d])
+      end
+
+      it 'changes deeper inner hash' do
+        expect { result }.to change(hash[:a][:c], :keys)
+          .from(%i[f e]).to(%i[e f])
+      end
+    end
+
+    context 'when it has a nestled array' do
+      let(:hash) { { b: 1, a: { d: 2, c: [{ f: 3, e: 4 }] } } }
+
+      it 'changes original hash' do
+        expect { result }.to change(hash, :keys)
+          .from(%i[b a]).to(%i[a b])
+      end
+
+      it 'changes inner hash' do
+        expect { result }.to change(hash[:a], :keys)
+          .from(%i[d c]).to(%i[c d])
+      end
+
+      it 'does not change array deeper inner hash' do
+        expect { result }.not_to(change { hash[:a][:c].map(&:keys) })
+      end
+    end
+  end
+end
+
+shared_examples 'a class with a keys sort method that not change self' do
+  describe '#sort_keys' do
+    let(:options) { {} }
+
+    context 'when keys are symbols' do
+      let(:hash) { { b: 1, a: 2 } }
+
+      it 'changes original hash' do
+        expect { result }.not_to change(hash, :keys)
+      end
+    end
+
+    context 'when keys are strings' do
+      let(:hash) { { 'b' => 1, 'a' => 2 } }
+
+      it 'changes original hash' do
+        expect { result }.not_to change(hash, :keys)
+      end
+    end
+
+    context 'when there is a nested hash' do
+      let(:hash) { { b: 1, a: { d: 3, c: 4 } } }
+
+      context 'when no option is given' do
+        it 'changes original hash' do
+          expect { result }.not_to change(hash, :keys)
+        end
+
+        it 'changes inner hash' do
+          expect { result }.not_to change(hash[:a], :keys)
+        end
+      end
+
+      context 'when recursive option is given' do
+        let(:options) { { recursive: true } }
+
+        it 'changes original hash' do
+          expect { result }.not_to change(hash, :keys)
+        end
+
+        it 'changes inner hash' do
+          expect { result }.not_to change(hash[:a], :keys)
+        end
+      end
+
+      context 'when no recursive option is given' do
+        let(:options) { { recursive: false } }
+
+        it 'changes original hash' do
+          expect { result }.not_to change(hash, :keys)
+        end
+
+        it 'does not change inner hash' do
+          expect { result }.not_to change(hash[:a], :keys)
+        end
+      end
+    end
+
+    context 'when it is deep nestled' do
+      let(:hash) { { b: 1, a: { d: 2, c: { f: 3, e: 4 } } } }
+
+      it 'changes original hash' do
+        expect { result }.not_to change(hash, :keys)
+      end
+
+      it 'changes inner hash' do
+        expect { result }.not_to change(hash[:a], :keys)
+      end
+
+      it 'changes deeper inner hash' do
+        expect { result }.not_to change(hash[:a][:c], :keys)
+      end
+    end
+
+    context 'when it has a nestled array' do
+      let(:hash) { { b: 1, a: { d: 2, c: [{ f: 3, e: 4 }] } } }
+
+      it 'changes original hash' do
+        expect { result }.not_to change(hash, :keys)
+      end
+
+      it 'changes inner hash' do
+        expect { result }.not_to change(hash[:a], :keys)
+      end
+
+      it 'does not change array deeper inner hash' do
+        expect { result }.not_to(change { hash[:a][:c].map(&:keys) })
       end
     end
   end

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

@@ -4,7 +4,7 @@ shared_examples 'an array with map_to_hash method' do
   describe '#map_to_hash' do
     subject(:hash) { %w[word1 wooord2] }
 
-    let(:mapping_block) { proc { |word| word.length } }
+    let(:mapping_block) { proc(&:length) }
     let(:mapped)        { hash.map_to_hash(&mapping_block) }
     let(:expected)      { { 'word1' => 5, 'wooord2' => 7 } }
 

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

@@ -57,18 +57,18 @@ shared_examples 'a method that remaps the keys' do |method|
     end
   end
 
-  context 'when remap has original array keys' do
+  context 'when remap swap keys' do
     let(:remap) { { b: :a, a: :b } }
 
-    it 'does not remap the keys' do
+    it 'swap keys' do
       expect(result).to eq(b: 1, a: 2)
     end
   end
 
-  context 'when remap has original array keys' do
+  context 'when remap has one of the keys swapped' do
     let(:remap) { { a: :b, b: :c } }
 
-    it 'does not remap the keys' do
+    it 'swap just that key' do
       expect(result).to eq(b: 1, c: 2)
     end
   end

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

@@ -103,7 +103,7 @@ shared_examples 'a method that change the hash values' do |method|
 
     it 'ignore hash and does not work recursively when option is passed' do
       options = { skip_inner: false, recursive: false }
-      result = hash.public_send(method, options) do |value|
+      result = hash.public_send(method, **options) do |value|
         value.is_a?(Hash) ? value : value + 1
       end
       expect(result).to eq(a: 2, b: 3, c: { d: 3, e: 4 })
@@ -142,7 +142,7 @@ shared_examples 'a method that change the hash values' do |method|
 
     it 'ignore hash and does not work recursively when option is passed' do
       options = { skip_inner: false, recursive: false }
-      result = hash.public_send(method, options) do |value|
+      result = hash.public_send(method, **options) do |value|
         value.is_a?(Array) ? value : value + 1
       end
       expect(result).to eq(a: 2, b: 3, c: [{ d: 3 }, { e: { f: 4 } }, 5])