active_object 2.5.2 → 3.0.0

data/lib/active_object/enumerable.rb

@@ -2,7 +2,6 @@ module Enumerable
 
   def cluster(&block)
     result = []
-
     each do |element|
       if result.last && (yield(result.last.last) == yield(element))
         result.last << element
@@ -10,7 +9,6 @@ module Enumerable
         result << [element]
       end
     end
-
     result
   end
 
@@ -41,7 +39,7 @@ module Enumerable
   def drop_last_if
     return(to_enum(:drop_last_if)) unless block_given?
 
-    result   = []
+    result = []
     dropping = true
     reverse_each do |value|
       result.unshift(value) unless dropping &&= yield(value)
@@ -55,10 +53,8 @@ module Enumerable
     (found_count > n) ? false : n == found_count
   end
 
-  unless defined?(Rails)
-    def exclude?(object)
-      !include?(object)
-    end
+  def exclude?(object)
+    !include?(object)
   end
 
   def expand
@@ -81,17 +77,15 @@ module Enumerable
     any? { |x| object === x }
   end
 
-  unless defined?(Rails)
-    def many?
-      found_count = 0
-      if block_given?
-        any? do |v|
-          found_count += 1 if yield v
-          found_count > 1
-        end
-      else
-        any? { (found_count += 1) > 1 }
+  def many?
+    found_count = 0
+    if block_given?
+      any? do |v|
+        found_count += 1 if yield v
+        found_count > 1
       end
+    else
+      any? { (found_count += 1) > 1 }
     end
   end
 
@@ -110,6 +104,8 @@ module Enumerable
     sum.to_f / collection_length.to_f
   end
 
+  alias_method :average, :mean
+
   def median(identity=0)
     collection_length   = length.to_f
     collection_sorted = sort
@@ -127,7 +123,7 @@ module Enumerable
     return(identity) unless length > 0
 
     frequency_distribution = inject(Hash.new(0)) { |h, v| h[v] += 1; h }
-    frequency_top_two      = frequency_distribution.sort { |k, v| v[1] <=> k[1] }.take(2)
+    frequency_top_two = frequency_distribution.sort { |k, v| v[1] <=> k[1] }.take(2)
 
     if frequency_top_two.length == 1
       frequency_top_two.first.first
@@ -165,13 +161,11 @@ module Enumerable
     Math.sqrt(variance)
   end
 
-  unless defined?(Rails)
-    def sum(identity=0, &block)
-      if block_given?
-        map(&block).sum(identity)
-      else
-        inject { |s, v| s + v } || identity
-      end
+  def sum(identity=0, &block)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject { |s, v| s + v } || identity
     end
   end
 
@@ -200,4 +194,4 @@ module Enumerable
     sum.to_f / (collection_length.to_f - 1.0)
   end
 
-end
+end

data/lib/active_object/hash.rb

@@ -1,48 +1,49 @@
-class Hash
-
-  unless defined?(Rails)
-    def assert_valid_keys(*valid_keys)
-      valid_keys.flatten!
-      each_key do |k|
-        unless valid_keys.include?(k)
-          raise ArgumentError,
-            "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
-        end
+module ActiveObject::Hash
+
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError,
+          "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
       end
     end
   end
 
-  unless defined?(Rails)
-    def compact
-      select { |k, v| !v.nil? }
-    end
+  def compact
+    select { |k, v| !v.nil? }
   end
 
-  unless defined?(Rails)
-    def compact!
-      reject! { |k, v| v.nil? }
-    end
+  def compact!
+    reject! { |k, v| v.nil? }
   end
 
-  unless defined?(Rails)
-    def deep_merge(other_hash, &block)
-      dup.deep_merge!(other_hash, &block)
-    end
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
   end
 
-  unless defined?(Rails)
-    def deep_merge!(other_hash, &block)
-      other_hash.each_pair do |current_key, other_value|
-        this_value = self[current_key]
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
 
-        self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
-          this_value.deep_merge(other_value, &block)
-        else
-          block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
-        end
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        this_value.deep_merge(other_value, &block)
+      else
+        block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
       end
+    end
 
-      self
+    self
+  end
+
+  def dig(key, *rest)
+    if value = (self[key] rescue nil)
+      if rest.empty?
+        value
+      elsif value.respond_to?(:dig)
+        value.dig(*rest)
+      end
     end
   end
 
