darthjee-core_ext 1.5.6 → 1.6.0

data/spec/lib/hash_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Hash do
@@ -8,54 +10,22 @@ describe Hash do
   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'
-  it_behaves_like 'a hash with map_to_hash method'
   it_behaves_like 'a class with transpose methods'
 
-  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 } }
+  it_behaves_like 'an object with capable of performing chain fetch' do
+    let(:result) { hash.chain_fetch(*keys, &block) }
+  end
 
-    context 'with array value' do
-      let(:hash) { { a: { b: [1, { x: 3, y: { z: 4 } }] } } }
+  it_behaves_like 'a class that has a method to squash a hash' do
+    let(:squashed) { hash.squash }
+  end
 
-      it 'flattens the hash' do
-        expect(hash.squash).to eq('a.b' => [1, { x: 3, y: { z: 4 } }])
-      end
-    end
+  it_behaves_like 'a hash with map_to_hash method' do
+    let(:mapped) { hash.map_to_hash(&mapping_block) }
   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
+  it_behaves_like 'a class with a keys sort method' do
+    let(:result) { hash.sort_keys(**options) }
   end
 
   describe :exclusive_merge do
@@ -67,7 +37,7 @@ describe Hash do
     end
 
     it 'does not change the original hash' do
-      expect { subject.exclusive_merge(other) }.not_to change { subject }
+      expect { subject.exclusive_merge(other) }.not_to(change { subject })
     end
   end
 
@@ -80,7 +50,7 @@ describe Hash do
     end
 
     it 'does not change the original hash' do
-      expect { subject.exclusive_merge!(other) }.to change { subject }
+      expect { subject.exclusive_merge!(other) }.to(change { subject })
     end
   end
 
@@ -126,7 +96,7 @@ describe Hash do
             { 'name' => 'First person', 'age' => 22 },
             { 'name' => 'Second person', 'age' => 27 }
           ],
-          'device' => %w(GEAR_LOCK GPS),
+          'device' => %w[GEAR_LOCK GPS],
           'zipCode' => '122345-123'
         }
       end
@@ -317,7 +287,7 @@ describe Hash do
       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]) }
+        it { expect(list).to eq(%i[b c d]) }
       end
 
       context 'but not for the first value' do

data/spec/lib/math_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Math do

data/spec/lib/numeric_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Numeric do

data/spec/lib/object/default_value_spe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Object do

data/spec/lib/object_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Object do

data/spec/lib/symbol_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Symbol do

data/spec/lib/time_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Time do

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'simplecov'
 
 SimpleCov.profiles.define 'gem' do
@@ -20,7 +22,6 @@ require 'darthjee/core_ext'
 Dir['./spec/support/**/*.rb'].each { |f| require f }
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/support/models/default_value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DefaultValue
   default_value :x, 10
   default_values :y, :z, 20

data/spec/support/models/hash/value_changer/dummy.rb

@@ -1,19 +1,25 @@
-class Hash::ValueChanger::Dummy
-  attr_reader :value
+# frozen_string_literal: true
 
-  delegate :+, to: :value
+class Hash
+  class ValueChanger
+    class Dummy
+      attr_reader :value
 
-  def initialize(value)
-    @value = value
-  end
+      delegate :+, to: :value
 
-  def as_json
-    { val: value }
-  end
+      def initialize(value)
+        @value = value
+      end
+
+      def as_json
+        { val: value }
+      end
 
-  def eql?(other)
-    return true if equals?(other)
-    return false unless other.is_a?(self.class)
-    a.value == value
+      def eql?(other)
+        return true if equals?(other)
+        return false unless other.is_a?(self.class)
+        a.value == value
+      end
+    end
   end
 end

data/spec/support/models/hash/value_changer/dummy_iteractor.rb

@@ -1,12 +1,17 @@
-class Hash::ValueChanger::DummyIteractor
-  def initialize(*array)
-    @array = array
-  end
+# frozen_string_literal: true
 
