active_object 3.1.0 → 4.0.0

data/lib/active_object/object.rb

@@ -1,6 +1,6 @@
 module ActiveObject::Object
-  FALSE_VALUES = [false, 0, "0", "false", "FALSE", "f", "F"]
-  TRUE_VALUES = [true, 1, "1", "true", "TRUE", "t", "T"]
+  FALSE_VALUES = [false, 0, '0', 'false', 'FALSE', 'f', 'F'].freeze
+  TRUE_VALUES = [true, 1, '1', 'true', 'TRUE', 't', 'T'].freeze
 
   def array?
     is_a?(Array)
@@ -56,7 +56,7 @@ module ActiveObject::Object
     is_a?(Range)
   end
 
-  def salvage(placeholder="---")
+  def salvage(placeholder = '---')
     blank? ? placeholder : self
   end
 
@@ -76,18 +76,18 @@ module ActiveObject::Object
     TRUE_VALUES.include?(self)
   end
 
-  def try(*a, &b)
-    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  def try(*obj, &block)
+    try!(*obj, yield(block)) if obj.empty? || respond_to?(obj.first)
   end
 
-  def try!(*a, &b)
-    if a.empty? && block_given?
-      b.arity.zero? ? instance_eval(&b) : yield(self)
+  def try!(*obj, &block)
+    if obj.empty? && block_given?
+      block.arity.zero? ? instance_eval(yield(block)) : yield(self)
     else
-      public_send(*a, &b)
+      public_send(*obj, yield(block))
     end
   end
 
 end
 
-Object.send(:include, ActiveObject::Object) if ActiveObject.configuration.autoload_object
+Object.send(:include, ActiveObject::Object) if ActiveObject::Settings.config.autoload_object

data/lib/active_object/range.rb

@@ -31,4 +31,4 @@ module ActiveObject::Range
 
 end
 
-Range.send(:include, ActiveObject::Range) if ActiveObject.configuration.autoload_range
+Range.send(:include, ActiveObject::Range) if ActiveObject::Settings.config.autoload_range

data/lib/active_object/settings.rb

@@ -0,0 +1,17 @@
+require 'dry-configurable'
+
+class ActiveObject::Settings
+  extend Dry::Configurable
+
+  setting :autoload_array, true
+  setting :autoload_date, true
+  setting :autoload_enumerable, true
+  setting :autoload_hash, true
+  setting :autoload_integer, true
+  setting :autoload_numeric, true
+  setting :autoload_object, true
+  setting :autoload_range, true
+  setting :autoload_string, true
+  setting :autoload_time, true
+
+end

data/lib/active_object/string.rb

@@ -2,7 +2,10 @@ module ActiveObject::String
 
   def any?(*keys)
     included = false
-    keys.flatten.each { |k| break if included = include?(k) }
+    keys.flatten.each do |key|
+      included = include?(key)
+      break if included
+    end
     included
   end
 
@@ -10,9 +13,13 @@ module ActiveObject::String
     self[position]
   end
 
-  def camelize(first_letter=:upper)
+  def camelize(first_letter = :upper)
     if first_letter.to_sym != :lower
-      to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      regex_last = Regexp.last_match(1).upcase
+
+      to_s
+        .gsub(%r{\/(.?)}) { "::#{regex_last}" }
+        .gsub(%r{^/(?:^|_)(.)}) { regex_last }
     else
       "#{to_s.first.chr.downcase}#{camelize(self)[1..-1]}"
     end
@@ -20,14 +27,14 @@ module ActiveObject::String
 
   alias_method :camelcase, :camelize
 
-  def camelize!(first_letter=:upper)
+  def camelize!(first_letter = :upper)
     replace(camelize(first_letter))
   end
 
   alias_method :camelcase!, :camelize!
 
   def classify
-    to_s.sub(/.*\./, "").camelize
+    to_s.sub(/.*\./, '').camelize
   end
 
   def classify!
@@ -39,7 +46,7 @@ module ActiveObject::String
   end
 
   def dasherize
-    gsub(/_/, "-")
+    tr(/_/, '-')
   end
 
   def dasherize!
@@ -47,7 +54,7 @@ module ActiveObject::String
   end
 
   def deconstantize
-    to_s[0, rindex("::") || 0]
+    to_s[0, rindex('::') || 0]
   end
 
   def deconstantize!
@@ -55,7 +62,7 @@ module ActiveObject::String
   end
 
   def demodulize
-    to_s.gsub(/^.*::/, "")
+    to_s.gsub(/^.*::/, '')
   end
 
   def demodulize!
@@ -63,63 +70,63 @@ module ActiveObject::String
   end
 
   def domain
-    self =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : self
+    self =~ %r{^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)} ? Regexp.last_match(1) : self
   end
 
   def downcase?
     downcase == self
   end
 
-  def ellipsize(ellipsize_at, options={})
-     return(self) if length <= ellipsize_at
+  def ellipsize(ellipsize_at, options = {})
+    return(self) if length <= ellipsize_at
 
