lite-ruby 1.0.28 → 1.1.1

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,183 @@
+# 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 = str.sub!(/.*\./, '')
+    str.camelize!
+  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 = str.underscore!
+    str = str.delete_suffix!('_id')
+    str = str.tr!('_', ' ')
+    str = str.squish!
+    str = str.gsub!(/([a-z\d]*)/i, &:downcase)
+    str = 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 = str.underscore!
+    str = str.gsub!(/\s+/, separator)
+    str = 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 = str.underscore!
+    str = str.humanize!
+    str = 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 = str.camelize!
+    str = 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 || 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

data/lib/lite/ruby/string.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: false
 
 if Lite::Ruby.configuration.monkey_patches.include?('string')
+  require 'lite/ruby/safe/string' unless defined?(ActiveSupport)
+
   class String
 
     TRANSLITERATIONS ||= {
@@ -34,65 +36,33 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
     }.freeze
 
     def acronym
-      dup.acronym!
+      gsub(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./, '\\2') || self
     end
 
     def acronym!
-      gsub!(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./, '\\2') || self
+      replace(acronym)
     end
 
     def any?(*keys)
       keys.any? { |key| include?(key) }
     end
 
-    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 }
-      end || modulize
-    end
-
-    alias camelcase camelize
-
     def camelize!(first_letter = :upper)
       replace(camelize(first_letter))
     end
 
-    alias camelcase! camelize!
-
     def capitalized?
       capitalize == self
     end
 
-    def classify
-      dup.classify!
-    end
-
     def classify!
-      sub!(/.*\./, '')
-      camelize!
-    end
-
-    def constantize
-      Object.const_get(camelize)
-    end
-
-    def dasherize
-      underscore.tr('_', '-')
+      replace(classify)
     end
 
     def dasherize!
       replace(dasherize)
     end
 
-    def deconstantize
-      [0, rindex('::') || 0]
-    end
-
     def deconstantize!
       replace(deconstantize)
     end
@@ -106,10 +76,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       self
     end
 
-    def demodulize
-      gsub(/^.*::/, '')
-    end
-
     def demodulize!
       replace(demodulize)
     end
@@ -137,24 +103,10 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
     end
 
-    def first(limit = 1)
-      if limit.zero?
-        ''
-      elsif limit >= length
-        self
-      else
-        to(limit - 1)
-      end
-    end
-
     def format(*args)
       super(self, *args.flatten)
     end
 
-    def from(position)
-      self[position..-1]
-    end
-
     def headerize
       squish.each_word(&:capitalize!).join(' ')
     end
@@ -163,29 +115,8 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       replace(headerize)
     end
 
-    def humanize(options = {})
-      dup.humanize!(options)
-    end
-
     def humanize!(capitalize: true)
