darthjee-core_ext 1.7.4 → 3.0.0

data/spec/integration/readme/hash_spec.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# frozen_string_literal: true
+
+describe Hash do
+  describe 'readme' do
+    describe '#chain_fetch' do
+      subject(:hash) { { a: { b: { c: { d: 10 } } } } }
+
+      it 'fetches value from hashes' do
+        expect(hash.chain_fetch(:a, :b, :c, :d)).to eq(10)
+      end
+
+      context 'when passing a block' do
+        let(:value) do
+          hash.chain_fetch(:a, :x, :y, :z) do |key, missed_keys|
+            "returned: #{key}\nmissed: [#{missed_keys.join(',')}]"
+          end
+        end
+
+        it 'return processing of the missed keys' do
+          expect(value).to eq("returned: x\nmissed: [y,z]")
+        end
+      end
+    end
+
+    describe '#change_values' do
+      subject(:hash) { { a: 1, b: [{ c: 2 }] } }
+
+      it 'changes the values of the hash' do
+        expect(hash.change_values { |v| (v + 1).to_s })
+          .to eq(a: '2', b: [{ c: '3' }])
+      end
+
+      context 'when setting recursive to false' do
+        it 'changes the values of the hash' do
+          expect(hash.change_values(recursive: false) { |v| (v + 1).to_s })
+            .to eq(a: '2', b: [{ c: 2 }])
+        end
+      end
+
+      context 'when skipping inner hash' do
+        subject(:hash) { { a: 1, b: [{ c: 2 }], d: { e: 3 } } }
+
+        let(:result) do
+          hash.change_values(skip_inner: false) do |value|
+            case value
+            when Integer
+              (value + 1).to_s
+            when described_class
+              value.to_s
+            else
+              value.class
+            end
+          end
+        end
+
+        it 'changes the values skipping inner' do
+          expect(result).to eq(a: '2', b: Array, d: '{:e=>3}')
+        end
+      end
+    end
+
+    describe '#change_values!' do
+      subject(:hash) { { a: 1, b: [{ c: 2 }] } }
+
+      it 'changes the values of the hash' do
+        expect { hash.change_values! { |v| (v + 1).to_s } }
+          .to change { hash }
+          .to(a: '2', b: [{ c: '3' }])
+      end
+
+      context 'when setting recursive to false' do
+        it 'changes the values of the hash' do
+          expect do
+            hash.change_values!(recursive: false) { |v| (v + 1).to_s }
+          end
+            .to change { hash }
+            .to(a: '2', b: [{ c: 2 }])
+        end
+      end
+
+      context 'when skipping inner hash' do
+        subject(:hash) { { a: 1, b: [{ c: 2 }], d: { e: 3 } } }
+
+        let(:result) do
+          hash.change_values!(skip_inner: false) do |value|
+            case value
+            when Integer
+              (value + 1).to_s
+            when described_class
+              value.to_s
+            else
+              value.class
+            end
+          end
+        end
+
+        it 'changes the values skipping inner' do
+          expect { result }
+            .to change { hash }
+            .to(a: '2', b: Array, d: '{:e=>3}')
+        end
+      end
+    end
+
+    describe '#camelize_keys' do
+      subject(:hash) { { ca_b: 1, k: [{ a_b: 1 }] } }
+
+      it 'camelize all keys' do
+        expect(hash.camelize_keys)
+          .to eq(CaB: 1, K: [{ AB: 1 }])
+      end
+
+      context 'when passing recursive false' do
+        it 'camelize all keys without recursion' do
+          expect(hash.camelize_keys(recursive: false))
+            .to eq(CaB: 1, K: [{ a_b: 1 }])
+        end
+      end
+
+      context 'when not upcasing first letter' do
+        it 'camelize all keys' do
+          expect(hash.camelize_keys(uppercase_first_letter: false))
+            .to eq(caB: 1, k: [{ aB: 1 }])
+        end
+      end
+    end
+
+    describe '#camelize_keys!' do
+      subject(:hash) { { ca_b: 1, k: [{ a_b: 1 }] } }
+
+      it 'camelize all keys' do
+        expect { hash.camelize_keys! }
+          .to change { hash }
+          .to(CaB: 1, K: [{ AB: 1 }])
+      end
+
+      context 'when passing recursive false' do
+        it 'camelize all keys without recursion' do
+          expect { hash.camelize_keys!(recursive: false) }
+            .to change { hash }
+            .to(CaB: 1, K: [{ a_b: 1 }])
+        end
+      end
+
+      context 'when not upcasing first letter' do
+        it 'camelize all keys' do
+          expect { hash.camelize_keys!(uppercase_first_letter: false) }
+            .to change { hash }
+            .to(caB: 1, k: [{ aB: 1 }])
+        end
+      end
+    end
+
+    describe '#lower_camelize_keys' do
+      subject(:hash) { { ca_b: 1, k: [{ a_b: 1 }] } }
+
+      it 'camelize with lower case' do
+        expect(hash.lower_camelize_keys)
+          .to eq(caB: 1, k: [{ aB: 1 }])
+      end
+    end
+
+    describe '#lower_camelize_keys!' do
+      subject(:hash) { { ca_b: 1, k: [{ a_b: 1 }] } }
+
+      it 'underscores keys' do
+        expect { hash.lower_camelize_keys! }
+          .to change { hash }
+          .to(caB: 1, k: [{ aB: 1 }])
+      end
+    end
+
+    describe '#undescore_keys' do
+      subject(:hash) { { Ca_B: 1, 'kB' => [{ KeysHash: 1 }] } }
+
+      it 'underscores keys' do
+        expect(hash.underscore_keys)
+          .to eq(ca_b: 1, 'k_b' => [{ keys_hash: 1 }])
+      end
+    end
+
+    describe '#undescore_keys!' do
+      subject(:hash) { { Ca_B: 1, 'kB' => [{ KeysHash: 1 }] } }
+
+      it 'camelize with lower case' do
+        expect { hash.underscore_keys! }.to change { hash }
+          .to(ca_b: 1, 'k_b' => [{ keys_hash: 1 }])
+      end
+    end
+
+    describe '#chain_change_keys' do
+      subject(:hash) { { ca_b: 1 } }
+
+      it 'changes the keys in order' do
+        expect(hash.chain_change_keys(:to_s, :upcase, :to_sym))
+          .to eq(CA_B: 1)
+      end
+    end
+
+    describe '#chain_change_keys!' do
+      subject(:hash) { { ca_b: 1 } }
+
+      it 'changes the keys in order' do
+        expect do
+          hash.chain_change_keys!(:to_s, :upcase, :to_sym)
+        end
+          .to change { hash }
+          .to(CA_B: 1)
+      end
+    end
+
+    describe '#change_keys' do
+      subject(:hash) do
+        { ca_b: 1, k: [{ a_b: 1 }] }
+      end
+
+      it 'changes keys' do
+        expect(hash.change_keys { |k| k.to_s.upcase })
+          .to eq('CA_B' => 1, 'K' => [{ 'A_B' => 1 }])
+      end
+
+      context 'when passing recursive option false' do
+        it 'changes keys not recursively' do
+          expect(hash.change_keys(recursive: false) { |k| k.to_s.upcase })
+            .to eq('CA_B' => 1, 'K' => [{ a_b: 1 }])
+        end
+      end
+    end
+
+    describe '#change_keys!' do
+      subject(:hash) do
+        { ca_b: 1, k: [{ a_b: 1 }] }
+      end
+
+      it 'changes keys' do
+        expect { hash.change_keys! { |k| k.to_s.upcase } }
+          .to change { hash }
+          .to('CA_B' => 1, 'K' => [{ 'A_B' => 1 }])
+      end
+
+      context 'when passing recursive option false' do
+        it 'changes keys not recursively' do
+          expect do
+            hash.change_keys!(recursive: false) { |k| k.to_s.upcase }
+          end
+            .to change { hash }
+            .to('CA_B' => 1, 'K' => [{ a_b: 1 }])
+        end
+      end
+    end
+
+    describe 'prepend_to_keys' do
+      subject(:hash) { { key: 1 } }
+
+      it 'prepends string to keys' do
+        expect(hash.prepend_to_keys('scope:'))
+          .to eq('scope:key': 1)
+      end
+    end
+
+    describe 'append_to_keys' do
+      subject(:hash) { { key: 1 } }
+
+      it 'prepends string to keys' do
+        expect(hash.append_to_keys('s'))
+          .to eq(keys: 1)
+      end
+    end
+
+    describe 'map_to_hash' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'mapscreating hash' do
+        expect(hash.map_to_hash { |k, v| "#{k}_#{v}" })
+          .to eq(a: 'a_1', b: 'b_2')
+      end
+    end
+
+    describe '#remap_keys' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'remap the keys' do
+        expect(hash.remap_keys(a: :c, d: :e))
+          .to eq(c: 1, b: 2, e: nil)
+      end
+    end
+
+    describe '#remap_keys!' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'remap the keys' do
+        expect { hash.remap_keys!(a: :c, d: :e) }
+          .to change { hash }
+          .to(c: 1, b: 2, e: nil)
+      end
+    end
+
+    describe 'exclusive_merge' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'merges exclusively' do
+        expect(hash.exclusive_merge(b: 3, c: 4))
+          .to eq(a: 1, b: 3)
+      end
+    end
+
+    describe 'exclusive_merge!' do
+      subject(:hash) { { a: 1, b: 2 } }
+
+      it 'merges exclusively' do
+        expect { hash.exclusive_merge!(b: 3, c: 4) }
+          .to change { hash }
+          .to(a: 1, b: 3)
+      end
+    end
+
+    describe '#squash' do
+      subject(:hash) { { a: { b: [1, 2] } } }
+
+      it 'squash keys' do
+        expect(hash.squash)
+          .to eq('a.b[0]' => 1, 'a.b[1]' => 2)
+      end
+    end
+
+    describe '#squash!' do
+      subject(:hash) { { a: { b: [1, 2] } } }
+
+      it 'squash keys' do
+        expect { hash.squash! }.to change { hash }
+          .to('a.b[0]' => 1, 'a.b[1]' => 2)
+      end
+    end
+
+    describe '#to_deep_hash' do
+      subject(:hash) { { 'a.b[0]' => 1, 'a.b[1]' => 2 } }
+
+      it 'builds hash' do
+        expect(hash.to_deep_hash)
+          .to eq('a' => { 'b' => [1, 2] })
+      end
+    end
+
+    describe '#to_deep_hash!' do
+      subject(:hash) { { 'a.b[0]' => 1, 'a.b[1]' => 2 } }
+
+      it 'builds hash' do
+        expect { hash.to_deep_hash! }.to change { hash }
+          .to('a' => { 'b' => [1, 2] })
+      end
+    end
+
+    describe '#sort_keys' do
+      subject(:hash) { { b: 1, a: 2 } }
+
+      it 'sort hash keys' do
+        expect(hash.sort_keys.keys)
+          .to eq(%i[a b])
+      end
+
+      it 'does not change the original hash' do
+        expect { hash.sort_keys }
+          .not_to change(hash, :keys)
+      end
+    end
+
+    describe '#sort_keys!' do
+      subject(:hash) { { b: 1, a: 2 } }
+
+      it 'sort hash keys' do
+        expect { hash.sort_keys! }
+          .to change(hash, :keys)
+          .to(%i[a b])
+      end
+    end
+
+    describe '#transpose' do
+      subject(:hash) { { a: 1, b: :a, c: [2, 3] } }
+
+      it 'transpose keys and values' do
+        expect(hash.transpose)
+          .to eq(1 => :a, a: :b, [2, 3] => :c)
+      end
+    end
+
+    describe '#transpose!' do
+      subject(:hash) { { a: 1, b: :a, c: [2, 3] } }
+
+      it 'transpose keys and values' do
+        expect { hash.transpose! }
+          .to change { hash }
+          .to(1 => :a, a: :b, [2, 3] => :c)
+      end
+    end
+  end
+end