-     separator = options.fetch(:separator, "...")
-     offset = options.fetch(:offset, 4)
+    separator = options[:separator] || '...'
+    offset = options[:offset] || 4
 
-     "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
+    "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
   end
 
   def exclude?(string)
     !include?(string)
   end
 
-  def first(limit=1)
-    return("") if limit.zero?
+  def first(limit = 1)
+    return('') if limit.zero?
 
     limit >= length ? self : to(limit - 1)
   end
 
   def format(*args)
-    super(self, *(args.flatten))
+    super(self, *args.flatten)
   end
 
   def from(position)
     self[position..-1]
   end
 
-  def humanize(options={})
-    capitalize = options.fetch(:capitalize, true)
+  def humanize(options = {})
+    capitalize = options[:capitalize] || true
 
-    underscore.
-    gsub(/_id\z/, "").
-    tr("_", " ").
-    squish.
-    gsub(/([a-z\d]*)/i) { |s| s.downcase }.
-    gsub(/\A\w/) { |s| capitalize ? s.upcase : s }
+    underscore
+      .gsub(/_id\z/, '')
+      .tr('_', ' ')
+      .squish
+      .gsub(/([a-z\d]*)/i, &:downcase)
+      .gsub(/\A\w/) { |str| capitalize ? str.upcase : str }
   end
 
-  def humanize!(options={})
+  def humanize!(options = {})
     replace(humanize(options))
   end
 
-  def indent(amount, indent_string=nil, indent_empty_lines=false)
-    indent_string = indent_string || self[/^[ \t]/] || " "
+  def indent(amount, indent_string = nil, indent_empty_lines = false)
+    indent_string = indent_string || self[/^[ \t]/] || ' '
     substitutes = indent_empty_lines ? /^/ : /^(?!$)/
 
     gsub(substitutes, indent_string * amount)
   end
 
-  def indent!(amount, indent_string=nil, indent_empty_lines=false)
+  def indent!(amount, indent_string = nil, indent_empty_lines = false)
     replace(indent(amount, indent_string, indent_empty_lines))
   end
 
@@ -128,7 +135,7 @@ module ActiveObject::String
     arr_indexes = []
     srch_index = rindex(pattern)
 
-    while srch_index do
+    while srch_index
       temp_string = self[0..(srch_index - 1)]
       arr_indexes << srch_index
       srch_index = srch_index.zero? ? nil : temp_string.rindex(pattern)
@@ -137,28 +144,27 @@ module ActiveObject::String
     arr_indexes.reverse
   end
 
-  def labelize(options={})
-    capitalize = options.fetch(:capitalize, true)
+  def labelize(options = {})
+    capitalize = options[:capitalize] || true
 
-    underscore.
-    tr("_", " ").
-    squish.
-    gsub(/([a-z\d]*)/i) { |s| s.downcase }.
-    gsub(/\A\w/) { |s| capitalize ? s.upcase : s }.
-    gsub(/ id\z/, " ID")
+    underscore
+      .tr('_', ' ')
+      .squish
+      .gsub(/([a-z\d]*)/i, &:downcase)
+      .gsub(/\A\w/) { |str| capitalize ? str.upcase : str }
+      .gsub(/ id\z/, ' ID')
   end
 
   alias_method :labelcase, :labelize
 
-  def labelize!(options={})
+  def labelize!(options = {})
     replace(labelize(options))
   end
 
   alias_method :labelcase!, :labelize!
 
-
-  def last(limit=1)
-    return("") if limit.zero?
+  def last(limit = 1)
+    return('') if limit.zero?
 
     limit >= length ? self : from(-limit)
   end
@@ -175,19 +181,19 @@ module ActiveObject::String
     to_i.ordinalize
   end
 
-  def parameterize(seperator="-")
+  def parameterize(seperator = '-')
     underscore.gsub(/\s+/, seperator).downcase
   end
 
-  def parameterize!(seperator="-")
+  def parameterize!(seperator = '-')
     replace(parameterize(seperator))
   end
 
-  def pollute(delimiter="^--^--^")
-    split("").map { |c| "#{c}#{delimiter}" }.join
+  def pollute(delimiter = '^--^--^')
+    split('').map { |chr| "#{chr}#{delimiter}" }.join
   end
 
-  def pollute!(delimiter="^--^--^")
+  def pollute!(delimiter = '^--^--^')
     replace(pollute(delimiter))
   end
 
@@ -202,12 +208,8 @@ module ActiveObject::String
   def remove(*patterns)
     string = dup
 
-    patterns.flatten.each do |p|
-      if p.is_a?(Range)
-        string.slice!(p)
-      else
-        string.gsub!(p, "")
-      end
+    patterns.flatten.each do |pat|
+      pat.is_a?(Range) ? string.slice!(pat) : string.gsub!(pat, '')
     end
 
     string
@@ -218,18 +220,18 @@ module ActiveObject::String
   end
 
   def remove_tags
-    gsub(/<\/?[^>]*>/, "")
+    gsub(%r{<\/?[^>]*>}, '')
   end
 
   def remove_tags!
     replace(remove_tags)
   end
 
