darthjee-core_ext 1.7.4 → 3.0.0

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

@@ -3,17 +3,16 @@
 module Darthjee
   module CoreExt
     module Hash
-      # Module holding methods responsible for camelizing
-      # keys of a hash
+      # Module holding methods for camelizing keys of a hash
       #
       # @api public
       module Cameliazable
-        # Change keys to CamelCase without changing the
-        # original hash
+        # Change keys to CamelCase without changing the original hash
         #
         # @return [::Hash] new hash with changed keys
         # @param [::Hash] options options of camelization
-        # @option options [::Boolean] uppercase_first_letter: flag
+        # @option options [::TrueClass,::FalseClass]
+        #   uppercase_first_letter: flag
         #   defining the type of CamelCase
         #
         # @see Hash::KeyChanger#camelize_keys
@@ -28,28 +27,28 @@ module Darthjee
         # @example
         #   hash = { first_key: 1, 'second_key' => 2 }
         #   options = { uppercase_first_letter: false }
-        #   hash.camelize_keys(options) # returns {
+        #   hash.camelize_keys(**options) # returns {
         #                               #   firstKey: 1,
         #                               #   'secondKey' => 2
         #                               # }
         #
-        def camelize_keys(options = {})
-          dup.camelize_keys!(options)
+        def camelize_keys(**)
+          dup.camelize_keys!(**)
         end
 
-        # Change keys to CamelCase changing the
-        # original hash
+        # Change keys to CamelCase changing the original hash
         #
         # @return [::Hash] new hash with changed keys
         # @param [::Hash] options options of camelization
-        # @option options [::Boolean] uppercase_first_letter: flag
+        # @option options [::TrueClass,::FalseClass]
+        #   uppercase_first_letter: flag
         #   defining the type of CamelCase
         #
         # @example (see #camelize_keys)
         #
         # @see #camelize_keys
-        def camelize_keys!(options = {})
-          Hash::KeyChanger.new(self).camelize_keys(options)
+        def camelize_keys!(**)
+          Hash::KeyChanger.new(self).camelize_keys(**)
         end
 
         # Camelize all keys in the hash as `key.camelize(:lower)
@@ -63,8 +62,8 @@ module Darthjee
         #                            #   'secondKey' => 2
         #                            # }
         #
-        def lower_camelize_keys(options = {})
-          dup.lower_camelize_keys!(options)
+        def lower_camelize_keys(**)
+          dup.lower_camelize_keys!(**)
         end
 
         # Camelize all keys in the hash
@@ -72,18 +71,50 @@ module Darthjee
         # @return [::Hash] self after changing the keys
         #
         # @example (see #lower_camelize_keys)
-        def lower_camelize_keys!(options = {})
+        def lower_camelize_keys!(**options)
           options = options.merge(uppercase_first_letter: false)
 
-          camelize_keys!(options)
+          camelize_keys!(**options)
         end
 
-        def underscore_keys(options = {})
-          dup.underscore_keys!(options)
+        # Change all keys to be snakecase
+        #
+        # THis method does not change the original hash
+        #
+        # @param options [::Hash]
+        # @option options recursive [::TrueClass,::FalseClass]
+        #   flag for recursive transformation
+        #
+        # @see Hash::KeyChanger#change_keys
+        #
+        # @example underscoring all keys
+        #   hash = { firstKey: 1, 'SecondKey' => 2 }
+        #
+        #   hash.underscore_keys  # returns {
+        #                         #   first_key: 1,
+        #                         #   'second_key' => 2
+        #                         # }
+        #
+        # @return [::Hash]
+        def underscore_keys(**)
+          dup.underscore_keys!(**)
         end
 
-        def underscore_keys!(options = {})
-          Hash::KeyChanger.new(self).underscore_keys(options)
+        # Change all keys to be snakecase
+        #
+        # THis method changes the original hash
+        #
+        # @param options [::Hash]
+        # @option options recursive [::TrueClass,::FalseClass]
+        #   flag for recursive transformation
+        #
+        # @see Hash::KeyChanger#change_keys
+        #
+        # @example (see #underscore_keys)
+        #
+        # @return [::Hash]
+        def underscore_keys!(**)
+          Hash::KeyChanger.new(self).underscore_keys(**)
         end
       end
     end

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

@@ -7,6 +7,8 @@ module Darthjee
       #
       # @api private
       #