data/spec/integration/readme/math_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Math do
+  describe 'readme' do
+    describe '.average' do
+      let(:values) { [0, 1, 2, 3, 4, 5] }
+
+      it 'calculates average' do
+        expect(described_class.average(values)).to eq(2.5)
+      end
+
+      context 'when giving a map' do
+        let(:values) do
+          {
+            0 => 1,
+            1 => 2,
+            2 => 3,
+            3 => 4,
+            4 => 5
+          }
+        end
+
+        it 'calculates average' do
+          expect(described_class.average(values)).to eq(2.6666666666666666)
+        end
+      end
+    end
+  end
+end

data/spec/integration/readme/object_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Object do
+  describe 'readme' do
+    # rubocop: disable RSpec/PredicateMatcher
+    describe '#is_any' do
+      context 'when is one of the classes' do
+        it do
+          expect(1.is_any?(String, Symbol, Numeric)).to be_truthy
+        end
+      end
+
+      context 'when is none of the classes' do
+        it do
+          expect(1.is_any?(String, Symbol)).to be_falsey
+        end
+      end
+    end
+
+    describe '#trueful?' do
+      context 'when it is a regular object' do
+        it { expect(described_class.new.trueful?).to be_truthy }
+      end
+
+      context 'when it is an empty string' do
+        it { expect(''.trueful?).to be_truthy }
+      end
+
+      context 'when it is an empty hash' do
+        it { expect({}.trueful?).to be_truthy }
+      end
+
+      context 'when it is an empty array' do
+        it { expect([].trueful?).to be_truthy }
+      end
+
+      context 'when it is 0' do
+        it { expect(0.trueful?).to be_truthy }
+      end
+
+      context 'when it is nil' do
+        it { expect(nil.trueful?).to be_falsey }
+      end
+    end
+    # rubocop: enable RSpec/PredicateMatcher
+  end
+end

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/array_spec.rb

