darthjee-core_ext 1.7.4 → 2.0.0

data/spec/integration/readme/symbol_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+describe Symbol do
+  describe 'readme' do
+    describe '#camelize' do
+      it 'camelizes symbol' do
+        expect(:underscore_sym.camelize(:upper))
+          .to eq(:UnderscoreSym)
+      end
+
+      it 'camelizes symbol lowercasing first letter' do
+        expect(:underscore_sym.camelize(:lower))
+          .to eq(:underscoreSym)
+      end
+
+      it 'camelizes uppercasing first letter' do
+        expect(:underscore_sym.camelize)
+          .to eq(:UnderscoreSym)
+      end
+    end
+
+    describe '#underscore' do
+      it 'underscore symbols' do
+        expect(:symBol.underscore)
+          .to eq(:sym_bol)
+      end
+    end
+  end
+end

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

@@ -73,11 +73,31 @@ describe Enumerable do
     end
 
     describe 'map_to_hash' do
-      subject(:strings) { %w[word big_word] }
+      describe 'Mapping strings to their sizes' do
+        subject(:strings) { %w[word big_word] }
 
-      it 'returns a hash with the mapped values' do
-        hash = strings.map_to_hash(&:size)
-        expect(hash).to eq('word' => 4, 'big_word' => 8)
+        it 'returns a hash with the mapped values' do
+          hash = strings.map_to_hash(&:size)
+          expect(hash).to eq('word' => 4, 'big_word' => 8)
+        end
+      end
+
+      describe 'Mapping a hash' do
+        subject(:hash) { { a: 'word', b: 'bigword', c: 'c' } }
+
+        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',
+            c: 'c->1'
+          )
+        end
       end
     end
   end

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

@@ -31,4 +31,15 @@ describe Darthjee::CoreExt::Hash::Cameliazable do
       expect(result).to eq(firstKey: 1, 'secondKey' => 2)
     end
   end
+
+  describe '#underscore_keys' do
+    subject(:hash) do
+      { firstKey: 1, 'SecondKey' => 2 }
+    end
+
+    it 'camelize all keys' do
+      result = hash.underscore_keys
+      expect(result).to eq(first_key: 1, 'second_key' => 2)
+    end
+  end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::Changeable do
+  describe '#change_values' do
+    describe 'Simple usage' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'changes the values' do
+        expect(hash.change_values { |value| value + 1 })
+          .to eq(a: 2, b: 3)
+      end
+    end
+
+    describe 'Skipping inner hash transformation' do
+      subject(:hash) { { a: 1, b: { c: 1 } } }
+
+      it 'changes the values' do
+        expect(hash.change_values(&:to_s))
+          .to eq(a: '1', b: { c: '1' })
+      end
+    end
+
+    describe 'Not skipping inner hash transformation' do
+      subject(:hash) { { a: 1, b: { c: 1 } } }
+
+      it 'changes the values' do
+        expect(hash.change_values(skip_inner: false, &:to_s))
+          .to eq(a: '1', b: '{:c=>1}')
+      end
+    end
+  end
+
+  describe '#change_values!' do
+    subject(:hash) { { a: 1, b: inner_hash } }
+
+    let(:inner_hash) { { c: 2 } }
+
+    describe 'Changing inner hash' do
+      it 'changes the original hash' do
+        expect { hash.change_values!(&:to_s) }
+          .to change { hash }
+          .from(a: 1, b: { c: 2 })
+          .to(a: '1', b: { c: '2' })
+      end
+
+      it 'changes the inner hash' do
+        expect { hash.change_values!(&:to_s) }
+          .to change { inner_hash }
+          .from(c: 2)
+          .to(c: '2')
+      end
+    end
+
+    describe 'Not changing inner hash' do
+      it 'changes the original hash' do
+        expect { hash.change_values!(skip_inner: false, &:to_s) }
+          .to change { hash }
+          .from(a: 1, b: { c: 2 })
+          .to(a: '1', b: '{:c=>2}')
+      end
+
+      it 'changes the inner hash' do
+        expect { hash.change_values!(skip_inner: false, &:to_s) }
+          .not_to(change { inner_hash })
+      end
+    end
+  end
+end

