lite-ruby 1.0.27 → 1.1.0

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,187 @@
+# 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 transliterate
+    TRANSLITERATIONS.each_with_object(dup) { |(k, v), s| s.gsub!(k, v) }
+  end
+
+  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,73 +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 ascii_only(alt = '')
-      dup.ascii_only!(alt)
-    end
-
-    def ascii_only!(alt = '')
-      encode_only!('ASCII', alt)
-    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
@@ -114,10 +76,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       self
     end
 
-    def demodulize
-      gsub(/^.*::/, '')
-    end
-
     def demodulize!
       replace(demodulize)
     end
@@ -136,21 +94,6 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       words.each(&block)
     end
 
-    def encode_only(encoding, alt = '')
-      dup.encode_only!(encoding, alt)
-    end
-
-    def encode_only!(encoding, alt = '')
-      encoding_options = {
-        invalid: :replace,
-        undef: :replace,
-        replace: alt,
-        UNIVERSAL_NEWLINE_DECORATOR: true
-      }
-
-      encode!(Encoding.find(encoding), encoding_options)
-    end
-
     def ellipsize(ellipsize_at, options = {})
       return self if length <= ellipsize_at
 
@@ -160,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
@@ -186,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)
@@ -225,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!('_', ' ')
@@ -240,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
@@ -290,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
@@ -298,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
@@ -334,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?
 
@@ -392,7 +280,7 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
         b = f
 
         if amount.odd?
-          f = "'" + f
+          f = "'#{f}"
           b += "'"
         end
       else
@@ -407,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
@@ -434,6 +312,26 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       slice!(amount, size - amount) + slice!(0, amount)
     end
 
+    # rubocop:disable Metrics/MethodLength
+    def safe_encode(target_encoding, replacement = '')
+      encode(target_encoding)
+    rescue Encoding::InvalidByteSequenceError
+      force_encoding(target_encoding).scrub!(replacement)
+    rescue Encoding::UndefinedConversionError
+      encode(
+        target_encoding,
+        invalid: :replace,
+        undef: :replace,
+        replace: replacement,
+        UNIVERSAL_NEWLINE_DECORATOR: true
+      )
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def safe_encode!(target_encoding, replacement = '')
+      replace(safe_encode(target_encoding, replacement))
+    end
+
     def sample(separator = ' ')
       split(separator).sample
     end
@@ -487,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
@@ -504,73 +393,32 @@ if Lite::Ruby.configuration.monkey_patches.include?('string')
       replace(sort)
     end
 
-    def titleize
-      dup.titleize!
+    def transliterate!
+      replace(transliterate)
     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!
+      replace(titleize)
     end
 
-    def transliterize!
-      TRANSLITERATIONS.each_with_object(self) { |(k, v), str| str.gsub!(k, v) }
-    end
-
-    def truncate(truncate_at, options = {})
-      return dup unless length > truncate_at
-
-      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
-
-      "#{self[0, stop]}#{omission}"
-    end
+      seperator = options[:separator] || /\s+/
 
-    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
@@ -579,19 +427,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
@@ -606,6 +441,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
@@ -627,8 +471,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