@@ -91,16 +92,12 @@ class Hash
     self
   end
 
-  unless defined?(Rails)
-    def reverse_merge(other_hash)
-      other_hash.merge(self)
-    end
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
   end
 
-  unless defined?(Rails)
-    def reverse_merge!(other_hash)
-      replace(reverse_merge(other_hash))
-    end
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
   end
 
   def sample
@@ -143,37 +140,29 @@ class Hash
     replace(shuffle)
   end
 
-  unless defined?(Rails)
-    def slice(*keys)
-      keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
-    end
+  def slice(*keys)
+    keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
   end
 
-  unless defined?(Rails)
-    def slice!(*keys)
-      omit = slice(*self.keys - keys)
-      hash = slice(*keys)
+  def slice!(*keys)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
 
-      hash.default      = default
-      hash.default_proc = default_proc if default_proc
+    hash.default = default
+    hash.default_proc = default_proc if default_proc
 
-      replace(hash)
-      omit
-    end
+    replace(hash)
+    omit
   end
 
-  unless defined?(Rails)
-    def stringify_keys
-      dup.stringify_keys!
-    end
+  def stringify_keys
+    dup.stringify_keys!
   end
 
-  unless defined?(Rails)
-    def stringify_keys!
-      inject({}) do |options, (key, value)|
-        options[key.to_s] = value
-        options
-      end
+  def stringify_keys!
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
     end
   end
 
@@ -185,18 +174,14 @@ class Hash
     reject! { |k, v| v.blank? }
   end
 
-  unless defined?(Rails)
-    def symbolize_keys
-      dup.symbolize_keys!
-    end
+  def symbolize_keys
+    dup.symbolize_keys!
   end
 
-  unless defined?(Rails)
-    def symbolize_keys!
-      inject({}) do |options, (key, value)|
-        options[(key.to_sym rescue key) || key] = value
-        options
-      end
+  def symbolize_keys!
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
     end
   end
 
@@ -206,38 +191,32 @@ class Hash
 
   def symbolize_and_underscore_keys!
     inject({}) do |options, (key, value)|
-      options[(key.to_s.gsub(' '.freeze, '_'.freeze).underscore.to_sym rescue key) || key] = value
+      options[(key.to_s.gsub(" ", "_").underscore.to_sym rescue key) || key] = value
       options
     end
   end
 
-  unless defined?(Rails)
-    def transform_keys(&block)
-      dup.transform_keys!(&block)
-    end
+  def transform_keys(&block)
+    dup.transform_keys!(&block)
   end
 
-  unless defined?(Rails)
-    def transform_keys!(&block)
-      return(enum_for(:transform_keys!)) unless block_given?
+  def transform_keys!(&block)
+    return(enum_for(:transform_keys!)) unless block_given?
 
-      keys.each { |k| self[yield(k)] = delete(k) }
-      self
-    end
+    keys.each { |k| self[yield(k)] = delete(k) }
+    self
   end
 
-  unless defined?(Rails)
-    def transform_values(&block)
-      dup.transform_values!(&block)
-    end
+  def transform_values(&block)
+    dup.transform_values!(&block)
   end
 
-  unless defined?(Rails)
-    def transform_values!(&block)
-      return(enum_for(:transform_values!)) unless block_given?
+  def transform_values!(&block)
+    return(enum_for(:transform_values!)) unless block_given?
 
-      each { |k, v| self[k] = yield(v) }
-    end
+    each { |k, v| self[k] = yield(v) }
   end
 
-end
+end
+
+Hash.send(:include, ActiveObject::Hash) if ActiveObject.configuration.autoload_hash

data/lib/active_object/integer.rb

@@ -1,20 +1,9 @@
-class Integer
+module ActiveObject::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
-  }.freeze
+    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
+  }
 
   def factorial
     return(1) if zero?
@@ -26,7 +15,7 @@ class Integer
   end
 
   def roman
-    return(''.freeze) if zero?
+    return("") if zero?
     return("-#{(-self).roman}") if self < 0
 
     ROMAN_VALUES.each { |k, v| return("#{k}#{(self - v).roman}") if v <= self }
@@ -36,4 +25,6 @@ class Integer
     Time.at(self)
   end
 
-end
+end
+
+Integer.send(:include, ActiveObject::Integer) if ActiveObject.configuration.autoload_integer