+      # @author Darthjee
+      #
       # @see Darthjee::CoreExt::Hash#chain_fetch
       class ChainFetcher
         def initialize(hash, *keys, &block)
@@ -21,13 +23,23 @@ module Darthjee
         #
         # @return [Object] value fetched from array
         def fetch
-          block.present? ? fetch_with_block : fetch_without_block
+          return fetch_with_block if block.present?
+
+          fetch_without_block
         end
 
         private
 
+        # @private
         attr_reader :hash, :keys, :block
 
+        # @private
+        #
+        # Perform chain fetch when block is given
+        #
+        # The block will be called in case a key is missed
+        #
+        # @return [Object]
         def fetch_with_block
           @hash = hash.fetch(keys.shift) do |*args|
             missed_keys = keys
@@ -37,6 +49,11 @@ module Darthjee
           hash
         end
 
+        # @private
+        #
+        # Perform chain fetch when block is not given
+        #
+        # @return [Object]
         def fetch_without_block
           @hash = hash.fetch(keys.shift) until keys.empty?
           hash

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Darthjee
+  module CoreExt
+    module Hash
+      # Methods responsible for changing hash values
+      #
+      # @api public
+      #
+      # @author Darthjee
+      module Changeable
+        # Creates a new hash with changes in its values
+        #
+        # @param options [::Hash]
+        # @option options [::TrueClass,::FalseClass]
+        #   recursive (true) flag indicating recursive sorting
+        # @option options [::TrueClass,::FalseClass]
+        #   skip_inner (true) Flag indicating to skip running
+        #   transformation on Hash objects
+        #
+        # @yield (value) changing value block
+        #
+        # @return [::Hash]
+        #
+        # @example Simple Usage
+        #   hash = { a: 1, b: 2 }
+        #   hash.change_values do |value|
+        #     value + 1
+        #   end                     # returns { a: 2, b: 3 }
+        #
+        # @example Skipping inner hash transformation
+        #   hash = { a: 1, b: { c: 1 } }
+        #
+        #   hash.change_values(&:to_s)) # returns {
+        #                               #   a: "1",
+        #                               #   b: { c: "1" }
+        #                               # }
+        #
+        # @example Not skipping inner hash transformation
+        #   hash = { a: 1, b: { c: 1 } }
+        #
+        #   hash.change_values(skip_inner: false, &:to_s))
+        #                               # returns {
+        #                               #   a: "1",
+        #                               #   b: "{:c=>1}"
+        #                               # }
+        def change_values(**, &)
+          deep_dup.change_values!(**, &)
+        end
+
+        # Changes the values of a hash
+        #
+        # @param options [::Hash]
+        # @option options [::TrueClass,::FalseClass]
+        #   recursive (true) flag indicating recursive sorting
+        # @option options [::TrueClass,::FalseClass]
+        #   skip_inner (true) Flag indicating to skip running
+        #   transformation on Hash objects
+        #
+        # @yield (value) changing value block
+        #
+        # @return [::Hash]
+        #
+        # @example (see change_values)
+        #
+        # @example Changing inner hash
+        #   inner_hash = { c: 2 }
+        #   hash = { a: 1, b: inner_hash }
+        #
+        #   hash.change_values!(&:to_s)
+        #
+        #   inner_hash # changed to { c: "2" }
+        #
+        # @example Not changing inner hash
+        #   inner_hash = { c: 2 }
+        #   hash = { a: 1, b: inner_hash }
+        #
+        #   hash.change_values!(skip_inner: false, &:to_s)
+        #
+        #   hash       # changed to { a: "1", b: "{:c=>2}" }
+        #   inner_hash # still      { c: 2 }
+        def change_values!(**, &)
+          Hash::ValueChanger.new(**, &).change(self)
+        end
+      end
+    end
+  end
+end

