active_object 2.2.5 → 2.3.0

data/lib/active_object/hash.rb

@@ -6,7 +6,7 @@ class Hash
       each_key do |k|
         unless valid_keys.include?(k)
           raise ArgumentError,
-            "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+            "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
         end
       end
     end
@@ -41,6 +41,7 @@ class Hash
           block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
         end
       end
+
       self
     end
   end
@@ -59,11 +60,7 @@ class Hash
   end
 
   def nillify!
-    each do |k, v|
-      if !v.nil? && ((v.respond_to?(:blank?) && v.blank?) || (v.respond_to?(:to_s) && v.to_s.blank?))
-        self[k] = nil
-      end
-    end
+    each { |k, v| self[k] = nil if !v.nil? && (v.try(:blank?) || v.try(:to_s).blank?) }
   end
 
   def only(*keys)
@@ -165,8 +162,8 @@ class Hash
 
   unless defined?(Rails)
     def stringify_keys!
-      inject({}) do |options,(k, v)|
-        options[k.to_s] = v
+      inject({}) do |options, (key, value)|
+        options[key.to_s] = value
         options
       end
     end
@@ -188,8 +185,8 @@ class Hash
 
   unless defined?(Rails)
     def symbolize_keys!
-      inject({}) do |options, (k, v)|
-        options[(k.to_sym rescue k) || k] = v
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
         options
       end
     end
@@ -200,8 +197,8 @@ class Hash
   end
 
   def symbolize_and_underscore_keys!
-    inject({}) do |options, (k, v)|
-      options[(k.to_s.gsub(" ", "_").underscore.to_sym rescue k) || k] = v
+    inject({}) do |options, (key, value)|
+      options[(key.to_s.gsub(' '.freeze, '_'.freeze).underscore.to_sym rescue key) || key] = value
       options
     end
   end
@@ -215,6 +212,7 @@ class Hash
   unless defined?(Rails)
     def transform_keys!(&block)
       return(enum_for(:transform_keys!)) unless block_given?
+
       keys.each { |k| self[yield(k)] = delete(k) }
       self
     end
@@ -229,6 +227,7 @@ class Hash
   unless defined?(Rails)
     def transform_values!(&block)
       return(enum_for(:transform_values!)) unless block_given?
+
       each { |k, v| self[k] = yield(v) }
     end
   end

data/lib/active_object/integer.rb

@@ -1,24 +1,24 @@
 class Integer
 
   ROMAN_VALUES = {
-    "M"  => 1000,
-    "CM" => 900,
-    "D"  => 500,
-    "CD" => 400,
-    "C"  => 100,
-    "XC" => 90,
-    "L"  => 50,
-    "XL" => 40,
-    "X"  => 10,
-    "IX" => 9,
-    "V"  => 5,
-    "IV" => 4,
-    "I"  => 1
-  }
+    'M'  => 1000,
+    'CM' => 900,
+    'D'  => 500,
+    'CD' => 400,
+    'C'  => 100,
+    'XC' => 90,
+    'L'  => 50,
+    'XL' => 40,
+    'X'  => 10,
+    'IX' => 9,
+    'V'  => 5,
+    'IV' => 4,
+    'I'  => 1
+  }.freeze
 
   def factorial
     return(1) if zero?
-    2.upto(self).inject(1) { |product, n| product * n }
+    2.upto(self).inject(1) { |p, n| p * n }
   end
 
   def of(&block)
@@ -26,12 +26,10 @@ class Integer
   end
 
   def roman
-    return("") if zero?
+    return(''.freeze) if zero?
     return("-#{(-self).roman}") if self < 0
 
-    ROMAN_VALUES.each do |key, value|
-      return(key + (self - value).roman) if value <= self
-    end
+    ROMAN_VALUES.each { |k, v| return("#{k}#{(self - v).roman}") if v <= self }
   end
 
   def time

data/lib/active_object/numeric.rb

@@ -131,6 +131,14 @@ class Numeric
 
   alias_method :gram_in_grams, :grams_in_grams
 
+  def greater_than?(n)
+    self > n
+  end
+
+  def greater_than_or_equal_to?(n)
+    self >= n
+  end
+
   def hectograms_in_grams
     self * HECTO
   end
@@ -155,6 +163,10 @@ class Numeric
 
   alias_method :inch_in_inches, :inches_in_inches
 
+  def inside?(start, finish)
+    (start < self) && (self < finish)
+  end
+
   def kilobytes_in_bytes
     self * KILOBYTE
   end