data/spec/integration/yard/darthjee/core_ext/hash/deep_hash_constructor/setter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::DeepHashConstructor::Setter do
+  subject(:setter) { described_class.new(hash, base_key) }
+
+  let(:hash)  { {} }
+  let(:value) { 21 }
+
+  describe 'yard' do
+    describe 'Simple usage' do
+      let(:base_key) { 'person' }
+      let(:key)      { 'age' }
+
+      it 'set value on inner hash' do
+        expect { setter.set(key, value) }
+          .to change { hash }
+          .from({})
+          .to(base_key => { key => value })
+      end
+    end
+
+    describe 'with array index' do
+      let(:base_key) { 'person[0]' }
+      let(:key)      { nil }
+
+      it 'set value on base key array' do
+        expect { setter.set(key, value) }
+          .to change { hash }
+          .from({})
+          .to('person' => [value])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::DeepHashConstructor do
+  describe 'yard' do
+    subject(:constructor) { described_class.new('.') }
+
+    let(:hash) do
+      {
+        'account.person.name[0]' => 'John',
+        'account.person.name[1]' => 'Wick',
+        'account.person.age'     =>  20,
+        'account.number'         => '102030',
+        :'house.number'          => 67,
+        :'house.zip'             => 12_345
+      }
+    end
+
+    describe 'general usage' do
+      let(:expected) do
+        {
+          'account' => {
+            'person' => {
+              'name'   => %w[John Wick],
+              'age'    =>  20
+            },
+            'number' => '102030'
+          },
+          'house' => {
+            'number' => 67,
+            'zip'    => 12_345
+          }
+        }
+      end
+
+      it 'builds deep hash' do
+        expect(constructor.deep_hash(hash))
+          .to eq(expected)
+      end
+    end
+
+    describe '#break_keys' do
+      let(:expected) do
+        {
+          'account' => {
+            %w[person name[0]] => 'John',
+            %w[person name[1]] => 'Wick',
+            %w[person age]     =>  20,
+            %w[number]         => '102030'
+          },
+          'house' => {
+            %w[number] => 67,
+            %w[zip]    => 12_345
+          }
+        }
+      end
+
+      it 'builds deep hash' do
+        expect(constructor.send(:break_keys, hash))
+          .to eq(expected)
+      end
+    end
+  end
+end

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

@@ -45,4 +45,12 @@ describe Darthjee::CoreExt::Hash::KeyChangeable do
       expect(result).to eq('5': 1, '6': 2)
     end
   end
+
+  describe '#sort_keys' do
+    subject(:hash) { { b: 1, a: 2 } }
+
+    it 'sorts he keys' do
+      expect(hash.sort_keys).to eq(a: 2, b: 1)
+    end
+  end
 end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::KeyChanger do
+  describe 'yard' do
+    subject(:changer) { described_class.new(hash) }
+
+    describe '#remap' do
+      let(:hash) { { a: 1, 'b' => 2 } }
+
+      let(:remap_map) { { a: :za, b: :zb, 'b' => 'yb' } }
+
+      it 'changes keys using the map' do
+        expect { changer.remap(remap_map) }
+          .to change { hash }.to(za: 1, 'yb' => 2, zb: nil)
+      end
+    end
+
+    describe '#change_keys' do
+      let(:hash) { { a: 1, 'b' => { c: 3 } } }
+      let(:expected) do
+        { 'key_a' => 1, 'key_b' => { 'key_c' => 3 } }
+      end
+
+      it 'changes keys using block' do
+        expect { changer.change_keys { |k| "key_#{k}" } }
+          .to change { hash }.to(expected)
+      end
+    end
+
+    describe '#camelize_keys' do
+      let(:hash) { { my_key: { inner_key: 10 } } }
+
+      it 'camelizes all keys' do
+        expect { changer.camelize_keys }
+          .to change { hash }.to(MyKey: { InnerKey: 10 })
+      end
+    end
+
+    describe '#underscore_keys' do
+      let(:hash) { { myKey: { InnerKey: 10 } } }
+
+      it 'camelizes all keys' do
+        expect { changer.underscore_keys }
+          .to change { hash }.to(my_key: { inner_key: 10 })
+      end
+    end
+
+    describe '#change_text' do
+      let(:hash) { { key: { inner_key: 10 } } }
+
+      it 'changes the text of the keys' do
+        expect { changer.change_text { |key| key.to_s.upcase } }
+          .to change { hash }.to(KEY: { INNER_KEY: 10 })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::KeysSorter do
+  subject(:sorter) { described_class.new(hash) }
+
+  describe 'yard' do
+    describe 'Simple Usage' do
+      let(:hash) { { key: 10, a_key: { z: 5, a: 10 } } }
+
+      it 'sorts the keys' do
+        expect(sorter.sort)
+          .to eq(a_key: { a: 10, z: 5 }, key: 10)
+      end
+
+      it 'changes the original hash' do
+        expect { sorter.sort }
+          .to change(hash, :keys)
+          .from(%i[key a_key])
+          .to(%i[a_key key])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::Squasher do
+  subject(:squasher) { described_class.new }
+
+  describe '#squash' do
+    describe 'Simple Usage' do
+      let(:hash) do
+        {
+          person: [{
+            name: %w[John Wick],
+            age: 22
+          }, {
+            name: %w[John Constantine],
+            age: 25
+          }]
+        }
+      end
+
+      let(:expected) do
+        {
+          'person[0].name[0]' => 'John',
+          'person[0].name[1]' => 'Wick',
+          'person[0].age'     => 22,
+          'person[1].name[0]' => 'John',
+          'person[1].name[1]' => 'Constantine',
+          'person[1].age'     => 25
+        }
+      end
+
+      it 'squashes the hash' do
+        expect(squasher.squash(hash)).to eq(expected)
+      end
+    end
+
+    describe 'Passing custom joiner' do
+      subject(:squasher) { described_class.new('> ') }
+
+      let(:hash) do
+        {
+          person: {
+            name: 'John',
+            age: 22
+          }
+        }
+      end
+
+      let(:expected) do
+        {
+          'person> name' => 'John',
+          'person> age'  => 22
+        }
+      end
+
+      it 'squashes the hash' do
+        expect(squasher.squash(hash)).to eq(expected)
+      end
+    end
+  end
+end

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