-  def sample(separator=" ")
+  def sample(separator = ' ')
     split(separator).sample
   end
 
-  def sample!(separator=" ")
+  def sample!(separator = ' ')
     replace(sample(separator))
   end
 
@@ -238,7 +240,7 @@ module ActiveObject::String
       self[0]
     else
       string = dup
-      patterns.flatten.each { |p| string.sub!(p, "") }
+      patterns.flatten.each { |pat| string.sub!(pat, '') }
       string
     end
   end
@@ -247,21 +249,21 @@ module ActiveObject::String
     replace(shift(*patterns))
   end
 
-  def shuffle(separator="")
+  def shuffle(separator = '')
     split(separator).shuffle.join
   end
 
-  def shuffle!(separator="")
+  def shuffle!(separator = '')
     replace(shuffle(separator))
   end
 
   def sift(chars_to_keep)
     chars_to_keep = case chars_to_keep
                     when String then chars_to_keep.chars
-                    when Array then chars_to_keep.map { |c| c.to_s }
-                    when Range then chars_to_keep.to_a.map { |c| c.to_s }
+                    when Array then chars_to_keep.map(&:to_s)
+                    when Range then chars_to_keep.to_a.map(&:to_s)
                     else
-                      raise TypeError, "Invalid parameter"
+                      raise TypeError, 'Invalid parameter'
                     end
 
     chars.keep_if { |chr| chars_to_keep.include?(chr) }.join
@@ -272,11 +274,11 @@ module ActiveObject::String
   end
 
   def slugify
-    gsub(/[^\x00-\x7F]+/, "").
-    gsub(/[^\w_ \-]+/i, "").
-    gsub(/[ \-]+/i, "-").
-    gsub(/^\-|\-$/i, "").
-    downcase
+    gsub(/[^\x00-\x7F]+/, '')
+      .gsub(/[^\w_ \-]+/i, '')
+      .gsub(/[ \-]+/i, '-')
+      .gsub(/^\-|\-$/i, '')
+      .downcase
   end
 
   def slugify!
@@ -284,7 +286,7 @@ module ActiveObject::String
   end
 
   def squish
-    strip.gsub(/\s+/, " ")
+    strip.gsub(/\s+/, ' ')
   end
 
   def squish!
@@ -315,49 +317,50 @@ module ActiveObject::String
     self[0..position]
   end
 
-  def truncate(truncate_at, options={})
+  def truncate(truncate_at, options = {})
     return(dup) unless length > truncate_at
 
-    omission = options.fetch(:omission, "...")
+    omission = options[:omission] || '...'
     size_with_room_for_omission = truncate_at - omission.length
 
-    stop = if options.fetch(:separator, false)
-      rindex(options.fetch(:separator, ""), size_with_room_for_omission) || size_with_room_for_omission
-    else
-      size_with_room_for_omission
-    end
+    seperator = options[:separator]
+    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 truncate_words(words_count, options={})
-    sep = options.fetch(:separator, /\s+/)
-    sep = Regexp.escape(sep.to_s) unless Regexp === sep
+  def truncate_words(words_count, options = {})
+    sep = options[:separator] || /\s+/
+    sep = Regexp.escape(sep.to_s) unless sep.is_a(Regexp)
 
     if self =~ /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
-      "#{$1}#{options.fetch(:omission, '...')}"
+      "#{Regexp.last_match(1)}#{options[:omissio] || '...'}"
     else
       self
     end
   end
 
   def underscore
-    gsub(/::/, "/").
-    gsub(/([A-Z\d]+)([A-Z][a-z])/, "\1_\2").
-    gsub(/([a-z\d])([A-Z])/, "\1_\2").
-    tr("-", "_").
-    downcase
+    gsub(/::/, '/')
+      .gsub(/([A-Z\d]+)([A-Z][a-z])/, "\1_\2")
+      .gsub(/([a-z\d])([A-Z])/, "\1_\2")
+      .tr('-', '_')
+      .downcase
   end
 
   def underscore!
     replace(underscore)
   end
 
-  def unpollute(delimiter="^--^--^")
-    gsub(delimiter, "")
+  def unpollute(delimiter = '^--^--^')
+    gsub(delimiter, '')
   end
 
-  def unpollute!(delimiter="^--^--^")
+  def unpollute!(delimiter = '^--^--^')
     replace(unpollute(delimiter))
   end
 
@@ -366,8 +369,8 @@ module ActiveObject::String
   end
 
   def unshift(*patterns)
-    string = ""
-    patterns.flatten.each { |p| string.concat(p) }
+    string = ''
+    patterns.flatten.each { |pat| string.concat(pat) }
     string.concat(self)
     string
   end
@@ -378,4 +381,4 @@ module ActiveObject::String
 
 end
 
-String.send(:include, ActiveObject::String) if ActiveObject.configuration.autoload_string
+String.send(:include, ActiveObject::String) if ActiveObject::Settings.config.autoload_string