@@ -173,6 +185,14 @@ class Numeric
 
   alias_method :kilogram_in_grams, :kilograms_in_grams
 
+  def less_than?(n)
+    self < n
+  end
+
+  def less_than_or_equal_to?(n)
+    self <= n
+  end
+
   def metric_tons_in_grams
     self * METRIC_TON
   end
@@ -245,14 +265,14 @@ class Numeric
     def ordinal
       abs_number = abs
 
-      if (11..13).include?(abs_number % 100)
-        "th"
+      if (11..13).cover?(abs_number % 100)
+        'th'.freeze
       else
         case abs_number % 10
-          when 1; "st"
-          when 2; "nd"
-          when 3; "rd"
-          else    "th"
+          when 1; 'st'.freeze
+          when 2; 'nd'.freeze
+          when 3; 'rd'.freeze
+          else    'th'.freeze
         end
       end
     end
@@ -270,6 +290,10 @@ class Numeric
 
   alias_method :ounce_in_ounces, :ounces_in_ounces
 
+  def outside?(start, finish)
+    (self < start) || (finish < self)
+  end
+
   def pad(options={})
     pad_number = options.fetch(:pad_number, 0)
     precision  = options.fetch(:precision, 3)
@@ -280,13 +304,13 @@ class Numeric
   def pad_precision(options={})
     pad_number = options.fetch(:pad_number, 0)
     precision  = options.fetch(:precision, 2)
-    separator  = options.fetch(:separator, ".")
+    separator  = options.fetch(:separator, '.'.freeze)
     string     = to_s
 
-    string << separator unless string.include?(separator)
-    ljust_count = string.split(separator).first.size
+    string      << separator unless string.include?(separator)
+    ljust_count =  string.split(separator).first.size
     ljust_count += (string.count(separator) + precision) if precision > 0
-    num_count   = string.size
+    num_count   =  string.size
     ljust_count >= num_count ? string.ljust(ljust_count, pad_number.to_s) : string[0..(ljust_count - 1)]
   end
 
@@ -345,18 +369,18 @@ class Numeric
       :terabyte, :terabytes,
       :petabyte, :petabytes,
       :exabyte,  :exabytes
-    ]
+    ].freeze
 
     unless valid_keys.include?(from) && valid_keys.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
     end
 
-    to_f * 1.send("#{from}_in_bytes") / 1.send("#{to}_in_bytes")
+    to_f * 1.send("#{from}_in_bytes").to_f / 1.send("#{to}_in_bytes").to_f
   end
 
   def to_currency(options={})
-    unit = options.fetch(:unit, "$")
+    unit = options.fetch(:unit, '$'.freeze)
 
     "#{unit}#{pad_precision(options.only(:precision))}"
   end
@@ -375,11 +399,11 @@ class Numeric
       :yard,          :yards,
       :mile,          :miles,
       :nautical_mile, :nautical_miles
-    ]
+    ].freeze
 
     unless valid_keys.include?(from) && valid_keys.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
     end
 
     case to
@@ -387,15 +411,15 @@ class Numeric
       self
     when :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters, :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers, :kilometer, :kilometers
       if valid_keys.first(14).include?(from)
-        to_f * 1.send("#{from}_in_meters") / 1.send("#{to}_in_meters")
+        to_f * 1.send("#{from}_in_meters").to_f / 1.send("#{to}_in_meters").to_f
       else
-        to_f * ((1.send("#{from}_in_inches") * 0.0254) / 1.send("#{to}_in_meters"))
+        to_f * ((1.send("#{from}_in_inches").to_f * 0.0254) / 1.send("#{to}_in_meters").to_f)
       end
     when :inch, :inches, :foot, :feet, :yard, :yards, :mile, :miles, :nautical_mile, :nautical_miles
       if valid_keys.first(14).include?(from)
-        to_f * ((1.send("#{from}_in_meters") * 39.3701) / 1.send("#{to}_in_inches"))
+        to_f * ((1.send("#{from}_in_meters").to_f * 39.3701) / 1.send("#{to}_in_inches").to_f)
       else
-        to_f * 1.send("#{from}_in_inches") / 1.send("#{to}_in_inches")
+        to_f * 1.send("#{from}_in_inches").to_f / 1.send("#{to}_in_inches").to_f
       end
     end
   end
@@ -414,11 +438,11 @@ class Numeric
       :pound,      :pounds,
       :stone,      :stones,
       :ton,        :tons