data/lib/active_object/numeric.rb

@@ -1,40 +1,68 @@
-class Numeric
+module ActiveObject::Numeric
 
   MILLI = 0.001
   CENTI = MILLI * 10
-  DECI  = CENTI * 10
-  DECA  = 10
+  DECI = CENTI * 10
+  DECA = 10
   HECTO = DECA * 10
-  KILO  = HECTO * 10
-
-  unless defined?(Rails)
-    KILOBYTE = 1024
-    MEGABYTE = KILOBYTE * 1024
-    GIGABYTE = MEGABYTE * 1024
-    TERABYTE = GIGABYTE * 1024
-    PETABYTE = TERABYTE * 1024
-    EXABYTE  = PETABYTE * 1024
-  end
-
-  FEET          = 12
-  YARD          = FEET * 3
-  MILE          = YARD * 1760
+  KILO = HECTO * 10
+
+  KILOBYTE = 1024
+  MEGABYTE = KILOBYTE * 1024
+  GIGABYTE = MEGABYTE * 1024
+  TERABYTE = GIGABYTE * 1024
+  PETABYTE = TERABYTE * 1024
+  EXABYTE = PETABYTE * 1024
+
+  FEET = 12
+  YARD = FEET * 3
+  MILE = YARD * 1760
   NAUTICAL_MILE = MILE * 1.15078
 
   METRIC_TON = KILO * 1000
-  POUND      = 16
-  STONE      = POUND * 14
-  TON        = POUND * 2000
-
-  MINUTE     = 60
-  HOUR       = MINUTE * 60
-  DAY        = HOUR * 24
-  WEEK       = DAY * 7
-  YEAR       = DAY * 365.25
-  DECADE     = YEAR * 10
-  CENTURY    = DECADE * 10
+  POUND = 16
+  STONE = POUND * 14
+  TON = POUND * 2000
+
+  MINUTE = 60
+  HOUR = MINUTE * 60
+  DAY = HOUR * 24
+  WEEK = DAY * 7
+  YEAR = DAY * 365.25
+  DECADE = YEAR * 10
+  CENTURY = DECADE * 10
   MILLENNIUM = CENTURY * 10
 
+  BYTE_KEYS = [
+    :byte, :bytes, :kilobyte, :kilobytes, :megabyte, :megabytes, :gigabyte,
+    :gigabytes, :terabyte, :terabytes, :petabyte, :petabytes, :exabyte, :exabytes
+  ]
+  LENGTH_KEYS = {
+    metric: [
+      :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters,
+      :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers,
+      :kilometer, :kilometers
+    ],
+    imperical: [
+      :inch, :inches, :foot, :feet, :yard, :yards, :mile, :miles,
+      :nautical_mile, :nautical_miles
+    ]
+  }
+  MASS_KEYS = {
+    metric: [
+      :gram, :grams, :milligram, :milligrams, :centigram, :centigrams,
+      :decigram, :decigrams, :decagram, :decagrams, :hectogram, :hectograms,
+      :kilogram, :kilograms, :metric_ton, :metric_tons
+    ],
+    imperical: [:ounce, :ounces, :pound, :pounds, :stone, :stones, :ton, :tons]
+  }
+  TEMPERATURE_KEYS = [:celsius, :fahrenheit, :kelvin]
+  TIME_KEYS = [
+    :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days,
+    :week, :weeks, :year, :years, :decade, :decades, :century, :centuries,
+    :millennium, :millenniums
+  ]
+
   def add(n)
     self + n
   end
@@ -63,6 +91,14 @@ class Numeric
 
   alias_method :century_in_seconds, :centuries_in_seconds
 
+  def clamp(min, max=nil)
+    if max.nil? && min.is_a?(Range)
+      self < min.min ? min.min : self > min.max ? min.max : self
+    else
+      self < min ? min : self > max ? max : self
+    end
+  end
+
   def days_in_seconds
     self * DAY
   end
@@ -99,6 +135,16 @@ class Numeric
 
   alias_method :decimeter_in_meters, :decimeters_in_meters
 
+  def decrement(amount=1.0)
+    self + amount
+  end
+
+  def degrees_to_radians
+    self * Math::PI / 180.0
+  end
+
+  alias_method :degree_to_radians, :degrees_to_radians
+
   def distance(n)
     (self - n).abs
   end
