lite-ruby 1.0.27 → 1.1.0

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',

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,8 +142,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
       to_s.rjust(precision, pad_number.to_s)
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def pad_precision(options = {})
       pad_number = options[:pad_number] || 0
       precision = options[:precision] || 2
@@ -191,8 +159,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('numeric')
         string[0..(ljust_count - 1)]
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def percentage_of(number)
       return 0 if zero? || number.zero?
@@ -208,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
@@ -265,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