-    ]
+    ].freeze
 
     unless valid_keys.include?(from) && valid_keys.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
     end
 
     case to
@@ -426,21 +450,22 @@ class Numeric
       self
     when :gram, :grams, :milligram, :milligrams, :centigram, :centigrams, :decigram, :decigrams, :decagram, :decagrams, :hectogram, :hectograms, :kilogram, :kilograms, :metric_ton, :metric_tons
       if valid_keys.first(16).include?(from)
-        to_f * 1.send("#{from}_in_grams") / 1.send("#{to}_in_grams")
+        to_f * 1.send("#{from}_in_grams").to_f / 1.send("#{to}_in_grams").to_f
       else
-        to_f * ((1.send("#{from}_in_ounces") * 28.3495) / 1.send("#{to}_in_grams"))
+        to_f * ((1.send("#{from}_in_ounces") * 28.3495).to_f / 1.send("#{to}_in_grams").to_f)
       end
     when :ounce, :ounces, :pound, :pounds, :stone, :stones, :ton, :tons
       if valid_keys.first(16).include?(from)
-        to_f * ((1.send("#{from}_in_grams") * 0.035274) / 1.send("#{to}_in_ounces"))
+        to_f * ((1.send("#{from}_in_grams") * 0.035274).to_f / 1.send("#{to}_in_ounces").to_f)
       else
-        to_f * 1.send("#{from}_in_ounces") / 1.send("#{to}_in_ounces")
+        to_f * 1.send("#{from}_in_ounces").to_f / 1.send("#{to}_in_ounces").to_f
       end
     end
   end
 
   def to_nearest_value(values=[])
     return(self) if values.size.zero?
+
     value      = values.first
     difference = (self - value).abs
 
@@ -450,32 +475,35 @@ class Numeric
         value      = v
       end
     end
+
     value
   end
 
   def to_percentage(options={})
-    unit = options.fetch(:unit, "%")
+    unit = options.fetch(:unit, '%'.freeze)
 
     "#{pad_precision(options.only(:precision))}#{unit}"
   end
 
   def to_temperature(from, to)
-    valid_keys = [:celsius, :fahrenheit, :kelvin]
+    valid_keys = [:celsius, :fahrenheit, :kelvin].freeze
 
     unless valid_keys.include?(from) && valid_keys.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
     end
 
+    number = to_f
+
     case to
     when from
       self
     when :celsius
-      from == :kelvin ? (to_f - 273.15) : ((to_f - 32.0) * 5.0 / 9.0)
+      from == :kelvin ? (number - 273.15) : ((number - 32.0) * 5.0 / 9.0)
     when :fahrenheit
-      from == :kelvin ? (1.8 * (to_f - 273.15) + 32.0) : ((to_f * 9.0 / 5.0) + 32.0)
+      from == :kelvin ? (1.8 * (number - 273.15) + 32.0) : ((number * 9.0 / 5.0) + 32.0)
     when :kelvin
-      from == :celsius ? (to_f + 273.15) : (((to_f - 32.0) * 5.0 / 9.0) + 273.15)
+      from == :celsius ? (number + 273.15) : (((number - 32.0) * 5.0 / 9.0) + 273.15)
     end
   end
 
@@ -490,14 +518,14 @@ class Numeric
       :decade,     :decades,
       :century,    :centuries,
       :millennium, :millenniums
-    ]
+    ].freeze
 
     unless valid_keys.include?(from) && valid_keys.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
     end
 
-    to_f * 1.send("#{from}_in_seconds") / 1.send("#{to}_in_seconds")
+    to_f * 1.send("#{from}_in_seconds").to_f / 1.send("#{to}_in_seconds").to_f
   end
 
   def tons_in_ounces
@@ -517,7 +545,7 @@ class Numeric
 
     a, b = to_f, number.to_f
 
-    (a.zero? || b.zero?) ? (a - b).abs < epsilon : (a / b - 1).abs < epsilon
+    (a.zero? || b.zero?) ? ((a - b).abs < epsilon) : ((a / b - 1).abs < epsilon)
   end
 
   def yards_in_inches

data/lib/active_object/object.rb

@@ -8,12 +8,12 @@ class Object
     def blank?
       object = self
       object = object.strip if respond_to?(:strip)
-      respond_to?(:empty?) ? !!object.empty? : !object
+      respond_to?(:empty?) ? object.empty? : !object
     end
   end
 
   def boolean?
