darthjee-core_ext 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7715cb61685cee6ed7a62cf04d205fe2995dd697
-  data.tar.gz: f6a4c92b92e884cb53ddd71faddbddaadd3a1e8c
+  metadata.gz: 738212a365d4f2b6182a1f71519d482998f71f7f
+  data.tar.gz: a5028fd0f7b6f62b5d7ba0510204c21fbafb3a52
 SHA512:
-  metadata.gz: bd36853fabb1b87a957bdf3dd8fcfdec3565b76856b5c3ec1af4c2fd1414524c2fae52d340b5b1cf7902a9869cba23e8c044edf575723fb929fd85b627c07811
-  data.tar.gz: 2982ea085d5041b194146f9d363dcaa209ac97f410c45cd495a28adcadc3f4e30afa9c889fde174ab188ddc399e5a50c19fc504938b36064a439780a8d898fbc
+  metadata.gz: 6386535f1ed9bed1fc21e6f157d4117322454cc0413f6bb01461f130fd8da860d6b02a5aaa634f60116e0e5e2703fc4515f4dc4fce0dfc08af86fc6b0d77489f
+  data.tar.gz: ff41c39af8f135b64f84f1cc5f21d51536490ada52003570c66add9c3887282b812a35249b3c6a43eb7ec628b1f43543757dbe5fc40aa3a02800986776dde1ae

data/.rubocop.yml

@@ -7,10 +7,6 @@ Naming/PredicateName:
   Exclude:
     - 'lib/darthjee/core_ext/object.rb'
 
-Metrics/ClassLength:
-  Exclude:
-    - 'lib/darthjee/core_ext/hash.rb'
-
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*_spec.rb'

data/core_ext.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'activesupport', '>= 5.2.x'
 
-  gem.add_development_dependency 'bundler',   '~> 1.16'
+  gem.add_development_dependency 'bundler',   '~> 1.15.4'
   gem.add_development_dependency 'pry-nav',   '~> 0.2.4'
   gem.add_development_dependency 'rake',      '>= 12.3.1'
   gem.add_development_dependency 'rspec',     '>= 3.8'

data/lib/darthjee/core_ext/hash.rb

@@ -1,182 +1,27 @@
 # frozen_string_literal: true
 
+require 'darthjee/core_ext/hash/key_changeable'
+require 'darthjee/core_ext/hash/transposeable'
+require 'darthjee/core_ext/hash/transformable'
+
 class Hash
-  autoload :ValueChanger,        'darthjee/core_ext/hash/value_changer'
+  autoload :ChainFetcher,        'darthjee/core_ext/hash/chain_fetcher'
   autoload :DeepHashConstructor, 'darthjee/core_ext/hash/deep_hash_constructor'
   autoload :KeyChanger,          'darthjee/core_ext/hash/key_changer'
-  autoload :ChainFetcher,        'darthjee/core_ext/hash/chain_fetcher'
+  autoload :KeysSorter,          'darthjee/core_ext/hash/keys_sorter'
   autoload :Squasher,            'darthjee/core_ext/hash/squasher'
+  autoload :ValueChanger,        'darthjee/core_ext/hash/value_changer'
   autoload :ToHashMapper,        'darthjee/core_ext/hash/to_hash_mapper'
