lite-ruby 1.0.30 → 1.1.3

data/lib/lite/ruby/boolean.rb

@@ -7,12 +7,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('boolean')
       self
     end
 
-    alias to_b to_bool
-
     def to_i
       0
     end
 
+    alias to_b to_bool
+
   end
 
   class TrueClass
@@ -21,11 +21,11 @@ if Lite::Ruby.configuration.monkey_patches.include?('boolean')
       self
     end
 
-    alias to_b to_bool
-
     def to_i
       1
     end
 
+    alias to_b to_bool
+
   end
 end

data/lib/lite/ruby/enumerable.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
+  require 'lite/ruby/safe/enumerable' unless defined?(ActiveSupport)
+
   module Enumerable
 
     def cluster
@@ -20,7 +22,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     end
 
     def deduce(identity = 0, &block)
-      if block_given?
+      if defined?(yield)
         map(&block).deduce(identity)
       else
         inject { |acc, val| acc - val } || identity
@@ -46,7 +48,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     def exactly?(num)
       found_count = 0
 
-      if block_given?
+      if defined?(yield)
         each { |*opt| found_count += 1 if yield(*opt) }
       else
         each { |opt| found_count += 1 if opt }
@@ -61,23 +63,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     end
     # rubocop:enable Style/CaseEquality
 
-    def exclude?(object)
-      !include?(object)
-    end
-
-    def excluding(*elements)
-      elements.flatten!(1)
-      reject { |element| elements.include?(element) }
-    end
-
-    alias without excluding
-
     def expand
       map { |val| val.is_a?(Enumerable) ? val.expand : val }
     end
 
     def exponential(identity = 0, &block)
-      if block_given?
+      if defined?(yield)
         map(&block).exponential(identity)
       else
         inject { |acc, val| acc**val } || identity
@@ -88,20 +79,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
       each_with_object(Hash.new(0)) { |val, hash| hash[val] += 1 }
     end
 
-    alias occurrences frequency
-
     # rubocop:disable Style/CaseEquality
     def incase?(object)
       any? { |val| object === val }
     end
     # rubocop:enable Style/CaseEquality
 
-    def including(*elements)
-      to_a.including(*elements)
-    end
-
-    alias with including
-
     # rubocop:disable Metrics/MethodLength
     def interpose(sep, &block)
       enum = Enumerator.new do |val|
@@ -128,19 +111,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     end
     # rubocop:enable Metrics/MethodLength
 
-    def many?
-      found_count = 0
-
-      if block_given?
-        any? do |val|
-          found_count += 1 if yield(val)
-          found_count > 1
-        end
-      else
-        any? { (found_count += 1) > 1 }
-      end
-    end
-
     def modulate(modulo)
       if modulo == 1
         to_a
@@ -153,7 +123,8 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
       end
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
     def occur(amount = nil)
       result = Hash.new { |hash, key| hash[key] = [] }
 
@@ -162,7 +133,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
         result[key] << item
       end
 
-      if block_given?
+      if defined?(yield)
         result.select! { |_key, values| yield(values.size) }
       else
         raise ArgumentError, 'Invalid occur amount' unless amount
@@ -176,18 +147,11 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
 
       result.values.flatten.uniq
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-
-    def pluck(*keys)
-      if keys.many?
-        map { |element| keys.map { |key| element[key] } }
-      else
-        map { |element| element[keys.first] }
-      end
-    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
     def produce(identity = 0, &block)
-      if block_given?
+      if defined?(yield)
         map(&block).produce(identity)
       else
         inject { |acc, val| acc * val } || identity
@@ -195,7 +159,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     end
 
     def quotient(identity = 0, &block)
-      if block_given?
+      if defined?(yield)
         map(&block).quotient(identity)
       else
         inject { |acc, val| acc / val } || identity
@@ -205,7 +169,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
     def several?
       found_count = 0
 
-      if block_given?
+      if defined?(yield)
         each { |*opt| found_count += 1 if yield(*opt) }
       else
         each { |opt| found_count += 1 if opt }
@@ -246,5 +210,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
       end
     end
 
+    alias occurrences frequency
+
   end
 end

data/lib/lite/ruby/hash.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 if Lite::Ruby.configuration.monkey_patches.include?('hash')
+  require 'lite/ruby/safe/hash' unless defined?(ActiveSupport)
+
   class Hash
 
     class << self
@@ -102,7 +104,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
     end
     # rubocop:enable Style/GuardClause
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
     def collate(*others)
       hash = {}
 
@@ -121,18 +123,18 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       hash.each_value(&:flatten!)
       hash
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     def collate!(other_hash)
       replace(collate(other_hash))
     end
 