@@ -20,7 +20,7 @@ describe Array do
       let(:array) { [{ a: { b: 1 }, b: 2 }, { a: { b: 3 }, b: 4 }] }
 
       describe 'when passing just the first key' do
-        it 'returns the array mapped ' do
+        it 'returns the array mapped' do
           expect(array.mapk(:a)).to eq([{ b: 1 }, { b: 3 }])
         end
       end

data/spec/integration/yard/darthjee/core_ext/class/default_value_spec.rb

@@ -19,8 +19,8 @@ describe Class do
         end
 
         it 'returns the same instance accros instances of the class' do
-          expect(instance.name).not_to be_equal('John')
-          expect(instance.name).to be_equal(klass.new.name)
+          expect(instance.name).not_to equal('John')
+          expect(instance.name).to equal(klass.new.name)
         end
       end
     end
@@ -42,13 +42,13 @@ describe Class do
         end
 
         it 'returns the same instance accros instances of the class' do
-          expect(instance.name).not_to be_equal('John')
-          expect(instance.name).to be_equal(klass.new.name)
+          expect(instance.name).not_to equal('John')
+          expect(instance.name).to equal(klass.new.name)
         end
 
         it 'returns the same instance for all methods' do
-          expect(instance.nick_name).not_to be_equal('John')
-          expect(instance.name).to be_equal(instance.nick_name)
+          expect(instance.nick_name).not_to equal('John')
+          expect(instance.name).to equal(instance.nick_name)
         end
       end
     end
@@ -57,6 +57,7 @@ describe Class do
       let(:klass) do
         Class.new do
           attr_writer :name
+
           default_reader :name, 'John Doe'
         end
       end
@@ -96,6 +97,7 @@ describe Class do
       let(:klass) do
         Class.new do
           attr_writer :cars, :houses
+
           default_readers :cars, :houses, 'none'
         end
       end
@@ -134,8 +136,8 @@ describe Class do
         end
 
         it 'returns the same instance for all methods' do
-          expect(instance.cars).not_to be_equal('none')
-          expect(instance.cars).to be_equal(instance.houses)
+          expect(instance.cars).not_to equal('none')
+          expect(instance.cars).to equal(instance.houses)
         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