lite-ruby 1.0.27 → 1.1.0

data/lib/lite/ruby.rb

@@ -4,11 +4,14 @@
   require "lite/ruby/#{filename}"
 end
 
+%w[date time].each do |filename|
+  require "lite/ruby/helpers/#{filename}_helper"
+end
+
 %w[
   array boolean date enumerable hash integer kernel numeric object open_struct range string
   struct time
 ].each do |filename|
-  require "lite/ruby/helpers/#{filename}_helper" if %w[date time].include?(filename)
   require "lite/ruby/#{filename}"
 end
 

data/lib/lite/ruby/array.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 if Lite::Ruby.configuration.monkey_patches.include?('array')
+  require 'lite/ruby/safe/array' unless defined?(ActiveSupport)
+
   class Array
 
     def assert_min_values!(*valid_values)
@@ -109,10 +111,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
     # rubocop:enable Metrics/PerceivedComplexity, Style/GuardClause, Style/IfInsideElse
     # rubocop:enable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
 
-    def deep_dup
-      map(&:deep_dup)
-    end
-
     def delete_first
       self[1..-1]
     end
@@ -160,11 +158,8 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
     end
 
     def except!(*values)
-      replace(except(*values))
-    end
-
-    def from(position)
-      self[position, size] || []
+      reject! { |val| values.include?(val) }
+      self
     end
 
     def fulfill(value, amount)
@@ -183,54 +178,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
       collection << self[-rem, rem]
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-    def in_groups(number, fill_with = nil)
-      collection_size = size
-      division = collection_size.div(number)
-      modulo = collection_size % number
-
-      collection = []
-      start = 0
-      number.times do |int|
-        mod_gt_zero = modulo.positive?
-        grouping = division + (mod_gt_zero && modulo > int ? 1 : 0)
-        collection << last_group = slice(start, grouping)
-        last_group << fill_with if (fill_with != false) && mod_gt_zero && (grouping == division)
-        start += grouping
-      end
-
-      return collection unless block_given?
-
-      collection.each { |val| yield(val) }
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
-    def in_groups_of(number, fill_with = nil)
-      if number.to_i <= 0
-        raise ArgumentError, "Group size must be a positive integer, was #{number.inspect}"
-      elsif fill_with == false
-        collection = self
-      else
-        padding = (number - size % number) % number
-        collection = dup.concat(Array.new(padding, fill_with))
-      end
-
-      sliced_collection = collection.each_slice(number)
-      return sliced_collection.to_a unless block_given?
-
-      sliced_collection { |val| yield(val) }
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
-
     def indexes(value)
       array = []
       each_with_index { |val, i| array << i if value == val }
       array
     end
 
-    alias indices indexes
-
     def merge(*values)
       dup.merge!(*values)
     end
@@ -252,7 +205,8 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
     end
 
     def only!(*values)
-      replace(only(*values))
+      select! { |val| values.include?(val) }
+      self
     end
 
     def position(value)
@@ -284,7 +238,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
     end
 
     def promote!(value)
-      replace(promote(value))
+      sort_by! { |val| val == value ? -1 : 0 }
     end
 
     def rand_sample(max = nil)
@@ -292,10 +246,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
       sample(amount)
     end
 
-    def reject_values(*args)
-      reject { |val| args.include?(val) }
-    end
-
     def rposition(value)
       idx = rindex(value)
       return idx if idx.nil?
@@ -307,36 +257,13 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
       delete_at(Random.rand(size - 1))
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
-    def split(number = nil)
-      array = [[]]
-
-      if block_given?
-        each { |val| yield(val) ? (array << []) : (array.last << val) }
-      else
-        dup_arr = dup
-
-        until dup_arr.empty?
-          if (idx = dup_arr.index(number))
-            array.last << dup_arr.shift(idx)
-            dup_arr.shift
-            array << []
-          else
-            array.last << arr.shift(dup_arr.size)
-          end
-        end
-      end
-
-      array
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
-
     def strip
       reject(&:blank?)
     end
 
     def strip!
-      replace(strip)
+      reject!(&:blank?)
+      self
     end
 
     def swap(from, to)
@@ -344,26 +271,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('array')
       self
     end
 
-    def to(position)
-      return first(position + 1) if position >= 0
-
-      self[0..position]
-    end
-
-    # rubocop:disable Metrics/CyclomaticComplexity
-    def to_sentence(options = {})
-      words_connector = options[:words_connector] || ', '
-      two_words_connector = options[:two_words_connector] || ' and '
-      last_word_connector = options[:last_word_connector] || ', and '
-
-      case size
-      when 0 then ''
-      when 1 then self[0].to_s.dup
-      when 2 then "#{self[0]}#{two_words_connector}#{self[1]}"
-      else "#{self[0...-1].join(words_connector)}#{last_word_connector}#{self[-1]}"
-      end
-    end
-    # rubocop:enable Metrics/CyclomaticComplexity
+    alias extract! except!
+    alias indices indexes
+    alias reject_values except
+    alias reject_values! except!
+    alias select_values only
+    alias select_values! only!
 
   end
 end

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/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/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/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/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 = str.gsub!(/::/, '/') || str
+          str = str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2') || str
+          str = str.gsub!(/([a-z\d])([A-Z])/, '\1_\2') || str
+          str = str.tr!(' -', '_') || str
+          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