@@ -163,6 +209,10 @@ class Numeric
 
   alias_method :inch_in_inches, :inches_in_inches
 
+  def increment(amount=1.0)
+    self + amount
+  end
+
   def inside?(start, finish)
     (start < self) && (self < finish)
   end
@@ -245,10 +295,8 @@ class Numeric
     self * n
   end
 
-  unless defined?(Rails)
-    def multiple_of?(number)
-      number != 0 ? modulo(number).zero? : zero?
-    end
+  def multiple_of?(number)
+    number != 0 ? modulo(number).zero? : zero?
   end
 
   def nautical_miles_in_inches
@@ -261,27 +309,23 @@ class Numeric
     self < 0
   end
 
-  unless defined?(Rails)
-    def ordinal
-      abs_number = abs
+  def ordinal
+    abs_number = abs
 
-      if (11..13).cover?(abs_number % 100)
-        'th'.freeze
-      else
-        case abs_number % 10
-          when 1; 'st'.freeze
-          when 2; 'nd'.freeze
-          when 3; 'rd'.freeze
-          else    'th'.freeze
-        end
+    if (11..13).cover?(abs_number % 100)
+      "th"
+    else
+      case abs_number % 10
+      when 1; "st"
+      when 2; "nd"
+      when 3; "rd"
+      else "th"
       end
     end
   end
 
-  unless defined?(Rails)
-    def ordinalize
-      "#{self}#{self.ordinal}"
-    end
+  def ordinalize
+    "#{self}#{self.ordinal}"
   end
 
   def ounces_in_ounces
@@ -296,21 +340,21 @@ class Numeric
 
   def pad(options={})
     pad_number = options.fetch(:pad_number, 0)
-    precision  = options.fetch(:precision, 3)
+    precision = options.fetch(:precision, 3)
 
     to_s.rjust(precision, pad_number.to_s)
   end
 
   def pad_precision(options={})
     pad_number = options.fetch(:pad_number, 0)
-    precision  = options.fetch(:precision, 2)
-    separator  = options.fetch(:separator, '.'.freeze)
-    string     = to_s
+    precision = options.fetch(:precision, 2)
+    separator = options.fetch(:separator, ".")
+    string = to_s
 
-    string      << separator unless string.include?(separator)
+    string << separator unless string.include?(separator)
     ljust_count =  string.split(separator).first.length
     ljust_count += (string.count(separator) + precision) if precision > 0
-    num_count   =  string.length
+    num_count =  string.length
     ljust_count >= num_count ? string.ljust(ljust_count, pad_number.to_s) : string[0..(ljust_count - 1)]
   end
 
@@ -361,62 +405,40 @@ class Numeric
   alias_method :terabyte_in_bytes, :terabytes_in_bytes
 
   def to_byte(from, to)
-    valid_keys = [
-      :byte,     :bytes,
-      :kilobyte, :kilobytes,
-      :megabyte, :megabytes,
-      :gigabyte, :gigabytes,
-      :terabyte, :terabytes,
-      :petabyte, :petabytes,
-      :exabyte,  :exabytes
-    ].freeze
-
-    unless valid_keys.include?(from) && valid_keys.include?(to)
+    unless BYTE_KEYS.include?(from) && BYTE_KEYS.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{BYTE_KEYS.map(&:inspect).join(', ')}"
     end
 
     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, '$'.freeze)
+    unit = options.fetch(:unit, "$")
 
     "#{unit}#{pad_precision(options.only(:precision))}"
   end
 
   def to_length(from, to)
-    valid_keys = [
-      :meter,         :meters,
-      :millimeter,    :millimeters,
-      :centimeter,    :centimeters,
-      :decimeter,     :decimeters,
-      :decameter,     :decameters,
-      :hectometer,    :hectometers,
-      :kilometer,     :kilometers,
-      :inch,          :inches,
-      :foot,          :feet,
-      :yard,          :yards,
-      :mile,          :miles,
-      :nautical_mile, :nautical_miles
-    ].freeze
+    metric_keys = LENGTH_KEYS.fetch(:metric)
+    valid_keys = LENGTH_KEYS.collect { |k, v| v }.flatten
 
     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(', '.freeze)}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
 
     case to
     when from
       self
     when :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters, :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers, :kilometer, :kilometers