-    def collect_keys
-      collect { |key, _| yield(key) }
+    def collect_keys(&block)
+      keys.map(&block)
     end
 
-    def collect_values
-      collect { |_, val| yield(val) }
+    def collect_values(&block)
+      values.map(&block)
     end
 
     def dearray_values(idx = 0)
@@ -161,39 +163,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       replace(dearray_singular_values)
     end
 
-    # rubocop:disable Style/CaseEquality
-    def deep_dup
-      hash = dup
-
-      each_pair do |key, value|
-        if key.frozen? && ::String === key
-          hash[key] = value.deep_dup
-        else
-          hash.delete(key)
-          hash[key.deep_dup] = value.deep_dup
-        end
-      end
-
-      hash
-    end
-    # rubocop:enable Style/CaseEquality
-
-    def deep_merge(other_hash, &block)
-      dup.deep_merge!(other_hash, &block)
-    end
-
-    def deep_merge!(other_hash, &block)
-      merge!(other_hash) do |key, this_val, other_val|
-        if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-          this_val.deep_merge(other_val, &block)
-        elsif block_given?
-          yield(key, this_val, other_val)
-        else
-          other_val
-        end
-      end
-    end
-
     def delete_unless
       delete_if { |key, val| !yield(key, val) }
     end
@@ -232,18 +201,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       h1.merge(h2)
     end
 
-    def except(*keys)
-      dup.except!(*keys)
-    end
-
-    def except!(*keys)
-      keys.each_with_object(self) { |key, _| delete(key) }
-    end
-
-    def extract!(*keys)
-      keys.each_with_object(self) { |key, hash| hash[key] = delete(key) if key?(key) }
-    end
-
     def hmap(&block)
       dup.hmap!(&block)
     end
@@ -274,15 +231,15 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       unknown_keys.empty?
     end
 
-    alias has_keys? keys?
-
     def nillify
       dup.nillify!
     end
 
     def nillify!
       each do |key, val|
-        self[key] = nil if !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?)
+        next if val.nil?
+
+        self[key] = nil if respond_to?(:blank?) ? val.blank? : !val
       end
     end
 
@@ -299,8 +256,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       unknown_keys.empty?
     end
 
-    alias has_only_keys? only_keys?
-
     def pair?(key, value)
       self[key] == value
     end
@@ -324,14 +279,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       keys.each_with_object(self) { |(key, val), hash| hash[val] = delete(key) if hash[key] }
     end
 
-    def reverse_merge(other_hash)
-      other_hash.merge(self)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge(other_hash))
-    end
-
     def sample
       key = sample_key
       [key, fetch(key)]
@@ -349,7 +296,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
     end
 
     def sample_key!
-      key, = sample
+      key, _val = sample
       delete(key)
       key
     end
@@ -381,55 +328,28 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       omit
     end
 
-    alias only slice
-    alias only! slice!
-
-    def stringify_keys
-      each_with_object({}) { |(key, val), hash| hash[key.to_s] = val }
-    end
-
-    def stringify_keys!
-      replace(stringify_keys)
-    end
-
     def strip
-      select { |_, val| !val.blank? }
+      reject { |_, val| respond_to?(:blank?) ? val.blank? : !val }
     end
 
     def strip!
-      reject! { |_, val| val.blank? }
-    end
-
-    def symbolize_keys
-      each_with_object({}) do |(key, val), hash|
-        new_key = begin
-                    key.to_s.to_sym
-                  rescue StandardError
-                    key
-                  end
-
-        hash[new_key] = val
-      end
-    end
-
-    def symbolize_keys!
-      replace(symbolize_keys)
+      reject! { |_, val| respond_to?(:blank?) ? val.blank? : !val }
     end
 
     # rubocop:disable Metrics/MethodLength
     def symbolize_and_underscore_keys
       each_with_object({}) do |(key, val), hash|
         new_key = begin
-                    key.to_s
-                       .gsub(/::/, '/')
-                       .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-                       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                       .tr(' -', '_')
-                       .downcase
-                       .to_sym
-                  rescue StandardError
-                    key
-                  end
+          str = key.dup.to_s
+          str.gsub!(/::/, '/') || str
+          str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2') || str
+          str.gsub!(/([a-z\d])([A-Z])/, '\1_\2') || str
+          str.tr!(' -', '_') || str
+          str.downcase!
+          str.to_sym
+        rescue StandardError
+          key
+        end
 
         hash[new_key] = val
       end
@@ -444,8 +364,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       JSON.parse(to_json, object_class: OpenStruct)
     end
 
-    alias to_o to_object
-
     def to_open_struct(lazy: true)
       struct = OpenStruct.new(self)
       struct.methods(lazy)