-  autoload :KeysSorter,          'darthjee/core_ext/hash/keys_sorter'
-
-  def chain_fetch(*keys, &block)
-    ChainFetcher.new(self, *keys, &block).fetch
-  end
-
-  def squash
-    Squasher.squash(self)
-  end
-
-  def map_to_hash(&block)
-    ToHashMapper.new(self).map(&block)
-  end
-
-  def remap_keys(remap)
-    dup.remap_keys!(remap)
-  end
-
-  def remap_keys!(keys_map)
-    KeyChanger.new(self).remap(keys_map)
-  end
-
-  def lower_camelize_keys(options = {})
-    dup.lower_camelize_keys!(options)
-  end
-
-  def lower_camelize_keys!(options = {})
-    options = options.merge(uppercase_first_letter: false)
-
-    camelize_keys!(options)
-  end
-
-  def camelize_keys(options = {})
-    dup.camelize_keys!(options)
-  end
-
-  def camelize_keys!(options = {})
-    Hash::KeyChanger.new(self).camelize_keys(options)
-  end
-
-  def underscore_keys(options = {})
-    dup.underscore_keys!(options)
-  end
-
-  def underscore_keys!(options = {})
-    Hash::KeyChanger.new(self).underscore_keys(options)
-  end
-
-  def exclusive_merge(hash)
-    dup.exclusive_merge!(hash)
-  end
-
-  def exclusive_merge!(hash)
-    merge!(hash.slice(*keys))
-  end
-
-  # change all keys returning the new map
-  # options: { recursive: true }
-  # ex: { "a" =>1 }.change_keys{ |key| key.upcase } == { "A" => 1 }
-  def change_keys(options = {}, &block)
-    deep_dup.change_keys!(options, &block)
-  end
-
-  # change all keys returning the new map
-  # options: { recursive: true }
-  # ex: { "a":1 }.change_keys{ |key| key.upcase } == { "A":1 }
-  def change_keys!(options = {}, &block)
-    Hash::KeyChanger.new(self).change_keys(options, &block)
-  end
-
-  # change all publicaly sending method calls
-  # options: { recursive: true }
-  # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
-  def chain_change_keys(*calls)
-    deep_dup.chain_change_keys!(*calls)
-  end
-
-  # change all publicaly sending method calls
-  # options: { recursive: true }
-  # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
-  def chain_change_keys!(*calls)
-    options = calls.extract_options!
 
-    calls.inject(self) do |h, m|
-      h.change_keys!(options, &m)
-    end
-  end
-
-  # prepend a string to all keys
-  # options {
-  #  recursive: true,
-  #  type: :keep [keep, string, symbol] (key type to be returned)
-  # }
-  # 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}"
-    end
-  end
+  include Hash::KeyChangeable
+  include Hash::Transposeable
+  include Hash::Transformable
 
-  # append a string to all keys
-  # options {
-  #  recursive: true,
-  #  type: :keep [keep, string, symbol] (key type to be returned)
-  # }
-  # 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}"
-    end
-  end
+  ########################################
+  # Fetching methods
+  #########################################
 
-  # sorts keys for hash
-  # options: { recursive: true }
-  # ex: { b:1, a:2 }.sort_keys == { a:2, b:1 }
-  def sort_keys(options = {})
-    Hash::KeysSorter.new(self, **options).sort
-  end
-
-  # creates a new hash with changes in its values
-  # options: {
-  #   recursive: true,
-  #   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 }
-  # # 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
-
-  def change_values!(options = {}, &block)
-    Hash::ValueChanger.new(options, &block).change(self)
-  end
-
-  def to_deep_hash(separator = '.')
-    Hash::DeepHashConstructor.new(separator).deep_hash(self)
-  end
-
-  def transpose!
-    aux = dup
-    keys.each { |k| delete(k) }
-    aux.each do |k, v|
-      self[v] = k
-    end
-    self
-  end
-
-  def transpose
-    {}.tap do |new_hash|
-      each do |k, v|
-        new_hash[v] = k
-      end
-    end
-  end
-
-  private
-
-  # changes the text of the keys
-  # options {
-  #  recursive: true,
-  #  type: :keep [keep, string, symbol] (key type to be returned)
-  # }
-  # 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)
+  def chain_fetch(*keys, &block)
+    ChainFetcher.new(self, *keys, &block).fetch
   end
 end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class Hash