-    [false, true, nil, 0, 1].include?(self)
+    [false, true, nil, 0, 1].freeze.include?(self)
   end
 
   def false?
@@ -21,7 +21,7 @@ class Object
   end
 
   def falsey?
-    [false, nil, 0].include?(self)
+    [false, nil, 0].freeze.include?(self)
   end
 
   def float?

data/lib/active_object/string.rb

@@ -2,13 +2,8 @@ class String
 
   def any?(*keys)
     included = false
-
-    keys.flatten.each do |key|
-      (included = true) if include?(key)
-      break if included
-    end
-
-    return(included)
+    keys.flatten.each { |k| break if included = include?(k) }
+    included
   end
 
   unless defined?(Rails)
@@ -19,10 +14,12 @@ class String
 
   unless defined?(Rails)
     def camelize(first_letter=:upper)
-      if first_letter != :lower
-        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      if first_letter.to_sym != :lower
+        to_s.
+        gsub(/\/(.?)/) { "::#{$1.upcase}" }.
+        gsub(/(?:^|_)(.)/) { $1.upcase }
       else
-        to_s.first.chr.downcase + camelize(self)[1..-1]
+        "#{to_s.first.chr.downcase}#{camelize(self)[1..-1]}"
       end
     end
 
@@ -39,7 +36,9 @@ class String
 
   unless defined?(Rails)
     def classify
-      to_s.sub(/.*\./, "").camelize
+      to_s.
+      sub(/.*\./, ''.freeze).
+      camelize
     end
   end
 
@@ -57,7 +56,7 @@ class String
 
   unless defined?(Rails)
     def dasherize
-      gsub(/_/, "-")
+      gsub(/_/, '-'.freeze)
     end
   end
 
@@ -69,7 +68,7 @@ class String
 
   unless defined?(Rails)
     def deconstantize
-      to_s[0, rindex('::') || 0]
+      to_s[0, rindex('::'.freeze) || 0]
     end
   end
 
@@ -81,7 +80,7 @@ class String
 
   unless defined?(Rails)
     def demodulize
-      to_s.gsub(/^.*::/, "")
+      to_s.gsub(/^.*::/, ''.freeze)
     end
   end
 
@@ -102,10 +101,11 @@ class String
 
   def ellipsize(ellipsize_at, options={})
      return(self)if size <= ellipsize_at
-     separator = options.fetch(:separator, "...")
+
+     separator = options.fetch(:separator, '...'.freeze)
      offset    = options.fetch(:offset, 4)
 
-     "#{self[0,offset]}#{separator}#{self[-offset,offset]}"
+     "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
   end
 
   unless defined?(Rails)
@@ -116,7 +116,8 @@ class String
 
   unless defined?(Rails)
     def first(limit=1)
-      return("") if limit.zero?
+      return(''.freeze) if limit.zero?
+
       limit >= size ? self.dup : to(limit - 1)
     end
   end
@@ -130,8 +131,8 @@ class String
   unless defined?(Rails)
     def humanize(options = {})
       underscore.
-      gsub(/_id\z/, "").
-      tr("_", " ").
+      gsub(/_id\z/, ''.freeze).
+      tr('_'.freeze, ' '.freeze).
       gsub(/([a-z\d]*)/i) { |s| s.downcase }.
       gsub(/\A\w/) { |s| options.fetch(:capitalize, true) ? s.upcase : s }
     end
@@ -145,8 +146,9 @@ class String
 
   unless defined?(Rails)
     def indent(amount, indent_string=nil, indent_empty_lines=false)
-      indent_string = indent_string || self[/^[ \t]/] || " "
+      indent_string = indent_string || self[/^[ \t]/] || ' '.freeze
       substitutes   = indent_empty_lines ? /^/ : /^(?!$)/
+
       gsub(substitutes, indent_string * amount)
     end
   end
@@ -159,7 +161,8 @@ class String
 
   unless defined?(Rails)
     def last(limit=1)
-      return("") if limit.zero?
+      return(''.freeze) if limit.zero?
+
       limit >= size ? self.dup : from(-limit)
     end
   end
@@ -181,30 +184,32 @@ class String
   end
 
   unless defined?(Rails)
-    def parameterize(sep="-")
+    def parameterize(seperator='-'.freeze)
       underscore.
-      gsub(/\s+/, "_").
-      gsub("_", sep).
+      gsub(/\s+/, '_'.freeze).
+      gsub('_'.freeze, seperator).
       downcase
     end
   end
 
   unless defined?(Rails)