@@ -462,13 +380,13 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
     end
 
     def update_keys
-      return to_enum(:update_keys) unless block_given?
+      return to_enum(:update_keys) unless defined?(yield)
 
       replace(each_with_object({}) { |(key, val), hash| hash[yield(key)] = val })
     end
 
     def update_values
-      return to_enum(:update_values) unless block_given?
+      return to_enum(:update_values) unless defined?(yield)
 
       replace(each_with_object({}) { |(key, val), hash| hash[key] = yield(val) })
     end
@@ -478,5 +396,13 @@ if Lite::Ruby.configuration.monkey_patches.include?('hash')
       respond_to?(:blank?) ? value.blank? : !value
     end
 
+    alias has_keys? keys?
+    alias has_only_keys? only_keys?
+    alias map_keys collect_keys
+    alias map_values collect_values
+    alias only slice
+    alias only! slice!
+    alias to_o to_object
+
   end
 end

data/lib/lite/ruby/helpers/time_helper.rb

@@ -9,9 +9,9 @@ if Lite::Ruby.configuration.monkey_patches.include?('time')
           hour: '%H',
           hour_blank: '%k',
           hour_padded: '%H',
-          hour_12: '%I',
-          hour_12_padded: '%I',
-          hour_12_blank: '%l',
+          hour12: '%I',
+          hour12_padded: '%I',
+          hour12_blank: '%l',
           minute: '%M',
           second: '%S',
           ampm: '%P',
@@ -25,29 +25,29 @@ if Lite::Ruby.configuration.monkey_patches.include?('time')
           time_padded: '%H:%M',
           time_tz: '%H:%M %z',
           time_tzn: '%H:%M %Z',
-          time_12: '%I:%M %P',
-          time_12_padded: '%I:%M %P',
-          time_12_blank: '%l:%M %P',
-          time_12_tz: '%I:%M %P %z',
-          time_12_tzn: '%I:%M %P %Z',
+          time12: '%I:%M %P',
+          time12_padded: '%I:%M %P',
+          time12_blank: '%l:%M %P',
+          time12_tz: '%I:%M %P %z',
+          time12_tzn: '%I:%M %P %Z',
           daytime: '%B %-d %H:%M',
           daytime_abbr: '%b %-d %H:%M',
           daytime_iso: '%m-%d %H:%M',
-          daytime_12: '%B %-d %I:%M %P',
-          daytime_12_abbr: '%b %-d %I:%M %P',
-          daytime_12_iso: '%m-%d %I:%M %P',
+          daytime12: '%B %-d %I:%M %P',
+          daytime12_abbr: '%b %-d %I:%M %P',
+          daytime12_iso: '%m-%d %I:%M %P',
           datetime: '%B %-d, %Y %H:%M',
           datetime_abbr: '%b %-d, %Y %H:%M',
           datetime_iso: '%Y-%m-%d %H:%M',
-          datetime_12: '%B %-d, %Y %I:%M %P',
-          datetime_12_abbr: '%b %-d, %Y %I:%M %P',
-          datetime_12_iso: '%Y-%m-%d %I:%M %P',
+          datetime12: '%B %-d, %Y %I:%M %P',
+          datetime12_abbr: '%b %-d, %Y %I:%M %P',
+          datetime12_iso: '%Y-%m-%d %I:%M %P',
           datetime_tzn: '%B %-d, %Y %H:%M %Z',
           datetime_abbr_tzn: '%b %-d, %Y %H:%M %Z',
           datetime_iso_tzn: '%Y-%m-%d %H:%M %z',
-          datetime_12_tzn: '%B %-d, %Y %I:%M %P %Z',
-          datetime_12_abbr_tzn: '%b %-d, %Y %I:%M %P %Z',
-          datetime_12_iso_tzn: '%Y-%m-%d %I:%M %P %z'
+          datetime12_tzn: '%B %-d, %Y %I:%M %P %Z',
+          datetime12_abbr_tzn: '%b %-d, %Y %I:%M %P %Z',
+          datetime12_iso_tzn: '%Y-%m-%d %I:%M %P %z'
         }.freeze
         TIME_UNITS = {
           h: 'H',
@@ -57,11 +57,11 @@ if Lite::Ruby.configuration.monkey_patches.include?('time')
           HOUR: 'k',
           hour_blank: 'k',
           hhh: 'I',
-          hour_12: 'I',
-          hour_12_padded: 'I',
+          hour12: 'I',
+          hour12_padded: 'I',
           hhhh: 'l',
-          HOUR_12: 'l',
-          hour_12_blank: 'l',
+          HOUR12: 'l',
+          hour12_blank: 'l',
           n: 'M',
           minute: 'M',
           s: 'S',