-      if valid_keys.first(14).include?(from)
+      if metric_keys.include?(from)
         to_f * 1.send("#{from}_in_meters").to_f / 1.send("#{to}_in_meters").to_f
       else
         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)
+      if metric_keys.include?(from)
         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").to_f / 1.send("#{to}_in_inches").to_f
@@ -425,37 +447,25 @@ class Numeric
   end
 
   def to_mass(from, to)
-    valid_keys = [
-      :gram,       :grams,
-      :milligram,  :milligrams,
-      :centigram,  :centigrams,
-      :decigram,   :decigrams,
-      :decagram,   :decagrams,
-      :hectogram,  :hectograms,
-      :kilogram,   :kilograms,
-      :metric_ton, :metric_tons,
-      :ounce,      :ounces,
-      :pound,      :pounds,
-      :stone,      :stones,
-      :ton,        :tons
-    ].freeze
+    metric_keys = MASS_KEYS.fetch(:metric)
+    valid_keys = MASS_KEYS.collect { |k, v| v }.flatten
 
     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(', '.freeze)}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
 
     case to
     when from
       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)
+      if metric_keys.include?(from)
         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).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)
+      if metric_keys.include?(from)
         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").to_f / 1.send("#{to}_in_ounces").to_f
@@ -466,13 +476,13 @@ class Numeric
   def to_nearest_value(values=[])
     return(self) if values.length.zero?
 
-    value      = values.first
+    value = values.first
     difference = (self - value).abs
 
     values.each do |v|
       if (self - v).abs < difference
         difference = (self - v).abs
-        value      = v
+        value = v
       end
     end
 
@@ -480,52 +490,36 @@ class Numeric
   end
 
   def to_percentage(options={})
-    unit = options.fetch(:unit, '%'.freeze)
+    unit = options.fetch(:unit, "%")
 
     "#{pad_precision(options.only(:precision))}#{unit}"
   end
 
   def to_temperature(from, to)
-    valid_keys = [:celsius, :fahrenheit, :kelvin].freeze
-
-    unless valid_keys.include?(from) && valid_keys.include?(to)
+    unless TEMPERATURE_KEYS.include?(from) && TEMPERATURE_KEYS.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{TEMPERATURE_KEYS.map(&:inspect).join(', ')}"
     end
 
-    number = to_f
-
     case to
     when from
       self
     when :celsius
-      from == :kelvin ? (number - 273.15) : ((number - 32.0) * 5.0 / 9.0)
+      from == :kelvin ? (self - 273.15) : ((self - 32.0) * 5.0 / 9.0)
     when :fahrenheit
-      from == :kelvin ? (1.8 * (number - 273.15) + 32.0) : ((number * 9.0 / 5.0) + 32.0)
+      from == :kelvin ? (1.8 * (self - 273.15) + 32.0) : ((self * 9.0 / 5.0) + 32.0)
     when :kelvin
-      from == :celsius ? (number + 273.15) : (((number - 32.0) * 5.0 / 9.0) + 273.15)
+      from == :celsius ? (self + 273.15) : (((self - 32.0) * 5.0 / 9.0) + 273.15)
     end
   end
 
   def to_time(from, to)
-    valid_keys = [
-      :second,     :seconds,
-      :minute,     :minutes,
-      :hour,       :hours,
-      :day,        :days,
-      :week,       :weeks,
-      :year,       :years,
-      :decade,     :decades,
-      :century,    :centuries,
-      :millennium, :millenniums
-    ].freeze
-
-    unless valid_keys.include?(from) && valid_keys.include?(to)
+    unless TIME_KEYS.include?(from) && TIME_KEYS.include?(to)
       raise ArgumentError,
-        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
+        "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{TIME_KEYS.map(&:inspect).join(', ')}"
     end
 
-    to_f * 1.send("#{from}_in_seconds").to_f / 1.send("#{to}_in_seconds").to_f
+    (to_f * 1.send("#{from}_in_seconds").to_f) / 1.send("#{to}_in_seconds").to_f
   end
 
   def tons_in_ounces
@@ -560,4 +554,6 @@ class Numeric
 
   alias_method :year_in_seconds, :years_in_seconds
 
-end
+end
+
+Numeric.send(:include, ActiveObject::Numeric) if ActiveObject.configuration.autoload_numeric