-  delegate :each, :map, :to_a, to: :array
+class Hash
+  class ValueChanger
+    class DummyIteractor
+      def initialize(*array)
+        @array = array
+      end
 
-  private
+      delegate :each, :map, :to_a, to: :array
 
-  attr_reader :array
-end
+      private
 
+      attr_reader :array
+    end
+  end
+end

data/spec/support/shared_examples/{array_random.rb → array/array_random.rb}

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 shared_examples 'a method that returns a random element' do |method|
-  let(:array) { [ 7, 5, 3 ] }
+  let(:array) { [7, 5, 3] }
 
   (0..2).each do |index|
     context "when random returns #{index}" do
       let!(:expected) { array[index] }
       before do
-        allow_any_instance_of(Array).to receive(:rand).with(array.size) { index }
+        allow_any_instance_of(Array).to receive(:rand)
+          .with(array.size) { index }
       end
 
       it 'returns the randomized index of the array' do

data/spec/support/shared_examples/clean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'a hash clean method' do |method|
   context 'when hash has one level' do
     let(:subject) do
@@ -29,7 +31,11 @@ shared_examples 'a hash clean method' do |method|
 
   context 'when hash has many levels' do
     let(:subject) do
-      { a: 1, d: { e: { k: { l: { m: { n: 1 } } } } }, f: { g: { h: { i: { j: { c: '' } } } } } }
+      {
+        a: 1,
+        d: { e: { k: { l: { m: { n: 1 } } } } },
+        f: { g: { h: { i: { j: { c: '' } } } } }
+      }
     end
 
     let(:expected) do
@@ -129,7 +135,13 @@ shared_examples 'an array clean method' do |method|
 
   context 'when array has many levels' do
     let(:subject) do
-      [1, nil, '', {}, [[[{ a: [[[[[[[]]]]]]] }]]], [[[[[[[2]]]]]]], [{ a: [2] }]]
+      [
+        1,
+        nil,
+        '',
+        {},
+        [[[{ a: [[[[[[[]]]]]]] }]]], [[[[[[[2]]]]]]], [{ a: [2] }]
+      ]
     end
 
     let(:expected) do

data/spec/support/shared_examples/date.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'an object that knows how to calculate days between' do
   let(:other_date) { subject.to_date + difference }
   let(:difference) { 1.year }

data/spec/support/shared_examples/expected.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 shared_examples 'result is as expected' do
   it 'is as expected' do
     expect(result).to eq(expected)
   end
 end
-

data/spec/support/shared_examples/{chain_fetch.rb → hash/chain_fetch.rb}

@@ -1,6 +1,10 @@
-shared_examples 'an object with chain_fetch method' do
-  describe :chain_fetch do
+# frozen_string_literal: true
+
+shared_examples 'an object with capable of performing chain fetch' do
+  describe '#chain_fetch' do
     let(:value) { 10 }
+    let(:keys)  { %i[a b c d] }
+    let(:block) { nil }
     let(:hash) do
       {
         b: 1, c: 2, d: 3, a: {
@@ -12,8 +16,6 @@ shared_examples 'an object with chain_fetch method' do
         }
       }
     end
-    let(:keys) { [:a, :b, :c, :d] }
-    let(:result) { hash.chain_fetch(*keys) }
 
     context 'when fetching existing keys' do
       it 'returns the value' do
@@ -22,7 +24,7 @@ shared_examples 'an object with chain_fetch method' do
     end
 
     context 'when fetching non existing keys keys' do
-      let(:keys) { [:a, :x, :y] }
+      let(:keys) { %i[a x y] }
 
       context 'when there is no default value' do
         it 'raises fetch error' do
@@ -50,7 +52,7 @@ shared_examples 'an object with chain_fetch method' do
 
       context 'but a default value block is given' do
         let(:default_value) { 100 }
-        let(:result) { hash.chain_fetch(*keys) { default_value } }
+        let(:block) { proc { default_value } }
 
         it 'returns the default_value' do
           expect(result).to eq(default_value)
