lite-ruby 1.0.31 → 1.1.4

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[
@@ -10,16 +12,13 @@ if Lite::Ruby.configuration.monkey_patches.include?('object')
       1 t true y yes on
     ].freeze
 
-    def array?
-      is_a?(Array)
-    end
-
-    def blank?
-      object = self
-      object = object.strip if respond_to?(:strip)
-      return object.empty? if respond_to?(:empty?)
-
-      !object
+    # NOTE: There is a class between the PG gem and the `array?` method.
+    #       We only need to skip this on migrations since that action
+    #       happens on a seperate runtime.
+    unless defined?(PG) && ARGV.first.to_s.start_with?('db:')
+      def array?
+        is_a?(Array)
+      end
     end
 
     def bool?
@@ -35,14 +34,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 +78,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 +143,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 +153,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? && defined?(yield)
-        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 +165,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

@@ -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,101 @@
+# frozen_string_literal: true
+
+class Array
+
+  def deep_dup
+    map(&:deep_dup)
+  end
+
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+    reject! { |element| extracted_elements << element if yield(element) }
+    extracted_elements
+  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

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Object
+
+  def blank?
+    object = self
+    object = object.strip if respond_to?(:strip)
+    return object.empty? if respond_to?(:empty?)
+
+    !object
+  end
+
+  def deep_dup
+    duplicable? ? dup : self
+  end
+
+  def duplicable?
+    true
+  end
+
+  def present?
+    !blank?
+  end
+
+  def presence
+    self if present?
+  end
+
+  def try(*obj, &block)
+    try!(*obj, &block) if obj.empty? || respond_to?(obj.first)
+  end
+
+  def try!(*obj, &block)
+    if obj.empty? && defined?(yield)
+      block.arity.zero? ? instance_eval(&block) : yield(self)
+    else
+      public_send(*obj, &block)
+    end
+  end
+
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Range
+
+  def overlaps?(other)
+    cover?(other.first) || other.cover?(first)
+  end
+
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+class String
+
+  def at(position)
+    self[position]
+  end
+
+  def camelize(first_letter = :upper)
+    case first_letter
+    when :upper, true then modulize.gsub(/(\A|\s)([a-z])/) { $1 + $2.upcase }
+    when :lower, false then modulize.gsub(/(\A|\s)([A-Z])/) { $1 + $2.downcase }
+    else modulize
+    end
+  end
+
+  def classify
+    str = dup
+    str.sub!(/.*\./, '')
+    str.camelize!
+    str || self
+  end
+
+  def constantize
+    Object.const_get(camelize)
+  end
+
+  def dasherize
+    underscore.tr('_', '-')
+  end
+
+  def deconstantize
+    [0, rindex('::') || 0]
+  end
+
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  def first(limit = 1)
+    if limit.zero?
+      ''
+    elsif limit >= length
+      self
+    else
+      to(limit - 1)
+    end
+  end
+
+  def from(position)
+    self[position..-1]
+  end
+
+  def humanize(capitalize: true)
+    str = dup
+    str.underscore!
+    str.delete_suffix!('_id')
+    str.tr!('_', ' ')
+    str.squish!
+    str.gsub!(/([a-z\d]*)/i, &:downcase)
+    str.gsub!(/\A\w/) { |s| capitalize ? s.upcase : s }
+    str || self
+  end
+
+  def indent(amount, seperator = ' ')
+    dup.indent!(amount, seperator)
+  end
+
+  def indent!(amount, seperator = ' ')
+    if amount >= 0
+      gsub!(/^/, seperator * amount)
+    else
+      gsub!(/^#{Regexp.escape(seperator)}{0,#{-amount}}/, '')
+    end
+  end
+
+  def last(limit = 1)
+    if limit.zero?
+      ''
+    elsif limit >= length
+      self
+    else
+      from(-limit)
+    end
+  end
+
+  def parameterize(separator: '-')
+    str = dup
+    str.underscore!
+    str.gsub!(/\s+/, separator)
+    str.downcase!
+    str || self
+  end
+
+  def remove(*patterns)
+    dup.remove!(*patterns)
+  end
+
+  def remove!(*patterns)
+    patterns.each_with_object(self) do |pat, str|
+      pat.is_a?(Range) ? str.slice!(pat) : str.gsub!(pat, '')
+    end
+  end
+
+  def squish
+    dup.squish!
+  end
+
+  def squish!
+    strip!
+    gsub!(/\s+/, ' ') || self
+  end
+
+  def titleize
+    str = dup
+    str.underscore!
+    str.humanize!
+    str.gsub!(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+    str || self
+  end
+
+  def to(position)
+    self[0..position]
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+  def to_time(form = :local)
+    parts = Date.parse(self, false)
+    used_keys = %i[year mon mday hour min sec sec_fraction offset]
+    return if (parts.keys & used_keys).empty?
+
+    now = Time.now
+    time = Time.new(
+      parts[:year] || now.year,
+      parts[:mon] || now.month,
+      parts[:mday] || now.day,
+      parts[:hour] || 0,
+      parts[:min] || 0,
+      (parts[:sec] || 0) + (parts[:sec_fraction] || 0),
+      parts[:offset] || (form == :utc ? 0 : nil)
+    )
+
+    form == :utc ? time.utc : time.to_time
+  end
+  # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+  def truncate(truncate_at, options = {})
+    return self unless length > truncate_at
+
+    omission = options[:omission] || '...'
+    seperator = options[:separator]
+
+    size_with_room_for_omission = truncate_at - omission.length
+
+    stop = if seperator
+             rindex(seperator || '', size_with_room_for_omission) || size_with_room_for_omission
+           else
+             size_with_room_for_omission
+           end
+
+    "#{self[0, stop]}#{omission}"
+  end
+
+  def underscore
+    str = dup
+    str.camelize!
+    str.gsub!(/::/, '/')
+    str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    str.tr!('-', '_')
+    str.downcase!
+    str || self
+  end
+
+  alias camelcase camelize
+  alias ends_with? end_with?
+  alias snakecase underscore
+  alias starts_with? start_with?
+  alias titlecase titleize
+  alias to_t to_time unless defined?(to_t)
+
+end