lite-ruby 1.0.28 → 1.1.1

data/lib/lite/ruby/numeric.rb

@@ -15,23 +15,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       self <= upper ? self : upper
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def clamp(minimum, maximum = nil)
-      if minimum.is_a?(Range)
-        maximum = minimum.max
-        minimum = minimum.min
-      end
-
-      if minimum > self
-        minimum
-      elsif maximum < self
-        maximum
-      else
-        self
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
     def close?(number, epsilon = 0.01)
       return self == number if epsilon.zero?
 
@@ -79,28 +62,22 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       self == num
     end
 
-    alias eq? equal_to?
-
     def fraction
       (self - truncate).abs
     end
 
     def fraction?
-      fraction != 0.0
+      fraction.to_d != 0.0.to_d
     end
 
     def greater_than?(num)
       num < self
     end
 
-    alias gt? greater_than?
-
     def greater_than_or_equal_to?(num)
       num <= self
     end
 
-    alias gteq? greater_than_or_equal_to?
-
     def increment(amount = 1.0)
       self + amount
     end
@@ -113,14 +90,10 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       num > self
     end
 
-    alias lt? less_than?
-
     def less_than_or_equal_to?(num)
       num >= self
     end
 
-    alias lteq? less_than_or_equal_to?
-
     def markdown_percentage(percent)
       to_f * ((100.0 - percent.to_f) / 100.0)
     end
@@ -143,10 +116,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       self != num
     end
 
-    alias not_eq? not_equal_to?
-    alias inequal_to? not_equal_to?
-    alias ineq? not_equal_to?
-
     def ordinal
       return 'th' if (11..13).cover?(abs % 100)
 
@@ -173,7 +142,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       to_s.rjust(precision, pad_number.to_s)
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def pad_precision(options = {})
       pad_number = options[:pad_number] || 0
       precision = options[:precision] || 2
@@ -190,7 +159,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
         string[0..(ljust_count - 1)]
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def percentage_of(number)
       return 0 if zero? || number.zero?
@@ -206,8 +175,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       (self - value)..(self + value)
     end
 
-    alias plus_minus range
-
     def root(num)
       self**(1.0 / num)
     end
@@ -263,5 +230,15 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       end
     end
 
+    alias eq? equal_to?
+    alias gt? greater_than?
+    alias gteq? greater_than_or_equal_to?
+    alias inequal_to? not_equal_to?
+    alias ineq? not_equal_to?
+    alias lt? less_than?
+    alias lteq? less_than_or_equal_to?
+    alias not_eq? not_equal_to?
+    alias plus_minus range
+
   end
 end