-    def parameterize!(sep="-")
-      replace(parameterize(sep))
+    def parameterize!(seperator='-'.freeze)
+      replace(parameterize(seperator))
     end
   end
 
-  def pollute(delimiter="^--^--^")
-    split('').map { |c| "#{c}#{delimiter}" }.join
+  def pollute(delimiter='^--^--^'.freeze)
+    split(''.freeze).map { |c| "#{c}#{delimiter}" }.join
+  end
+
+  def pollute!(delimiter='^--^--^'.freeze)
+    replace(pollute(delimiter))
   end
 
   unless defined?(Rails)
     def remove(*patterns)
       string = dup
-      patterns.flatten.each do |pattern|
-        string.gsub!(pattern, "")
-      end
+      patterns.flatten.each { |p| string.gsub!(p, ''.freeze) }
       string
     end
   end
@@ -216,26 +221,24 @@ class String
   end
 
   def remove_tags
-    gsub(/<\/?[^>]*>/, "")
+    gsub(/<\/?[^>]*>/, ''.freeze)
   end
 
   def remove_tags!
     replace(remove_tags)
   end
 
-  def sample(separator=' ')
+  def sample(separator=' '.freeze)
     split(separator).sample
   end
 
-  def sample!(separator=' ')
+  def sample!(separator=' '.freeze)
     replace(sample(separator))
   end
 
   def shift(*patterns)
     string = dup
-    patterns.flatten.each do |pattern|
-      string.sub!(pattern, "")
-    end
+    patterns.flatten.each { |p| string.sub!(p, ''.freeze) }
     string
   end
 
@@ -243,19 +246,19 @@ class String
     replace(shift(*patterns))
   end
 
-  def shuffle(separator='')
+  def shuffle(separator=''.freeze)
     split(separator).shuffle.join
   end
 
-  def shuffle!(separator='')
+  def shuffle!(separator=''.freeze)
     replace(shuffle(separator))
   end
 
   def slugify
-    gsub(/[^\x00-\x7F]+/, '').
-    gsub(/[^\w_ \-]+/i,   '').
-    gsub(/[ \-]+/i,      '-').
-    gsub(/^\-|\-$/i,      '').
+    gsub(/[^\x00-\x7F]+/, ''.freeze).
+    gsub(/[^\w_ \-]+/i,   ''.freeze).
+    gsub(/[ \-]+/i,      '-'.freeze).
+    gsub(/^\-|\-$/i,      ''.freeze).
     downcase
   end
 
@@ -265,7 +268,8 @@ class String
 
   unless defined?(Rails)
     def squish
-      strip.gsub(/\s+/, ' ')
+      strip.
+      gsub(/\s+/, ' '.freeze)
     end
   end
 
@@ -303,14 +307,14 @@ class String
     def truncate(truncate_at, options={})
       return(dup) unless size > truncate_at
 
-      omission = options.fetch(:omission, "...")
+      omission = options.fetch(:omission, '...'.freeze)
       size_with_room_for_omission = truncate_at - omission.size
 
       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
+        rindex(options.fetch(:separator, ''.freeze), size_with_room_for_omission) || size_with_room_for_omission
+      else
+        size_with_room_for_omission
+      end
 
       "#{self[0, stop]}#{omission}"
     end
@@ -318,11 +322,11 @@ class String
 
   unless defined?(Rails)
     def truncate_words(words_count, options={})
-      sep = options[:separator] || /\s+/
+      sep = options.fetch(:separator, /\s+/)
       sep = Regexp.escape(sep.to_s) unless Regexp === sep
 
       if self =~ /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
-        $1 + (options[:omission] || '...')
+        "#{$1}#{options.fetch(:omission, '...'.freeze)}"
       else
         dup
       end
@@ -331,10 +335,10 @@ class String
 
   unless defined?(Rails)
     def underscore
-      gsub(/::/, '/').
-      gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
+      gsub(/::/, '/'.freeze).
+      gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze).
+      gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze).
+      tr('-'.freeze, '_'.freeze).
       downcase
     end
   end
@@ -345,8 +349,12 @@ class String
     end
   end
 
-  def unpollute(delimiter="^--^--^")
-    gsub(delimiter, "")
+  def unpollute(delimiter='^--^--^'.freeze)
+    gsub(delimiter, ''.freeze)
+  end
+
+  def unpollute!(delimiter='^--^--^'.freeze)
+    replace(unpollute(delimiter))
   end
 
   def upcase?