darthjee-core_ext 1.6.2 → 1.7.0

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

@@ -1,139 +1,143 @@
 # 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)
+module Darthjee
+  module CoreExt
+    module 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
-
-    # 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/key_changer.rb

@@ -1,86 +1,90 @@
 # frozen_string_literal: true
 
-class Hash
-  class KeyChanger
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def remap(keys_map)
-      new_hash = {}
-      keys_map.each do |o, n|
-        new_hash[n] = hash.delete(o)
-      end
-      hash.merge! new_hash
-    end
-
-    def change_keys(settings = {}, &block)
-      merge_options({
-                      recursive: true
-                    }, settings)
-
-      if options[:recursive]
-        hash.deep_transform_keys!(&block)
-      else
-        hash.transform_keys!(&block)
-      end
-    end
-
-    def camelize_keys(settings = {})
-      merge_options({
-                      uppercase_first_letter: true
-                    }, settings)
-
-      type = options[:uppercase_first_letter] ? :upper : :lower
-
-      change_keys do |k|
-        k.camelize(type)
+module Darthjee
+  module CoreExt
+    module Hash
+      class KeyChanger
+        def initialize(hash)
+          @hash = hash
+        end
+
+        def remap(keys_map)
+          new_hash = {}
+          keys_map.each do |o, n|
+            new_hash[n] = hash.delete(o)
+          end
+          hash.merge! new_hash
+        end
+
+        def change_keys(settings = {}, &block)
+          merge_options({
+                          recursive: true
+                        }, settings)
+
+          if options[:recursive]
+            hash.deep_transform_keys!(&block)
+          else
+            hash.transform_keys!(&block)
+          end
+        end
+
+        def camelize_keys(settings = {})
+          merge_options({
+                          uppercase_first_letter: true
+                        }, settings)
+
+          type = options[:uppercase_first_letter] ? :upper : :lower
+
+          change_keys do |k|
+            k.camelize(type)
+          end
+        end
+
+        def underscore_keys(settings = {})
+          merge_options({}, settings)
+
+          change_keys(&:underscore)
+        end
+
+        def change_text(options = {})
+          merge_options({
+                          type: :keep
+                        }, options)
+
+          change_keys do |key|
+            cast_new_key yield(key), key.class
+          end
+        end
+
+        private
+
+        attr_reader :hash
+
+        def merge_options(default, custom)
+          @options = {}.merge!(default).merge!(custom).merge!(options)
+        end
+
+        def options
+          @options ||= {}
+        end
+
+        def cast_new_key(key, old_clazz)
+          case class_cast(old_clazz)
+          when :symbol then
+            key.to_sym
+          when :string then
+            key.to_s
+          end
+        end
+
+        def keep_class?
+          options[:type] == :keep
+        end
+
+        def class_cast(old_clazz)
+          keep_class? && old_clazz.to_s.downcase.to_sym || options[:type]
+        end
       end
     end
-
-    def underscore_keys(settings = {})
-      merge_options({}, settings)
-
-      change_keys(&:underscore)
-    end
-
-    def change_text(options = {})
-      merge_options({
-                      type: :keep
-                    }, options)
-
-      change_keys do |key|
-        cast_new_key yield(key), key.class
-      end
-    end
-
-    private
-
-    attr_reader :hash
-
-    def merge_options(default, custom)
-      @options = {}.merge!(default).merge!(custom).merge!(options)
-    end
-
-    def options
-      @options ||= {}
-    end
-
-    def cast_new_key(key, old_clazz)
-      case class_cast(old_clazz)
-      when :symbol then
-        key.to_sym
-      when :string then
-        key.to_s
-      end
-    end
-
-    def keep_class?
-      options[:type] == :keep
-    end
-
-    def class_cast(old_clazz)
-      keep_class? && old_clazz.to_s.downcase.to_sym || options[:type]
-    end
   end
 end

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

@@ -1,31 +1,35 @@
 # frozen_string_literal: true
 
-class Hash
-  class KeysSorter
-    def initialize(hash, recursive: true)
-      @hash = hash
-      @recursive = recursive
-    end
+module Darthjee
+  module CoreExt
+    module Hash
+      class KeysSorter
+        def initialize(hash, recursive: true)
+          @hash = hash
+          @recursive = recursive
+        end
 
-    def sort
-      {}.tap do |new_hash|
-        sorted_keys.each do |key|
-          new_hash[key] = change_value(hash[key])
+        def sort
+          {}.tap do |new_hash|
+            sorted_keys.each do |key|
+              new_hash[key] = change_value(hash[key])
+            end
+          end
         end
-      end
-    end
 
-    private
+        private
 
-    def sorted_keys
-      hash.keys.sort
-    end
+        def sorted_keys
+          hash.keys.sort
+        end
 
-    def change_value(value)
-      return value unless value.is_a?(Hash) && recursive
-      value.sort_keys(recursive: true)
-    end
+        def change_value(value)
+          return value unless value.is_a?(Hash) && recursive
+          value.sort_keys(recursive: true)
+        end
 
-    attr_reader :hash, :recursive
+        attr_reader :hash, :recursive
+      end
+    end
   end
 end