darthjee-core_ext 1.5.6 → 1.6.0

data/lib/darthjee/core_ext/hash/value_changer.rb

@@ -1,62 +1,66 @@
-class Hash::ValueChanger
-  attr_accessor :options, :block
+# frozen_string_literal: true
 
-  def initialize(options, &block)
-    @options = {
-      recursive: true,
-      skip_inner: true
-    }.merge(options)
+class Hash
+  class ValueChanger
+    attr_accessor :options, :block
 
-    @block = block
-  end
+    def initialize(options, &block)
+      @options = {
+        recursive: true,
+        skip_inner: true
+      }.merge(options)
 
-  def change(object)
-    if object.respond_to?(:change_values)
-      change_hash(object)
-    elsif is_iterable?(object)
-      change_array(object)
+      @block = block
     end
-  end
 
-  private
+    def change(object)
+      if object.respond_to?(:change_values)
+        change_hash(object)
+      elsif iterable?(object)
+        change_array(object)
+      end
+    end
 
-  def change_hash(original_hash)
-    original_hash.tap do |hash|
-      original_hash.each do |key, value|
-        value = new_value(value)
-        hash[key] = value
+    private
+
+    def change_hash(original_hash)
+      original_hash.tap do |hash|
+        original_hash.each do |key, value|
+          value = new_value(value)
+          hash[key] = value
+        end
       end
     end
-  end
 
-  def change_array(array)
-    method = %w(map! map).find { |m| array.respond_to? m }
+    def change_array(array)
+      method = %w[map! map].find { |m| array.respond_to? m }
 
-    array.public_send(method) do |value|
-      if value.respond_to?(:change_values)
-        value.change_values(options, &block)
-      elsif is_iterable?(value)
-        change_array(value)
-      else
-        new_value(value)
+      array.public_send(method) do |value|
+        if value.respond_to?(:change_values)
+          value.change_values(options, &block)
+        elsif iterable?(value)
+          change_array(value)
+        else
+          new_value(value)
+        end
       end
     end
-  end
 
-  def change_value?(value)
-    !is_iterable?(value) || !options[:skip_inner]
-  end
+    def change_value?(value)
+      !iterable?(value) || !options[:skip_inner]
+    end
 
-  def is_iterable?(value)
-    value.respond_to?(:each)
-  end
+    def iterable?(value)
+      value.respond_to?(:each)
+    end
 
-  def new_value(value)
-    value = block.call(value) if change_value?(value)
-    apply_recursion?(value) ? change(value) : value
-  end
+    def new_value(value)
+      value = block.call(value) if change_value?(value)
+      apply_recursion?(value) ? change(value) : value
+    end
 
-  def apply_recursion?(value)
-    is_iterable?(value) && options[:recursive]
+    def apply_recursion?(value)
+      iterable?(value) && options[:recursive]
+    end
   end
 end

data/lib/darthjee/core_ext/hash.rb

@@ -1,57 +1,32 @@
+# frozen_string_literal: true
+
 class Hash
-  autoload :ValueChanger, 'darthjee/core_ext/hash/value_changer'
+  autoload :ValueChanger,        'darthjee/core_ext/hash/value_changer'
   autoload :DeepHashConstructor, 'darthjee/core_ext/hash/deep_hash_constructor'
-  autoload :KeyChanger, 'darthjee/core_ext/hash/key_changer'
-
-  def chain_fetch(*keys)
-    value = self
-
-    if block_given?
-      value = value.fetch(keys.shift) do |*args|
-        missed_keys = keys
-        keys = []
-        yield(*(args + [missed_keys]))
-      end until keys.empty?
-    else
-      value = value.fetch(keys.shift) until keys.empty?
-    end
+  autoload :KeyChanger,          'darthjee/core_ext/hash/key_changer'
+  autoload :ChainFetcher,        'darthjee/core_ext/hash/chain_fetcher'
+  autoload :Squasher,            'darthjee/core_ext/hash/squasher'
+  autoload :ToHashMapper,        'darthjee/core_ext/hash/to_hash_mapper'
+  autoload :KeysSorter,          'darthjee/core_ext/hash/keys_sorter'
 
-    value
+  def chain_fetch(*keys, &block)
+    ChainFetcher.new(self, *keys, &block).fetch
   end
 
   def squash
-    {}.tap do |hash|
-      each do |key, value|
-        if value.is_a? Hash
-          value.squash.each do |k, v|
-            new_key = [key, k].join('.')
-            hash[new_key] = v
-          end
-        else
-          hash[key] = value
-        end
-      end
-    end
+    Squasher.squash(self)
   end
 
-  def map_to_hash
-    {}.tap do |hash|
-      each do |k, v|
-        hash[k] = yield(k, v)
-      end
-    end
+  def map_to_hash(&block)
+    ToHashMapper.new(self).map(&block)
   end
 
   def remap_keys(remap)
     dup.remap_keys!(remap)
   end
 
