darthjee-core_ext 1.7.4 → 3.0.0

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
@@ -20,13 +21,14 @@ describe Hash do
       end
     end
 
-    describe '#exclusive_merge' 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
-        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' } }
-
-    let(:new_hash) do
-      hash.map_to_hash do |key, value|
-        "#{key}->#{value.size}"
+  describe '#squash' do
+    describe 'Simple Usage' do
+      subject(:hash) do
+        { name: { first: 'John', 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'
-      )
+      it 'squash the hash into a one level hash' do
+        expect(hash.squash)
+          .to eq('name.first' => 'John', 'name.last' => 'Doe')
+      end
     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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Hash::Transposeable do
+  describe 'yard' do
+    subject(:hash) do
+      {
+        key1: :value1,
+        key2: :value2
+      }
+    end
+
+    describe '#transpose' do
+      it 'transpose rows and keys' do
+        expect(hash.transpose).to eq(
+          value1: :key1,
+          value2: :key2
+        )
+      end
+
+      it do
+        expect { hash.transpose }.not_to(change { hash })
+      end
+    end
+
+    describe '#transpose!' do
+      it 'transpose rows and keys' do
+        expect { hash.transpose! }.to change { hash }
+          .to(
+            value1: :key1,
+            value2: :key2
+          )
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Darthjee::CoreExt::Hash::ValueChanger do
   describe 'yard' do
-    subject(:changer) { described_class.new(options, &block) }
+    subject(:changer) { described_class.new(**options, &block) }
 
     describe '#initialize' do
       let(:options) { { recursive: false, skip_inner: false } }

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

@@ -22,13 +22,15 @@ describe Hash do
       context 'when key is not found' do
         context 'when no block is given' do
           it do
-            expect { hash.chain_fetch(:a, :c, :d) }.to raise_error(KeyError)
+            expect { hash.chain_fetch(:a, :c, :d) }
+              .to raise_error(KeyError)
           end
         end
 
         context 'when a block is given' do
           it do
-            expect { hash.chain_fetch(:a, :c, :d) { 10 } }.not_to raise_error
+            expect { hash.chain_fetch(:a, :c, :d) { 10 } }
+              .not_to raise_error
           end
 
           it 'returns the result of the block' do
@@ -37,6 +39,15 @@ describe Hash do
           end
         end
       end
+
+      describe '#append_to_keys' do
+        let(:hash) { { :a => 1, 'b' => 2 } }
+
+        it 'appends string to keys' do
+          expect(hash.prepend_to_keys('foo_'))
+            .to eq(:foo_a => 1, 'foo_b' => 2)
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Math do
+  describe 'yard' do
+    describe '.average' do
+      describe 'Average of array' do
+        let(:values) { [1, 2, 3, 4] }
+
+        it 'calculates the average' do
+          expect(Math.average(values)).to eq(2.5)
+        end
+      end
+
+      describe 'Average of hash' do
+        let(:values) do
+          {
+            1 => 3,
+            7 => 1
+          }
+        end
+
+        it 'calculates the average' do
+          expect(Math.average(values)).to eq(2.5)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Numeric do
+  describe 'yard' do
+    describe '#percent_of' do
+      it 'calculates the percentage over total' do
+        expect(10.percent_of(30)).to eq(33.33333333333333)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Object do
+  describe 'yard' do
+    describe '#is_any?' do
+      subject(:object) { [1, 2, 3] }
+
+      context 'when none match' do
+        it do
+          expect(object).not_to be_is_any(Hash, Class)
+        end
+      end
+
+      context 'when at least one of them matches' do
+        it do
+          expect(object).to be_is_any(Hash, Array)
+        end
+      end
+
+      context 'when a module matches' do
+        it do
+          expect(object).to be_is_any(Enumerable, Class)
+        end
+      end
+    end
+
+    # rubocop: disable RSpec/PredicateMatcher
+    describe '#trueful?' do
+      describe 'Calling on nil object' do
+        it { expect(nil.trueful?).not_to be_truthy }
+      end
+
+      describe 'Calling on empty array' do
+        it { expect([].trueful?).to be_truthy }
+      end
+
+      describe 'Calling on empty hash' do
+        it { expect({}.trueful?).to be_truthy }
+      end
+
+      describe 'Calling on empty string' do
+        it { expect(''.trueful?).to be_truthy }
+      end
+    end
+    # rubocop: enable RSpec/PredicateMatcher
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+describe Darthjee::CoreExt::Symbol do
+  describe 'yard' do
+    describe '#camelize' do
+      it 'camelizes symbol' do
+        expect(:the_symbol.camelize).to eq(:TheSymbol)
+      end
+    end
+
+    describe '#underscore' do
+      it 'underscores symbol' do
+        expect(:theSymbol.underscore).to eq(:the_symbol)
+      end
+    end
+  end
+end

data/spec/lib/array_spec.rb

@@ -201,6 +201,7 @@ describe Array do
         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
@@ -267,7 +268,7 @@ describe Array do
           filtered
         end
 
-        it { expect(filtered).to eq(array[1..-1].map(&:to_s)) }
+        it { expect(filtered).to eq(array[1..].map(&:to_s)) }
 
         it 'calls the mapping only once per element' do
           expect(transformer).to have_received(:transform).exactly(4)

data/spec/lib/darthjee/core_ext/hash/deep_hash_constructor/setter_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darthjee::CoreExt::Hash::DeepHashConstructor::Setter do
+  subject(:setter) { described_class.new(hash, base_key) }
+
+  let(:hash)  { {} }
+  let(:value) { 21 }
+
+  describe '#set' do
+    context 'when base_key does not have index' do
+      let(:base_key) { 'person' }
+
+      context 'when key is nil' do
+        let(:key) { nil }
+
+        it 'set value on base key' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to(base_key => value)
+        end
+      end
+
+      context 'when key is present' do
+        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
+    end
+
+    context 'when base_key has index' do
+      let(:base_key) { 'person[0]' }
+
+      context 'when key is nil' do
+        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
+
+      context 'when key is present' do
+        let(:key) { 'age' }
+
+        it 'set value on inner hash inside array' do
+          expect { setter.set(key, value) }
+            .to change { hash }
+            .from({})
+            .to('person' => [{ key => value }])
+        end
+      end
+    end
+  end
+end