@@ -10,7 +10,8 @@ describe Hash do
       let(:other)    { { b: 4, 'c' => 5, e: 6 } }
 
       it 'merges only the existing keys' do
-        expect(hash.exclusive_merge(other)).to eq(a: 1, b: 4, c: 3)
+        expect(hash.exclusive_merge(other))
+          .to eq(a: 1, b: 4, c: 3)
       end
 
       it 'does not change original hash' do
@@ -26,7 +27,8 @@ describe Hash do
       let(:other)    { { b: 4, 'c' => 5, e: 6 } }
 
       it 'merges only the existing keys' do
-        expect(hash.exclusive_merge!(other)).to eq(a: 1, b: 4, c: 3)
+        expect(hash.exclusive_merge!(other))
+          .to eq(a: 1, b: 4, c: 3)
       end
 
       it 'does not change original hash' do
@@ -37,63 +39,91 @@ describe Hash do
     end
   end
 
-  describe '#map_to_hash' do
-    subject(:hash) { { a: 'word', b: 'bigword', c: 'c' } }
+  describe '#squash' do
+    describe 'Simple Usage' do
+      subject(:hash) do
+        { name: { first: 'John', last: 'Doe' } }
+      end
 
-    let(:new_hash) do
-      hash.map_to_hash do |key, value|
-        "#{key}->#{value.size}"
+      it 'squash the hash into a one level hash' do
+        expect(hash.squash)
+          .to eq('name.first' => 'John', 'name.last' => 'Doe')
       end
     end
 
-    it 'remaps the values keeping the original keys' do
-      expect(new_hash).to eq(
-        a: 'a->4',
-        b: 'b->7',
-        c: 'c->1'
-      )
-    end
-  end
-
-  describe '#squash' do
-    subject(:hash) { { name: { first: 'John', last: 'Doe' } } }
+    describe 'Reverting a #to_deep_hash call' do
+      let(:person) { person_data.to_deep_hash }
+      let(:person_data) do
+        { 'person.name' => 'John', 'person.age' => 23 }
+      end
 
-    it 'squash the hash into a one level hash' do
-      expect(hash.squash).to eq('name.first' => 'John', 'name.last' => 'Doe')
+      it 'is the reverse operation' do
+        expect(person.squash).to eq(person_data)
+      end
     end
 
-    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 }
+    describe 'Giving a custom joiner' do
+      subject(:hash) do
+        {
+          links: {
+            home: '/',
+            products: '/products'
+          }
+        }
+      end
 
-      it 'is the reverse operation' do
-        expect(person.squash).to eq(person_data)
+      it 'joins keys using custom joiner' do
+        expect(hash.squash('> ')).to eq(
+          'links> home' => '/',
+          'links> products' => '/products'
+        )
       end
     end
   end
 
   describe '#to_deep_hash' do
-    subject(:hash) { { 'name_first' => 'John', 'name_last' => 'Doe' } }
+    describe 'With custom separator' do
+      subject(:hash) do
+        {
+          'person[0]_name_first' => 'John',
+          'person[0]_name_last'  => 'Doe',
+          'person[1]_name_first' => 'John',
+          'person[1]_name_last'  => 'Wick'
+        }
+      end
 
-    it 'with custom separator' do
-      expect(hash.to_deep_hash('_')).to eq(
-        'name' => { 'first' => 'John', 'last' => 'Doe' }
-      )
+      let(:expected) do
+        {
+          'person' => [{
+            'name' => { 'first' => 'John', 'last' => 'Doe' }
+          }, {
+            'name' => { 'first' => 'John', 'last' => 'Wick' }
+          }]
+        }
+      end
+
+      it 'with custom separator' do
+        expect(hash.to_deep_hash('_')).to eq(expected)
+      end
     end
 
-    context 'when squashing the result of a deep hash' do
+    describe 'Reverting the result of a squash' do
       let(:person) do
         {
-          'person' => {
-            'name' => 'John',
-            'age' => 23
-          }
+          person: [{
+            name: %w[John Wick],
+            age: 22
+          }, {
+            name: %w[John Constantine],
+            age: 25
+          }]
         }
       end
       let(:person_data) { person.squash }
 
       it 'is the reverse operation' do
-        expect(person_data.to_deep_hash).to eq(person)
+        expect(person_data.to_deep_hash)
+          .to eq(person.deep_stringify_keys)
       end
     end
   end