-      underscore!
-      gsub!(/_id\z/, '')
-      tr!('_', ' ')
-      squish!
-      gsub!(/([a-z\d]*)/i, &:downcase)
-      gsub!(/\A\w/) { |str| capitalize ? str.upcase : 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
+      replace(humanize(capitalize: capitalize))
     end
 
     def index_all(pattern)
@@ -202,12 +133,10 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       arr_indexes.reverse
     end
 
-    def labelize(options = {})
-      dup.labelize!(options)
+    def labelize(capitalize: true)
+      dup.labelize!(capitalize: capitalize)
     end
 
-    alias labelcase labelize
-
     def labelize!(capitalize: true)
       underscore!
       tr!('_', ' ')
@@ -217,18 +146,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       gsub!(/ id\z/, ' ID') || self
     end
 
-    alias labelcase! labelize!
-
-    def last(limit = 1)
-      if limit.zero?
-        ''
-      elsif limit >= length
-        self
-      else
-        from(-limit)
-      end
-    end
-
     def lchomp(match)
       dup.lchomp!(match)
     end
@@ -267,6 +184,16 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       !upcase? && !downcase?
     end
 
+    def non_possessive
+      dup.non_possessive!
+    end
+
+    def non_possessive!
+      return self unless possessive?
+
+      chomp!("'s") || chomp!("'") || self
+    end
+
     def ordinal
       to_i.ordinal
     end
@@ -275,14 +202,8 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       to_i.ordinalize
     end
 
-    def parameterize(separator: '-')
-      dup.parameterize!(separator: separator)
-    end
-
     def parameterize!(separator: '-')
-      underscore!
-      gsub!(/\s+/, separator)
-      downcase! || self
+      replace(parameterize(separator: separator))
     end
 
     def pathize
@@ -311,16 +232,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       self[-1]
     end
 
-    def non_possessive
-      dup.non_possessive!
-    end
-
-    def non_possessive!
-      return self unless possessive?
-
-      chomp!("'s") || chomp!("'") || self
-    end
-
     def possessive
       return self if possessive?
 
@@ -369,7 +280,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
         b = f
 
         if amount.odd?
-          f = "'" + f
+          f = "'#{f}"
           b += "'"
         end
       else
@@ -384,16 +295,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       replace(quote(type, amount))
     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 remove_tags
       dup.remove_tags!
     end
@@ -484,15 +385,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       downcase! || self
     end
 
-    def squish
-      dup.squish!
-    end
-
-    def squish!
-      strip!
-      gsub!(/\s+/, ' ') || self
-    end
-
     def sort
       chars.sort.join
     end
@@ -501,73 +393,36 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       replace(sort)
     end
 
-    def titleize
-      dup.titleize!
-    end
-
-    alias titlecase titleize
-
-    def titleize!
-      underscore!
-      humanize!
-      gsub!(/\b(?<!['’`])[a-z]/) { $&.capitalize } || self
-    end
-
-    alias titlecase! titleize!
-
-    def to(position)
-      self[0..position]
-    end
-
     def transliterize
-      dup.transliterize!
+      TRANSLITERATIONS.each_with_object(dup) { |(k, v), s| s.gsub!(k, v) }
     end
 
     def transliterize!
-      TRANSLITERATIONS.each_with_object(self) { |(k, v), str| str.gsub!(k, v) }
+      replace(transliterize)
     end
 
-    def truncate(truncate_at, options = {})
-      return dup unless length > truncate_at
+    def titleize!
+      replace(titleize)
+    end
 
-      seperator = options[:separator]
+    def truncate_words(word_count, options = {})
       omission = options[:omission] || '...'
-      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
+      seperator = options[:separator] || /\s+/
 
-      "#{self[0, stop]}#{omission}"
-    end
-
-    def truncate_words(words_count, options = {})
-      sep = options[:separator] || /\s+/
-      sep = Regexp.escape(sep.to_s) unless sep.is_a(Regexp)
-      return self unless /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m.match?(self)
+      seperator = Regexp.escape(seperator.to_s) unless seperator.is_a(Regexp)
+      return self unless /\A((?:.+?#{seperator}){#{word_count - 1}}.+?)#{seperator}.*/m.match?(self)
 
-      "#{::Regexp.last_match(1)}#{options[:omissio] || '...'}"
+      "#{::Regexp.last_match(1)}#{omission}"
     end
 
-    def underscore
-      dup.underscore!
+    def upcase?
+      upcase == self
     end
 
-    alias snakecase underscore
-
     def underscore!
-      camelize!
-      gsub!(/::/, '/')
-      gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-      gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-      tr!('-', '_')
-      downcase! || self
+      replace(underscore)
     end
 
-    alias snakecase! underscore!
-
     def unpollute(delimiter = '^--^--^')
       dup.unpollute!(delimiter)
     end
@@ -576,19 +431,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       gsub!(delimiter, '') || self
     end
 
-    def upcase?
-      upcase == self
-    end
-
-    def unshift(*patterns)
-      patterns.each_with_object('') { |pat, str| str << pat }
-              .concat(self)
-    end
-
-    def unshift!(*patterns)
-      replace(unshift(*patterns))
-    end
-
     def unquote
       dup.unquote!
     end
@@ -603,6 +445,15 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       self
     end
 
+    def unshift(*patterns)
+      patterns.each_with_object('') { |pat, str| str << pat }
+              .concat(self)
+    end
+
+    def unshift!(*patterns)
+      replace(unshift(*patterns))
+    end
+
     def words
       split(/\s+/)
     end
@@ -624,8 +475,11 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       replace(variablize)
     end
 
-    alias ends_with? end_with?
-    alias starts_with? start_with?
+    alias camelcase! camelize!
+    alias labelcase labelize
+    alias labelcase! labelize!
+    alias snakecase! underscore!
+    alias titlecase! titleize!
 
   end
 end