data/lib/lite/ruby/object.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 if Lite::Ruby.configuration.monkey_patches.include?('object')
+  require 'lite/ruby/safe/object' unless defined?(ActiveSupport)
+
   class Object
 
     FALSE_VALUES ||= %w[
@@ -14,14 +16,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       is_a?(Array)
     end
 
-    def blank?
-      object = self
-      object = object.strip if respond_to?(:strip)
-      return object.empty? if respond_to?(:empty?)
-
-      !object
-    end
-
     def bool?
       true? || false?
     end
@@ -35,14 +29,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       is_a?(Date)
     end
 
-    def deep_dup
-      duplicable? ? dup : self
-    end
-
-    def duplicable?
-      true
-    end
-
     # rubocop:disable Style/YodaCondition
     def false?
       false == self
@@ -87,14 +73,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       to_s == to_s.reverse
     end
 
-    def present?
-      !blank?
-    end
-
-    def presence
-      self if present?
-    end
-
     def range?
       is_a?(Range)
     end
@@ -160,8 +138,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       nil
     end
 
-    alias to_b to_bool
-
     # rubocop:disable Style/YodaCondition
     def true?
       true == self
@@ -172,18 +148,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       TRUE_VALUES.include?(to_s.downcase)
     end
 
-    def try(*obj, &block)
-      try!(*obj, &block) if obj.empty? || respond_to?(obj.first)
-    end
-
-    def try!(*obj, &block)
-      if obj.empty? && block_given?
-        block.arity.zero? ? instance_eval(&block) : yield(self)
-      else
-        public_send(*obj, &block)
-      end
-    end
-
     def try_call(*keys)
       return unless respond_to?(:call)
 
@@ -196,5 +160,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       nil
     end
 
+    alias to_b to_bool
+
   end
 end

data/lib/lite/ruby/open_struct.rb

@@ -14,7 +14,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('open_struct')
 
       hash&.each do |key, val|
         @table[key.to_sym] = val
-        new_ostruct_member(key)
+        new_ostruct_member!(key)
       end
 
       yield self if block && block.arity == 1
@@ -46,13 +46,12 @@ if Lite::Ruby.configuration.monkey_patches.include?('open_struct')
       { table: attributes }
     end
 
-    alias to_h to_hash
-
     def to_json(table: true)
       to_hash(table: table).to_json
     end
 
     alias as_json to_json
+    alias to_h to_hash
 
   end
 end

data/lib/lite/ruby/range.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 if Lite::Ruby.configuration.monkey_patches.include?('range')
+  require 'lite/ruby/safe/range' unless defined?(ActiveSupport)
+
   class Range
 
     def combine(other)
@@ -14,10 +16,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('range')
       include?(other.first) && other.last.send(operator, last)
     end
 
-    def overlaps?(other)
-      cover?(other.first) || other.cover?(first)
-    end
-
     def sample
       to_a.sample
     end

data/lib/lite/ruby/safe/array.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class Array
+
+  def deep_dup
+    map(&:deep_dup)
+  end
+
+  def from(position)
+    self[position, size] || []
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  def in_groups(number, fill_with = nil, &block)
+    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 defined?(yield)
+
+    collection.each(&block)
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+  # rubocop:disable Metrics/MethodLength, Style/GuardClause
+  def in_groups_of(number, fill_with = nil, &block)
+    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 defined?(yield)
+
+    sliced_collection(&block)
+  end
+  # rubocop:enable Metrics/MethodLength, Style/GuardClause
+
+  # rubocop:disable Metrics/MethodLength, Style/ExplicitBlockArgument
+  def split(value = nil)
+    arr = dup
+    result = []
+
+    if block_given?
+      while (idx = arr.index { |i| yield(i) })
+        result << arr.shift(idx)
+        arr.shift
+      end
+    else
+      while (idx = arr.index(value))
+        result << arr.shift(idx)
+        arr.shift
+      end
+    end
+
+    result << arr
+  end
+  # rubocop:enable Metrics/MethodLength, Style/ExplicitBlockArgument
+
+  def to(position)
+    return first(position + 1) if position >= 0
+
+    self[0..position]
+  end
+
+  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
+    when 2 then "#{self[0]}#{two_words_connector}#{self[1]}"
+    else "#{self[0...-1].join(words_connector)}#{last_word_connector}#{self[-1]}"
+    end
+  end
+
+end

data/lib/lite/ruby/safe/enumerable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Enumerable
+
+  def exclude?(object)
+    !include?(object)
+  end
+
+  def excluding(*elements)
+    elements.flatten!(1)
+    reject { |element| elements.include?(element) }
+  end
+
+  def including(*elements)
+    to_a.including(*elements)
+  end
+
+  def many?
+    found_count = 0
+
+    if defined?(yield)
+      any? do |val|
+        found_count += 1 if yield(val)
+        found_count > 1
+      end
+    else
+      any? { (found_count += 1) > 1 }
+    end
+  end
+
+  def pluck(*keys)
+    if keys.many?
+      map { |element| keys.map { |key| element[key] } }
+    else
+      map { |element| element[keys.first] }
+    end
+  end
+
+  alias with including
+  alias without excluding
+
+end

data/lib/lite/ruby/safe/hash.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class Hash
+
+  # 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 defined?(yield)
+        yield(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def except(*keys)
+    slice(*self.keys - keys)
+  end
+
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+
+  def extract!(*keys)
+    keys.each_with_object({}) { |key, hash| hash[key] = delete(key) if key?(key) }
+  end
+
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  def reverse_merge!(other_hash)
+    other_hash.merge!(self)
+  end
+
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  def symbolize_keys
+    transform_keys do |key|
+      key.to_sym
+    rescue StandardError
+      key
+    end
+  end
+
+  def symbolize_keys!
+    transform_keys! do |key|
+      key.to_sym
+    rescue StandardError
+      key
+    end
+  end
+
+end