@@ -68,7 +70,7 @@ shared_examples 'an object with chain_fetch method' do
         end
 
         context 'and the block uses the key for the return' do
-          let(:result) { hash.chain_fetch(*keys) { |k| "returned #{k}" } }
+          let(:block) { proc { |k| "returned #{k}" } }
           it 'hnadles the missing keys' do
             expect(result).to eq('returned x')
           end

data/spec/support/shared_examples/{chain_hash_keys_changer.rb → hash/chain_hash_keys_changer.rb}

@@ -1,25 +1,28 @@
+# frozen_string_literal: true
+
 shared_examples 'a class with chain_change_key method' do
   let(:hash) do
     { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
   end
 
   describe :chain_change_keys do
-
-    it_behaves_like 'a method that is able to chain change keys', :chain_change_keys
+    it_behaves_like 'a method that is able to chain change keys',
+                    :chain_change_keys
     it 'does not affects the original hash' do
       expect do
         hash.chain_change_keys(:to_s, :upcase)
-      end.not_to change { hash }
+      end.not_to(change { hash })
     end
   end
 
   describe :ichain_change_keys! do
-    it_behaves_like 'a method that is able to chain change keys', :chain_change_keys!
+    it_behaves_like 'a method that is able to chain change keys',
+                    :chain_change_keys!
 
     it 'affects the original hash' do
       expect do
         hash.chain_change_keys!(:to_s, :upcase)
-      end.to change { hash }
+      end.to(change { hash })
     end
   end
 end
@@ -27,13 +30,13 @@ end
 shared_examples 'a method that is able to chain change keys' do |method|
   let(:result) { hash.public_send(method, *transformations, options) }
   let(:options) { {} }
-  let(:transformations) { [ :to_s ] }
+  let(:transformations) { [:to_s] }
 
   context 'with simple level hash' do
     let(:hash) { { 'a' => 1, b: 2 } }
 
     context 'with symbol transformation' do
-      let(:transformations) { [ :to_sym ] }
+      let(:transformations) { [:to_sym] }
       let(:expected) { { a: 1, b: 2 } }
       it_behaves_like 'result is as expected'
     end
@@ -45,9 +48,9 @@ shared_examples 'a method that is able to chain change keys' do |method|
   end
 
   context 'with recursive hash' do
-    let(:hash) { { 'a' => 1, b:  { c: 3, 'd' => 4 } } }
+    let(:hash) { { 'a' => 1, b: { c: 3, 'd' => 4 } } }
     let(:expected) do
-      { 'a' => 1, 'b' =>  { 'c' => 3, 'd' => 4 } }
+      { 'a' => 1, 'b' => { 'c' => 3, 'd' => 4 } }
     end
 
     context 'when no options are given' do
@@ -64,7 +67,7 @@ shared_examples 'a method that is able to chain change keys' do |method|
 
       context 'without recursion' do
         let(:recursive) { false }
-        let(:expected) { { 'a' => 1, 'b' =>  { c: 3, 'd' => 4 } } }
+        let(:expected) { { 'a' => 1, 'b' => { c: 3, 'd' => 4 } } }
         it_behaves_like 'result is as expected'
       end
     end
@@ -79,7 +82,7 @@ shared_examples 'a method that is able to chain change keys' do |method|
   end
 
   context 'calling with chained transformations' do
-    let(:transformations) { [ :to_s, :upcase, :to_sym ] }
+    let(:transformations) { %i[to_s upcase to_sym] }
 
     let(:hexpected) do
       { A: 1, B: 2, C: { D: 3, E: 4 }, F: [{ G: 5 }, { H: 6 }] }

data/spec/support/shared_examples/{hash_keys_changer.rb → hash/hash_keys_changer.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'a class with change_key method' do
   let(:hash) do
     { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
@@ -8,7 +10,7 @@ shared_examples 'a class with change_key method' do
     it 'does not affects the original hash' do
       expect do
         hash.change_keys(recursive: true) { |k| "foo_#{k}" }
-      end.not_to change { hash }
+      end.not_to(change { hash })
     end
   end
 
@@ -18,7 +20,7 @@ shared_examples 'a class with change_key method' do
     it 'affects the original hash' do
       expect do
         hash.change_keys!(recursive: true) { |k| "foo_#{k}" }
-      end.to change { hash }
+      end.to(change { hash })
     end
   end
 end
@@ -47,10 +49,10 @@ shared_examples 'a method that is able to change keys' do |method|
   end
 
   context 'with recursive hash' do
-    let(:hash) { { 'a' => 1, b:  { c: 3, 'd' => 4 } } }
+    let(:hash) { { 'a' => 1, b: { c: 3, 'd' => 4 } } }
     let(:result) { hash.public_send(method, options) { |k| "foo_#{k}" } }
     let(:expected) do
-      { 'foo_a' => 1, 'foo_b' =>  { 'foo_c' => 3, 'foo_d' => 4 } }
+      { 'foo_a' => 1, 'foo_b' => { 'foo_c' => 3, 'foo_d' => 4 } }
     end
 
     context 'when no options are given' do
@@ -68,7 +70,7 @@ shared_examples 'a method that is able to change keys' do |method|
 
       context 'without recursion' do
         let(:recursive) { false }
-        let(:expected) { { 'foo_a' => 1, 'foo_b' =>  { c: 3, 'd' => 4 } } }
+        let(:expected) { { 'foo_a' => 1, 'foo_b' => { c: 3, 'd' => 4 } } }
         it_behaves_like 'result is as expected'
       end
     end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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 } } } }