-  def remap_keys!(remap)
-    new_hash = {}
-    remap.each do |o, n|
-      new_hash[n] = delete o
-    end
-    merge! new_hash
+  def remap_keys!(keys_map)
+    KeyChanger.new(self).remap(keys_map)
   end
 
   def lower_camelize_keys(options = {})
@@ -59,7 +34,7 @@ class Hash
   end
 
   def lower_camelize_keys!(options = {})
-    options = options.merge({ uppercase_first_letter: false })
+    options = options.merge(uppercase_first_letter: false)
 
     camelize_keys!(options)
   end
@@ -125,7 +100,8 @@ class Hash
   #  recursive: true,
   #  type: :keep [keep, string, symbol] (key type to be returned)
   # }
-  # ex: { :a => 1, "b"=> 2 }.prepend_to_keys("foo_") == { :foo_a => 1, "foo_b"=> 2 }
+  # ex: { :a => 1, "b"=> 2 }.prepend_to_keys("foo_")
+  # # returns { :foo_a => 1, "foo_b"=> 2 }
   def prepend_to_keys(str, options = {})
     change_key_text(options) do |key|
       "#{str}#{key}"
@@ -137,7 +113,8 @@ class Hash
   #  recursive: true,
   #  type: :keep [keep, string, symbol] (key type to be returned)
   # }
-  # ex: { :a => 1, "b"=> 2 }.append_to_keys("_bar") == { :a_bar => 1, "b_bar"=> 2 }
+  # ex: { :a => 1, "b"=> 2 }.append_to_keys("_bar")
+  # # returns { :a_bar => 1, "b_bar"=> 2 }
   def append_to_keys(str, options = {})
     change_key_text(options) do |key|
       "#{key}#{str}"
@@ -148,17 +125,7 @@ class Hash
   # options: { recursive: true }
   # ex: { b:1, a:2 }.sort_keys == { a:2, b:1 }
   def sort_keys(options = {})
-    options = {
-      recursive: true
-    }.merge(options)
-
-    {}.tap do |hash|
-      keys.sort.each do |key|
-        value = self[key]
-        hash[key] = value unless value.is_a?(Hash) && options[:recursive]
-        hash[key] = value.sort_keys(options) if value.is_a?(Hash) && options[:recursive]
-      end
-    end
+    Hash::KeysSorter.new(self, **options).sort
   end
 
   # creates a new hash with changes in its values
@@ -167,8 +134,10 @@ class Hash
   #   skip_hash:true
   # }
   # ex: { a:1, b:2 }.change_values{ |v| v+1 } == { a:2, b:3 }
-  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:false) { |v| v.to_s } == { a:"1", b:"{ c=>1 }
-  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:true) { |v| v.to_s } == { a:"1", b:{ c=>"1" } }
+  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:false) { |v| v.to_s }
+  # # returns { a:"1", b:"{ c=>1 }
+  # ex: { a:1, b:{ c:1 } }.change_values(skip_hash:true) { |v| v.to_s }
+  # # returns { a:"1", b:{ c=>"1" } }
   def change_values(options = {}, &block)
     deep_dup.change_values!(options, &block)
   end
@@ -183,7 +152,7 @@ class Hash
 
   def transpose!
     aux = dup
-    keys.each { |k| self.delete(k) }
+    keys.each { |k| delete(k) }
     aux.each do |k, v|
       self[v] = k
     end
@@ -205,7 +174,8 @@ class Hash
   #  recursive: true,
   #  type: :keep [keep, string, symbol] (key type to be returned)
   # }
-  # ex: { :a => 1, "b"=> 2 }.change_key_text{ |key| key.upcase } == { :A => 1, "B"=> 2 }
+  # ex: { :a => 1, "b"=> 2 }.change_key_text{ |key| key.upcase }
+  # # returns { :A => 1, "B"=> 2 }
   def change_key_text(options = {}, &block)
     Hash::KeyChanger.new(self).change_text(options, &block)
   end

data/lib/darthjee/core_ext/math.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Math
   def self.average(values)
-    values = values.map { |v| [v,1] }.to_h unless values.is_a?(Hash)
+    values = values.map { |v| [v, 1] }.to_h unless values.is_a?(Hash)
 
     values.inject(0) do |sum, vals|
-      sum + vals.inject { |a,b| a * b }
+      sum + vals.inject { |a, b| a * b }
     end / values.values.sum.to_f
   end
 end

data/lib/darthjee/core_ext/numeric.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class Numeric
-  def percent_of(n)
-    return Float::INFINITY if n == 0
-    (to_f / n.to_f) * 100.0
+  def percent_of(total)
+    return Float::INFINITY if total&.zero?
+    (to_f / total.to_f) * 100.0
   end
 end

