darthjee-core_ext 1.2.6

data/spec/lib/enumerable_spec.rb

@@ -0,0 +1,31 @@
+describe Enumerable do
+  describe '#clean!' do
+    it_behaves_like 'an array clean method', :clean!
+    it_behaves_like 'a hash clean method', :clean!
+
+    it 'changes the original hash' do
+      hash = { a: nil}
+      expect { hash.clean! }.to change { hash }
+    end
+
+    it 'changes original array' do
+      array = [{ a: nil}]
+      expect { array.clean! }.to change { array }
+    end
+  end
+
+  describe '#clean' do
+    it_behaves_like 'an array clean method', :clean
+    it_behaves_like 'a hash clean method', :clean
+
+    it 'does not change the original hash' do
+      hash = { a: nil}
+      expect { hash.clean }.not_to change { hash }
+    end
+
+    it 'does not change the original array' do
+      array = [{ a: nil}]
+      expect { array.clean }.not_to change { array }
+    end
+  end
+end

data/spec/lib/hash/deep_hash_constructor_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Hash::DeepHashConstructor do
+  let(:subject) { described_class.new('.') }
+  let(:deep_hash) { subject.deep_hash(hash) }
+
+  describe '.deep_hash' do
+    let(:hash) do
+      {
+        'person.name' => 'Some name',
+        'person.age' => 22,
+        'status' => :success,
+        'vehicle.fuel' => 'GASOLINE',
+        'vehicle.doors' => 4
+      }
+    end
+
+    let(:expected) do
+      {
+        'person' => { 'name' => 'Some name', 'age' => 22 },
+        'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 },
+        'status' => :success
+      }
+    end
+
+    it 'build a deep hash' do
+      expect(deep_hash).to eq(expected)
+    end
+
+    context 'with indexed keys' do
+      let(: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(deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash' do
+      let(: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(deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash and arrays' do
+      let(: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(deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with custom separator' do
+      let(:subject) { described_class.new('_') }
+      let(:hash) do
+        {
+          'person_name' => 'Some name',
+          'person_age' => 22,
+          'status' => :success,
+          'vehicle_fuel' => 'GASOLINE',
+          'vehicle_doors' => 4
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with custom separator on n level deep hash' do
+      let(:subject) { described_class.new('_') }
+      let(:hash) do
+        {
+          'person_name_clazz' => String
+        }
+      end
+
+      let(:expected) do
+        {
+          'person' => {
+            'name' => { 'clazz' => String }
+          }
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(deep_hash).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/hash/key_changer_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Hash::KeyChanger do
+  let(:subject) { described_class.new(hash) }
+
+  describe '#underscore_keys' do
+    let(:hash) { { keyUnderscore: 1 } }
+
+    it 'underscore all the keys' do
+      expect(subject.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
+        expect(subject.underscore_keys).to eq(key_underscore: { another_key: 1 })
+      end
+    end
+
+    context 'when hash has an array' do
+      let(:hash) { { keyUnderscore: [{ anotherKey: 1 }] } }
+
+      it 'underscore all the keys' do
+        expect(subject.underscore_keys).to eq(key_underscore: [{ another_key: 1 }])
+      end
+    end
+
+    context 'changes the hash' do
+      it 'underscore all the keys' do
+        expect do
+          subject.underscore_keys
+        end.to change { hash }
+      end
+    end
+
+    context 'when giving non recursive options' do
+      context 'when hash is a many level hash' do
+        let(:hash) { { keyUnderscore: { anotherKey: 1 } } }
+
+        it 'underscore all the keys' do
+          expect(subject.underscore_keys(recursive: false)).to eq(key_underscore: { anotherKey: 1 })
+        end
+      end
+
+      context 'when hash has an array' do
+        let(:hash) { { keyUnderscore: [{ anotherKey: 1 }] } }
+
+        it 'underscore all the keys' do
+          expect(subject.underscore_keys(recursive: false)).to eq(key_underscore: [{ anotherKey: 1 }])
+        end
+      end
+    end
+  end
+end

data/spec/lib/hash_spec.rb

@@ -0,0 +1,347 @@
+require 'spec_helper'
+
+describe Hash do
+  it_behaves_like 'a class with change_key method'
+  it_behaves_like 'a class with chain_change_key method'
+  it_behaves_like 'a class with camlize_keys method'
+  it_behaves_like 'a class with underscore_keys method'
+  it_behaves_like 'a class with append_keys method'
+  it_behaves_like 'a class with change_values method'
+  it_behaves_like 'a class with remap method'
+  it_behaves_like 'an object with chain_fetch method'
+
+  describe :squash do
+    let(:hash) { { a: { b: 1, c: { d: 2 } } } }
+
+    it 'flattens the hash' do
+      expect(hash.squash).to eq('a.b' => 1, 'a.c.d' => 2)
+    end
+
+    it { expect { hash.squash }.not_to change { hash } }
+
+    context 'with array value' do
+      let(:hash) { { a: { b: [1, { x: 3, y: { z: 4 } }] } } }
+
+      it 'flattens the hash' do
+        expect(hash.squash).to eq('a.b' => [1, { x: 3, y: { z: 4 } }])
+      end
+    end
+  end
+
+  describe :sort_keys do
+    it 'sorts keys as symbols' do
+      expect({ b: 1, a: 2 }.sort_keys).to eq(a: 2, b: 1)
+    end
+    it 'sorts keys as string' do
+      expect({ 'b' => 1, 'a' => 2 }.sort_keys).to eq('a' => 2, 'b' => 1)
+    end
+    it 'sorts keys recursively' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys).to eq(a: { c: 4, d: 3 }, b: 1)
+    end
+    it 'sorts keys recursively when argumen is passed' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys(recursive: true)).to eq(a: { c: 4, d: 3 }, b: 1)
+    end
+    it 'does not sorts keys recursively when argumen is passed' do
+      expect({ b: 1, a: { d: 3, c: 4 } }.sort_keys(recursive: false)).to eq(a: { d: 3, c: 4 }, b: 1)
+    end
+    it 'sort recursevely on many levels' do
+      hash = { b: 1, a: { d: 2, c: { e: 3, f: 4 } } }
+      expected = { a: { c: { f: 4, e: 3 }, d: 2 }, b: 1 }
+      expect(hash.sort_keys(recursive: true)).to eq(expected)
+    end
+    it 'applies to arrays as well' do
+      hash = { b: 1, a: { d: 2, c: [{ e: 3, f: 4 }] } }
+      expected = { a: { c: [{ f: 4, e: 3 }], d: 2 }, b: 1 }
+      expect(hash.sort_keys(recursive: true)).to eq(expected)
+    end
+  end
+
+  describe :exclusive_merge do
+    let(:subject) { { a: 1, b: 2 } }
+    let(:other) { { b: 3, c: 4 } }
+
+    it 'merge only the common keys' do
+      expect(subject.exclusive_merge(other)).to eq(a: 1, b: 3)
+    end
+
+    it 'does not change the original hash' do
+      expect { subject.exclusive_merge(other) }.not_to change { subject }
+    end
+  end
+
+  describe :exclusive_merge! do
+    let(:subject) { { a: 1, b: 2 } }
+    let(:other) { { b: 3, c: 4 } }
+
+    it 'merge only the common keys' do
+      expect(subject.exclusive_merge!(other)).to eq(a: 1, b: 3)
+    end
+
+    it 'does not change the original hash' do
+      expect { subject.exclusive_merge!(other) }.to change { subject }
+    end
+  end
+
+  describe :to_deep_hash do
+    let(:subject) do
+      {
+        'person.name' => 'Some name',
+        'person.age' => 22,
+        'status' => :success,
+        'vehicle.fuel' => 'GASOLINE',
+        'vehicle.doors' => 4
+      }
+    end
+
+    let(:expected) do
+      {
+        'person' => { 'name' => 'Some name', 'age' => 22 },
+        'vehicle' => { 'fuel' => 'GASOLINE', 'doors' => 4 },
+        'status' => :success
+      }
+    end
+
+    it 'build a deep hash' do
+      expect(subject.to_deep_hash).to eq(expected)
+    end
+
+    context 'with indexed keys' do
+      let(:subject) 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(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash' do
+      let(:subject) 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(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with a n level hash and arrays' do
+      let(:subject) 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(subject.to_deep_hash).to eq(expected)
+      end
+    end
+
+    context 'with custom separator' do
+      let(:subject) do
+        {
+          'person_name' => 'Some name',
+          'person_age' => 22,
+          'status' => :success,
+          'vehicle_fuel' => 'GASOLINE',
+          'vehicle_doors' => 4
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash('_')).to eq(expected)
+      end
+    end
+
+    context 'with custom separator on n level deep hash' do
+      let(:subject) do
+        {
+          'person_name_clazz' => String
+        }
+      end
+
+      let(:expected) do
+        {
+          'person' => {
+            'name' => { 'clazz' => String }
+          }
+        }
+      end
+
+      it 'build a deep hash with arrays' do
+        expect(subject.to_deep_hash('_')).to eq(expected)
+      end
+    end
+  end
+
+  describe '#map_and_find' do
+    let(:hash) { { a: 1, b: 2, c: 3, d: 4 } }
+    let(:value) { hash.map_and_find(&block) }
+
+    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
+
+    context 'when block returns a true evaluated value' do
+      let(:block) { proc { |_, v| v.to_s } }
+
+      it { expect(value).to eq('1') }
+
+      context 'when block returns the key and not the value' do
+        let(:block) { proc { |k, v| v > 1 && k } }
+
+        it { expect(value).to eq(:b) }
+      end
+
+      context 'but not for the first value' do
+        let(:transformer) { double(:transformer) }
+        let(:block) { proc { |_, v| transformer.transform(v) } }
+
+        before do
+          allow(transformer).to receive(:transform) do |v|
+            v.to_s if v > 1
+          end
+          value
+        end
+
+        it { expect(value).to eq('2') }
+        it 'calls the mapping only until it returns a valid value' do
+          expect(transformer).to have_received(:transform).exactly(2)
+        end
+      end
+    end
+
+    context 'when the block accepts one argument' do
+      let(:block) { proc { |v| v } }
+
+      it do
+        expect(value).to eq([:a, 1])
+      end
+    end
+  end
+
+  describe '#map_and_select' do
+    let(:hash) { { a: 1, b: 2, c: 3, d: 4 } }
+    let(:list) { hash.map_and_select(&block) }
+
+    context 'when block returns nil' do
+      let(:block) { proc {} }
+      it { expect(list).to be_empty }
+    end
+
+    context 'when block returns false' do
+      let(:block) { proc { false } }
+      it { expect(list).to be_empty }
+    end
+
+    context 'when block returns a true evaluated value' do
+      let(:block) { proc { |_, v| v.to_s } }
+
+      it { expect(list).to eq((1..4).map(&:to_s)) }
+
+      context 'when block returns the key and not the value' do
+        let(:block) { proc { |k, v| v > 1 && k } }
+
+        it { expect(list).to eq([:b, :c, :d]) }
+      end
+
+      context 'but not for the first value' do
+        let(:transformer) { double(:transformer) }
+        let(:block) { proc { |_, v| transformer.transform(v) } }
+
+        before do
+          allow(transformer).to receive(:transform) do |v|
+            v.to_s if v > 1
+          end
+          list
+        end
+
+        it { expect(list).to eq(hash.values[1..-1].map(&:to_s)) }
+        it 'calls the mapping only once for each value' do
+          expect(transformer).to have_received(:transform).exactly(4)
+        end
+      end
+    end
+
+    context 'when the block accepts one argument' do
+      let(:block) { proc { |v| v } }
+
+      it do
+        expect(list).to eq([[:a, 1], [:b, 2], [:c, 3], [:d, 4]])
+      end
+    end
+  end
+end