+
+    it 'flattens the hash' do
+      expect(squashed).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(squashed).to eq('a.b' => [1, { x: 3, y: { z: 4 } }])
+      end
+    end
+  end
+end

data/spec/support/shared_examples/{hash_transpose.rb → hash/hash_transpose.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'a class with transpose method' do |method|
   let(:hash) { { a: 1 } }
 
@@ -61,7 +63,7 @@ shared_examples 'a class with transpose method' do |method|
     end
 
     context 'when there is a clash of keys' do
-      let(:hash) { { a: :b, c: :b} }
+      let(:hash) { { a: :b, c: :b } }
 
       it 'uses the last key for value' do
         expect(hash.public_send(method)).to eq(b: :c)
@@ -69,7 +71,7 @@ shared_examples 'a class with transpose method' do |method|
     end
 
     context 'when there is a key which alreay has been defined' do
-      let(:hash) { { a: :b, b: :c} }
+      let(:hash) { { a: :b, b: :c } }
 
       it 'does not override values' do
         expect(hash.public_send(method)).to eq(b: :a, c: :b)
@@ -83,18 +85,18 @@ shared_examples 'a class with transpose method' do |method|
 end
 
 shared_examples 'a class with transpose methods' do
- it_behaves_like 'a class with transpose method', :transpose do
+  it_behaves_like 'a class with transpose method', :transpose do
     it do
       expect do
         hash.transpose
-      end.not_to change { hash }
+      end.not_to(change { hash })
     end
   end
- it_behaves_like 'a class with transpose method', :transpose! do
+  it_behaves_like 'a class with transpose method', :transpose! do
     it do
       expect do
         hash.transpose!
-      end.to change { hash }
+      end.to(change { hash })
     end
   end
 end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+shared_examples 'a class with append_keys method' do
+  describe '#prepend_to_keys' do
+    it 'accepts block to change the keys' do
+      hash = { a: 1, 'b' => 2 }
+      expected = { foo_a: 1, 'foo_b' => 2 }
+      expect(hash.prepend_to_keys('foo_')).to eq(expected)
+    end
+    it 'applies the block recursively' do
+      hash = { 'a' => 1, b: { c: 3, 'd' => 4 } }
+      expected = { 'foo_a' => 1, foo_b: { foo_c: 3, 'foo_d' => 4 } }
+      expect(hash.prepend_to_keys('foo_')).to eq(expected)
+    end
+    it 'changes type when type option is passed' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { 'foo_a' => 1, 'foo_b' => 2 }
+      expect(hash.prepend_to_keys('foo_', type: :string)).to eq(expected)
+    end
+    it 'changes type when type option is passed' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { foo_a: 1, foo_b: 2 }
+      expect(hash.prepend_to_keys('foo_', type: :symbol)).to eq(expected)
+    end
+    it 'keep type when type option is passed as keep' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { 'foo_a' => 1, foo_b: 2 }
+      expect(hash.prepend_to_keys('foo_', type: :keep)).to eq(expected)
+    end
+    it 'applies to array as well' do
+      hash = { 'a' => 1, b: [{ c: 2 }, { d: 3 }] }
+      expected = { 'foo_a' => 1, foo_b: [{ foo_c: 2 }, { foo_d: 3 }] }
+      expect(hash.prepend_to_keys('foo_', type: :keep)).to eq(expected)
+    end
+  end
+
+  describe '#append_to_keys' do
+    it 'accepts block to change the keys' do
+      hash = { a: 1, 'b' => 2 }
+      expected = { a_bar: 1, 'b_bar' => 2 }
+      expect(hash.append_to_keys('_bar')).to eq(expected)
+    end
+    it 'applies the block recursively' do
+      hash = { 'a' => 1, b: { c: 3, 'd' => 4 } }
+      expected = { 'a_bar' => 1, b_bar: { c_bar: 3, 'd_bar' => 4 } }
+      expect(hash.append_to_keys('_bar')).to eq(expected)
+    end
+    it 'changes type when type option is passed' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { 'a_bar' => 1, 'b_bar' => 2 }
+      expect(hash.append_to_keys('_bar', type: :string)).to eq(expected)
+    end
+    it 'changes type when type option is passed' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { a_bar: 1, b_bar: 2 }
+      expect(hash.append_to_keys('_bar', type: :symbol)).to eq(expected)
+    end
+    it 'keep type when type option is passed as keep' do
+      hash = { 'a' => 1, b: 2 }
+      expected = { 'a_bar' => 1, b_bar: 2 }
+      expect(hash.append_to_keys('_bar', type: :keep)).to eq(expected)
+    end
+    it 'applies to array as well' do
+      hash = { 'a' => 1, b: [{ c: 2 }, { d: 3 }] }
+      expected = { 'a_bar' => 1, b_bar: [{ c_bar: 2 }, { d_bar: 3 }] }
+      expect(hash.append_to_keys('_bar', type: :keep)).to eq(expected)
+    end
+  end
+end

data/spec/support/shared_examples/{keys_camelizer.rb → hash/keys_camelizer.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples 'a class with camlize_keys method' do
   describe :lower_camelize_keys do
     let(:expected) { { inputKey: 'value' } }
@@ -10,7 +12,7 @@ shared_examples 'a class with camlize_keys method' do
       end
 
       it 'does not change original hash' do
-        expect { hash.lower_camelize_keys }.not_to change { hash }
+        expect { hash.lower_camelize_keys }.not_to(change { hash })
       end
     end
 
@@ -81,7 +83,7 @@ shared_examples 'a class with camlize_keys method' do
       end
 
       it 'does not change original hash' do
-        expect { hash.lower_camelize_keys! }.to change { hash }
+        expect { hash.lower_camelize_keys! }.to(change { hash })
       end
     end
 
@@ -152,7 +154,7 @@ shared_examples 'a class with camlize_keys method' do
       end
 
       it 'does not change original hash' do
-        expect { hash.camelize_keys }.not_to change { hash }
+        expect { hash.camelize_keys }.not_to(change { hash })
       end
     end
 
@@ -223,7 +225,7 @@ shared_examples 'a class with camlize_keys method' do
       end
 
       it 'does not change original hash' do
-        expect { hash.camelize_keys! }.to change { hash }
+        expect { hash.camelize_keys! }.to(change { hash })
       end
     end