data/lib/darthjee/core_ext/hash/deep_hash_constructor/setter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Darthjee
+  module CoreExt
+    module Hash
+      class DeepHashConstructor
+        # @api private
+        #
+        # Class responsible for setting value localized inside hash
+        #
+        # @example Simple usage
+        #   hash   = {}
+        #   base   = 'person'
+        #   setter = Darthjee::CoreExt::Hash::DeepHashConstructor::Setter.new(
+        #     hash, base
+        #   )
+        #
+        #   setter.set('age', 21)
+        #
+        #   hash # changed to {
+        #        #   'person' => {
+        #        #     'age' => 21,
+        #        #   }
+        #        # }
+        class Setter
+          # @param hash [Hash] hash to be changed
+          # @param base_key [::String] base key of hash where
+          #   subhash will be created
+          def initialize(hash, base_key)
+            @hash     = hash
+            @base_key = base_key
+          end
+
+          # Sets a value in the correct key inside the hash
+          #
+          # @param key [::String,::NilClass] key where value will live
+          # @param value [::Object] value to be set
+          #
+          # @return [::Object] value
+          #
+          # @example (see DeepHashConstructor)
+          #
+          # @example With Array index
+          #   hash   = {}
+          #   base   = 'person[0]'
+          #   setter = Darthjee::CoreExt::Hash::DeepHashConstructor::Setter.new(
+          #     hash, base
+          #   )
+          #
+          #   setter.set('age', 21)
+          #
+          #   hash # changed to {
+          #        #   'person' => [{
+          #        #     'age' => 21,
+          #        #   }]
+          #        # }
+          def set(key, value)
+            return hash[base_key] = value unless key || index
+            return array[index]   = value unless key
+
+            sub_hash[key] = value
+          end
+
+          private
+
+          # @private
+          attr_reader :hash, :base_key
+
+          # @private
+          # Extract index of array from base_key
+          #
+          # @return [::NilClass,::Integer]
+          def index
+            return @index if instance_variable_defined?('@index')
+
+            match = base_key.match(/\[([^)]+)\]/)
+            return @index = nil unless match
+
+            @index = match[1].to_i
+          end
+
+          # @private
+          # Returns array that will receive value
+          #
+          # This array is only created / used when base_key
+          # contains index
+          #
+          # @return [::Array]
+          def array
+            return @array if instance_variable_defined?('@array')
+
+            key_without_index = base_key.tr("[#{index}]", '')
+
+            @array = hash[key_without_index] ||= []
+          end
+
+          # @private
+          # Returns sub hash that will receive the value
+          #
+          # This sub_hash is only build when key is not nil
+          #
+          # @return [::Hash]
+          def sub_hash
+            return array[index] ||= {} if index
+
+            hash[base_key] ||= {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,90 +3,155 @@
 module Darthjee
   module CoreExt
     module Hash
+      # @api private
+      #
+      # @author Darthjee
+      #
+      # Class responsible for creating a Hash deep hash
+      #
+      # Deep hash construction happens when a hash of one layer
+      # (no sub hashes) has keys that, once explitted, can be
+      # assembled in a hash with many layers
+      #
+      # @see Transformable#squash
+      # @see Transformable#to_deep_hash
+      #
+      # @example (see Transformable#to_deep_hash)
+      # @example General Usage
+      #   hash = {
+      #     'account.person.name[0]' => 'John',
+      #     'account.person.name[1]' => 'Wick',
+      #     'account.person.age'     =>  20,
+      #     'account.number'         => '102030',
+      #     :'house.number'          => 67,
+      #     :'house.zip'             => 12_345
+      #   }
+      #
+      #   constructor = Darthjee::CoreExt::Hash::DeepHashConstructor.new('.')
+      #
+      #   constructor.deep_hash(hash)  # returns {
+      #                                #   'account' => {
+      #                                #     'person' => {
+      #                                #       'name'   => ['John', 'Wick'],
+      #                                #       'age'    =>  20
+      #                                #     },
+      #                                #     'number' => '102030',
+      #                                #   },
+      #                                #   'house' => {
+      #                                #     'number' => 67,
+      #                                #     'zip'    => 12345
+      #                                #   }
+      #                                # }
       class DeepHashConstructor
-        attr_accessor :separator
+        autoload :Setter, "#{PATH}/hash/deep_hash_constructor/setter"
 
-        def initialize(separator)
+        # @param separator [::String] keys splitter
+        def initialize(separator = '.')
           @separator = separator
         end
 
-        def deep_hash(object)
-          if object.is_a? Array
-            array_deep_hash(object)
-          elsif object.is_a? Hash
-            hash_deep_hash(object)
-          else
-            object
+        # Performs deep hash transformation
+        #
+        # @param hash [::Hash] On layered hash
+        #
+        # @return [::Hash] Many layered hash
+        #
+        # @example (see DeepHashConstructor)
+        def deep_hash(hash)
+          break_keys(hash).tap do
+            hash.keys.each do |key|
+              hash[key] = deep_hash_value(hash[key])
+            end
           end
         end
 
         private
 
-        def array_deep_hash(array)
-          array.map do |value|
-            value.is_a?(Hash) ? deep_hash(value) : value
-          end
-        end
-
-        def hash_deep_hash(hash)
-          {}.tap do |new_hash|
-            hash.each do |k, v|
-              base_key, child_key = split_key(k, separator)
-              set_deep_hash_positioned_value(new_hash, base_key, v, child_key)
-            end
+        # @private
+        attr_reader :separator
 
-            new_hash.each do |k, v|
-              new_hash[k] = deep_hash(v)
-            end
+        # @private
+        # break the keys creating sub-hashes
+        #
+        # @param hash [::Hash] hash to be broken
+        #
+        # @example Breaking many level keys
+        #   hash = {
+        #     'account.person.name[0]' => 'John',
+        #     'account.person.name[1]' => 'Wick',
+        #     'account.person.age'     =>  20,
+        #     'account.number'         => '102030',
+        #     :'house.number'          => 67,
+        #     :'house.zip'             => 12_345
+        #   }
+        #
+        #   constructor = Darthjee::CoreExt::Hash::DeepHashConstructor.new('.')
+        #
+        #   constructor.send(:break_keys, hash)
+        #
+        #   # Returns {
+        #   #   'account' => {
+        #   #     %w[person name[0]] => 'John',
+        #   #     %w[person name[1]] => 'Wick',
+        #   #     %w[person age]     =>  20,
+        #   #     %w[number]         => '102030'
+        #   #   },
+        #   #   'house' => {
+        #   #     %w[number] => 67,
+        #   #     %w[zip]    => 12_345
+        #   #   }
+        #   # }
+        #
+        # @return [Hash]
+        def break_keys(hash)
+          hash.keys.each do |key|
+            value = hash.delete(key)
+            base_key, child_key = split_key(key, separator)
+            Setter.new(hash, base_key).set(child_key, value)
           end
-        end
 
-        def split_key(key, separator)
-          separator_rxp = separator == '.' ? "\\#{separator}" : separator
-          skipper = "[^#{separator}]"
-          regexp = Regexp.new("^(#{skipper}*)#{separator_rxp}(.*)")
-          match = key.match(regexp)
-
-          match ? match[1..2] : key
+          hash
         end
 
-        def set_deep_hash_array_value(hash, base_key, index, value, key = nil)
-          key_without_index = base_key.gsub("[#{index}]", '')
-          hash[key_without_index] ||= []
+        # @private
+        #
+        # Recursively proccess a value calling deep hash on it
+        #
+        # @return [::Object]
+        def deep_hash_value(object)
+          return array_deep_hash(object) if object.is_a? Array
+          return deep_hash(object) if object.is_a? Hash
 
-          if key.nil?
-            hash[key_without_index][index] = value
-          else
-            hash[key_without_index][index] ||= {}
-            hash[key_without_index][index][key] = value
-          end
+          object
         end
 
-        def set_deep_hash_positioned_value(new_hash, base_key, value, child_key)
-          index = array_index(base_key)
-
-          if index
-            set_deep_hash_array_value(
-              new_hash, base_key, index,
-              value, child_key
-            )
-          else
-            set_deep_hash_value(new_hash, base_key, value, child_key)
+        # @private
+        #
+        # Map array performing deep hash on its Hash elements
+        #
+        # @param array [::Array] array to be mapped
+        #
+        # @return [::Array]
+        def array_deep_hash(array)
+          array.map do |value|
+            deep_hash_value(value)
           end
         end
 
-        def array_index(key)
-          match = key.match(/\[([^)]+)\]/)
-          match && match[1].to_i
-        end
+        # @private
+        #
+        # Split key into array of keys
+        #
+        # @param key [::String,::Symbol] key to be splitted
+        # @param separator [::String] string of key splitting
+        #
+        # @return [::Array<::String>,::String]
+        def split_key(key, separator)
+          keys = key.is_a?(Array) ? key : key.to_s.split(separator)
 
-        def set_deep_hash_value(hash, base_key, value, key = nil)
-          if key.nil?
-            hash[base_key] = value
-          else
-            hash[base_key] ||= {}
-            hash[base_key][key] = value
-          end
+          return keys unless keys.second
+
+          [keys.shift, keys]
         end
       end
     end