data/lib/darthjee/core_ext/object/default_value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   class << self
     private
@@ -13,4 +15,3 @@ class Object
     end
   end
 end
-

data/lib/darthjee/core_ext/object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'darthjee/core_ext/object/default_value'
 
 class Object

data/lib/darthjee/core_ext/symbol.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Symbol
   def camelize(type = :upper)
     to_s.camelize(type).to_sym

data/lib/darthjee/core_ext/time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Time
   delegate :days_between, to: :to_date
 end

data/lib/darthjee/core_ext/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Darthjee
   module CoreExt
-    VERSION = '1.5.6'
+    VERSION = '1.6.0'
   end
 end

data/lib/darthjee/core_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/all'
 require 'darthjee/core_ext/enumerable'
 require 'darthjee/core_ext/hash'

data/lib/darthjee.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 module Darthjee
   require 'darthjee/core_ext'
 end
-

data/spec/lib/array_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Array do
   it_behaves_like 'an array with map_to_hash method'
 
   describe '#mapk' do
-    let(:array) { [{a: { b: 1 }, b: 2}, {a: { b: 3 }, b: 4}] }
+    let(:array) { [{ a: { b: 1 }, b: 2 }, { a: { b: 3 }, b: 4 }] }
 
     it 'maps using the keys given as arguments' do
-      expect(array.mapk(:a, :b)).to eq([ 1, 3 ])
+      expect(array.mapk(:a, :b)).to eq([1, 3])
     end
   end
 
@@ -27,7 +29,7 @@ describe Array do
     it 'does not change the array' do
       expect do
         result
-      end.not_to change { array }
+      end.not_to(change { array })
     end
 
     context 'when array is empty' do
@@ -45,7 +47,7 @@ describe Array do
     end
 
     context 'when array has only one element' do
-      let(:array) { [ 2 ] }
+      let(:array) { [2] }
 
       it do
         expect do
@@ -82,11 +84,11 @@ describe Array do
   end
 
   describe '#chain_map' do
-    let(:array) { [ :a, :long_name, :sym ] }
+    let(:array) { %i[a long_name sym] }
     let(:mapped) { array.chain_map(:to_s, :size, :to_s) }
 
     it 'calls each argument as method of the mapped result' do
-      expect(mapped).to eq([ '1', '9', '3' ])
+      expect(mapped).to eq(%w[1 9 3])
     end
 
     context 'when an extra block is given' do
@@ -97,14 +99,14 @@ describe Array do
       end
 
       it 'calls each argument as method of the mapped result' do
-        expect(mapped).to eq([ 'final: 1', 'final: 9', 'final: 3' ])
+        expect(mapped).to eq(['final: 1', 'final: 9', 'final: 3'])
       end
     end
   end
 
   describe '#as_hash' do
     let(:array) { [1, 2, 3] }
-    let(:keys) { %w(a b c) }
+    let(:keys) { %w[a b c] }
     let(:expected) { { 'a' => 1, 'b' => 2, 'c' => 3 } }
 
     it 'creates a hash using the array as value and the argument as keys' do
@@ -112,24 +114,30 @@ describe Array do
     end
 
     context 'when there are more keys than values' do
-      let(:keys) { %w(a b c d e f) }
-      let(:expected) { { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => nil, 'e' => nil, 'f' => nil } }
+      let(:keys) { %w[a b c d e f] }
+      let(:expected) do
+        {
+          'a' => 1,
+          'b' => 2,
+          'c' => 3,
+          'd' => nil,
+          'e' => nil,
+          'f' => nil
+        }
+      end
 
       it 'creates a hash with nil values for the extra keys' do
         expect(array.as_hash(keys)).to eq(expected)
       end
 
-      it { expect { array.as_hash(keys) }.not_to change { keys } }
-      it { expect { array.as_hash(keys) }.not_to change { array } }
+      it { expect { array.as_hash(keys) }.not_to(change { keys }) }
+      it { expect { array.as_hash(keys) }.not_to(change { array }) }
     end
 
     context 'when there are more values than keys' do
       let(:array) { [1, 2, 3, 4, 5, 6, 7] }
 
       it { expect { array.as_hash(keys) }.to raise_error(IndexError) }
-
-      it { expect { array.as_hash(keys) rescue nil }.not_to change { keys } }
-      it { expect { array.as_hash(keys) rescue nil }.not_to change { array } }
     end
   end
 
@@ -174,19 +182,19 @@ describe Array do
   describe '#random' do
     it_behaves_like 'a method that returns a random element', :random
 
-    let(:array) { [ 8,4,2 ] }
+    let(:array) { [8, 4, 2] }
 
     it 'removes an the returned element' do
       expect do
         array.random
-      end.not_to change { array }
+      end.not_to(change { array })
     end
   end
 
   describe '#random!' do
     it_behaves_like 'a method that returns a random element', :random!
 