+  module KeyChangeable
+    def remap_keys(remap)
+      dup.remap_keys!(remap)
+    end
+
+    def remap_keys!(keys_map)
+      KeyChanger.new(self).remap(keys_map)
+    end
+
+    def lower_camelize_keys(options = {})
+      dup.lower_camelize_keys!(options)
+    end
+
+    def lower_camelize_keys!(options = {})
+      options = options.merge(uppercase_first_letter: false)
+
+      camelize_keys!(options)
+    end
+
+    def camelize_keys(options = {})
+      dup.camelize_keys!(options)
+    end
+
+    def camelize_keys!(options = {})
+      Hash::KeyChanger.new(self).camelize_keys(options)
+    end
+
+    def underscore_keys(options = {})
+      dup.underscore_keys!(options)
+    end
+
+    def underscore_keys!(options = {})
+      Hash::KeyChanger.new(self).underscore_keys(options)
+    end
+
+    # change all keys returning the new map
+    # options: { recursive: true }
+    # ex: { "a" =>1 }.change_keys{ |key| key.upcase } == { "A" => 1 }
+    def change_keys(options = {}, &block)
+      deep_dup.change_keys!(options, &block)
+    end
+
+    # change all keys returning the new map
+    # options: { recursive: true }
+    # ex: { "a":1 }.change_keys{ |key| key.upcase } == { "A":1 }
+    def change_keys!(options = {}, &block)
+      Hash::KeyChanger.new(self).change_keys(options, &block)
+    end
+
+    # change all publicaly sending method calls
+    # options: { recursive: true }
+    # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
+    def chain_change_keys(*calls)
+      deep_dup.chain_change_keys!(*calls)
+    end
+
+    # change all publicaly sending method calls
+    # options: { recursive: true }
+    # ex: { a: 1 }.chain_change_keys(:to_s, :upcase) == { "A" =>1 }
+    def chain_change_keys!(*calls)
+      options = calls.extract_options!
+
+      calls.inject(self) do |h, m|
+        h.change_keys!(options, &m)
+      end
+    end
+
+    # prepend a string to all keys
+    # options {
+    #  recursive: true,
+    #  type: :keep [keep, string, symbol] (key type to be returned)
+    # }
+    # 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}"
+      end
+    end
+
+    # append a string to all keys
+    # options {
+    #  recursive: true,
+    #  type: :keep [keep, string, symbol] (key type to be returned)
+    # }
+    # 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}"
+      end
+    end
+
+    # sorts keys for hash
+    # options: { recursive: true }
+    # ex: { b:1, a:2 }.sort_keys == { a:2, b:1 }
+    def sort_keys(options = {})
+      Hash::KeysSorter.new(self, **options).sort
+    end
+
+    ##########################################
+    # Value change methods
+    ##########################################
+
+    # creates a new hash with changes in its values
+    # options: {
+    #   recursive: true,
+    #   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 }
+    # # 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
+
+    def change_values!(options = {}, &block)
+      Hash::ValueChanger.new(options, &block).change(self)
+    end
+
+    private
+
+    # changes the text of the keys
+    # options {
+    #  recursive: true,
+    #  type: :keep [keep, string, symbol] (key type to be returned)
+    # }
+    # 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
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Hash
+  module Transformable
+    def squash
+      Squasher.squash(self)
+    end
+
+    def to_deep_hash(separator = '.')
+      Hash::DeepHashConstructor.new(separator).deep_hash(self)
+    end
+
+    def map_to_hash(&block)
+      ToHashMapper.new(self).map(&block)
+    end
+
+    def exclusive_merge(hash)
+      dup.exclusive_merge!(hash)
+    end
+
+    def exclusive_merge!(hash)
+      merge!(hash.slice(*keys))
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Hash
+  module Transposeable
+    def transpose!
+      aux = dup
+      keys.each { |k| delete(k) }
+      aux.each do |k, v|
+        self[v] = k
+      end
+      self
+    end
+
+    def transpose
+      {}.tap do |new_hash|
+        each do |k, v|
+          new_hash[v] = k
+        end
+      end
+    end
+  end
+end

data/lib/darthjee/core_ext/version.rb

@@ -2,6 +2,6 @@
 
 module Darthjee
   module CoreExt
-    VERSION = '1.6.1'
+    VERSION = '1.6.2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: darthjee-core_ext
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-30 00:00:00.000000000 Z
+date: 2018-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 1.15.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 1.15.4
 - !ruby/object:Gem::Dependency
   name: pry-nav
   requirement: !ruby/object:Gem::Requirement
@@ -156,10 +156,13 @@ files:
 - lib/darthjee/core_ext/hash.rb
 - lib/darthjee/core_ext/hash/chain_fetcher.rb
 - lib/darthjee/core_ext/hash/deep_hash_constructor.rb
+- lib/darthjee/core_ext/hash/key_changeable.rb
 - lib/darthjee/core_ext/hash/key_changer.rb
 - lib/darthjee/core_ext/hash/keys_sorter.rb
 - lib/darthjee/core_ext/hash/squasher.rb
 - lib/darthjee/core_ext/hash/to_hash_mapper.rb
+- lib/darthjee/core_ext/hash/transformable.rb
+- lib/darthjee/core_ext/hash/transposeable.rb
 - lib/darthjee/core_ext/hash/value_changer.rb
 - lib/darthjee/core_ext/math.rb
 - lib/darthjee/core_ext/numeric.rb