-    let(:array) { [ 8,4,2 ] }
+    let(:array) { [8, 4, 2] }
 
     it 'removes an the returned element' do
       expect do
@@ -196,7 +204,7 @@ describe Array do
   end
 
   describe '#map_and_select' do
-    let(:array) { [1, 2, 3, 4].map { |i| { value: i} } }
+    let(:array) { [1, 2, 3, 4].map { |i| { value: i } } }
     let(:filtered) { array.map_and_select(&block) }
 
     context 'when block returns nil' do

data/spec/lib/date_spec.rb

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

data/spec/lib/enumerable_spec.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 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 }
+      hash = { a: nil }
+      expect { hash.clean! }.to(change { hash })
     end
 
     it 'changes original array' do
-      array = [{ a: nil}]
-      expect { array.clean! }.to change { array }
+      array = [{ a: nil }]
+      expect { array.clean! }.to(change { array })
     end
   end
 
@@ -19,13 +21,13 @@ describe Enumerable do
     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 }
+      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 }
+      array = [{ a: nil }]
+      expect { array.clean }.not_to(change { array })
     end
   end
 end

data/spec/lib/hash/chain_fetcher_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash::ChainFetcher do
+  subject { described_class.new(hash, *keys, &block) }
+
+  it_behaves_like 'an object with capable of performing chain fetch' do
+    let(:result) { subject.fetch }
+  end
+end

data/spec/lib/hash/deep_hash_constructor_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Hash::DeepHashConstructor do
@@ -46,7 +48,7 @@ describe Hash::DeepHashConstructor 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

data/spec/lib/hash/key_changer_spec.rb

@@ -1,8 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Hash::KeyChanger do
   let(:subject) { described_class.new(hash) }
 
+  describe '#remap_keys!' do
+    it_behaves_like 'a method that remaps the keys', :remap do
+      it 'changes the original hash' do
+        expect { result }.to(change { hash })
+      end
+    end
+  end
+
   describe '#underscore_keys' do
     let(:hash) { { keyUnderscore: 1 } }
 
@@ -14,7 +24,8 @@ describe Hash::KeyChanger do
       let(:hash) { { keyUnderscore: { anotherKey: 1 } } }
 
       it 'underscore all the keys' do
-        expect(subject.underscore_keys).to eq(key_underscore: { another_key: 1 })
+        result = subject.underscore_keys
+        expect(result).to eq(key_underscore: { another_key: 1 })
       end
     end
 
@@ -22,7 +33,8 @@ describe Hash::KeyChanger do
       let(:hash) { { keyUnderscore: [{ anotherKey: 1 }] } }
 
       it 'underscore all the keys' do
-        expect(subject.underscore_keys).to eq(key_underscore: [{ another_key: 1 }])
+        result = { key_underscore: [{ another_key: 1 }] }
+        expect(subject.underscore_keys).to eq(result)
       end
     end
 
@@ -30,7 +42,7 @@ describe Hash::KeyChanger do
       it 'underscore all the keys' do
         expect do
           subject.underscore_keys
-        end.to change { hash }
+        end.to(change { hash })
       end
     end
 
@@ -39,7 +51,8 @@ describe Hash::KeyChanger do
         let(:hash) { { keyUnderscore: { anotherKey: 1 } } }
 
         it 'underscore all the keys' do
-          expect(subject.underscore_keys(recursive: false)).to eq(key_underscore: { anotherKey: 1 })
+          result = subject.underscore_keys(recursive: false)
+          expect(result).to eq(key_underscore: { anotherKey: 1 })
         end
       end
 
@@ -47,7 +60,8 @@ describe Hash::KeyChanger do
         let(:hash) { { keyUnderscore: [{ anotherKey: 1 }] } }
 
         it 'underscore all the keys' do
-          expect(subject.underscore_keys(recursive: false)).to eq(key_underscore: [{ anotherKey: 1 }])
+          result = subject.underscore_keys(recursive: false)
+          expect(result).to eq(key_underscore: [{ anotherKey: 1 }])
         end
       end
     end

data/spec/lib/hash/keys_sorter_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash::KeysSorter do
+  it_behaves_like 'a class with a keys sort method' do
+    subject { described_class.new(hash, **options) }
+    let(:result) { subject.sort }
+  end
+end

data/spec/lib/hash/squasher_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash::Squasher do
+  it_behaves_like 'a class that has a method to squash a hash' do
+    let(:squashed) { described_class.squash(hash) }
+  end
+end

data/spec/lib/hash/to_hash_mapper_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Hash::ToHashMapper do
+  it_behaves_like 'a hash with map_to_hash method' do
+    subject { described_class.new(hash) }
+    let(:mapped) { subject.map(&mapping_block) }
+  end
+end