active_object 3.1.0 → 4.0.0

data/lib/active_object/hash.rb

@@ -3,47 +3,52 @@ module ActiveObject::Hash
   def assert_valid_keys(*valid_keys)
     valid_keys.flatten!
 
-    each_key do |k|
-      unless valid_keys.include?(k)
+    each_key do |key|
+      unless valid_keys.include?(key)
         raise ArgumentError,
-          "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+              "Unknown key: #{key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
       end
     end
   end
 
   def compact
-    select { |k, v| !v.nil? }
+    select { |_, val| !val.nil? }
   end
 
   def compact!
-    reject! { |k, v| v.nil? }
+    reject! { |_, val| val.nil? }
   end
 
   def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
+    dup.deep_merge!(other_hash, yield(block))
   end
 
+  # rubocop:disable Metrics/MethodLength
   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
+                            this_value.deep_merge(other_value, yield(block))
+                          elsif block_given? && key?(current_key)
+                            yield(current_key, this_value, other_value)
+                          else
+                            other_value
+                          end
     end
 
     self
   end
+  # rubocop:enable Metrics/MethodLength
 
   def dig(key, *rest)
-    if value = (self[key] rescue nil)
-      if rest.empty?
-        value
-      elsif value.respond_to?(:dig)
-        value.dig(*rest)
-      end
+    value = (self[key] rescue nil)
+    return if value.nil?
+
+    if rest.empty?
+      value
+    elsif value.respond_to?(:dig)
+      value.dig(*rest)
     end
   end
 
@@ -52,7 +57,7 @@ module ActiveObject::Hash
   end
 
   def except!(*keys)
-    keys.flatten.each { |k| delete(k) }
+    keys.flatten.each { |key| delete(key) }
     self
   end
 
@@ -60,16 +65,18 @@ module ActiveObject::Hash
     dup.hmap!(&block)
   end
 
+  # rubocop:disable Lint/UnusedMethodArgument
   def hmap!(&block)
-    inject({}) { |hash, (k, v)| hash.merge(block.call(k, v)) }
+    inject({}) { |hash, (key, val)| hash.merge(yield(key, val)) }
   end
+  # rubocop:enable Lint/UnusedMethodArgument
 
   def nillify
     dup.nillify!
   end
 
   def nillify!
-    each { |k, v| self[k] = nil if !v.nil? && (v.try(:blank?) || v.try(:to_s).blank?) }
+    each { |key, val| self[key] = nil if !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?) }
   end
 
   def only(*keys)
@@ -78,7 +85,7 @@ module ActiveObject::Hash
 
   def only!(*keys)
     hash = {}
-    keys.flatten.each { |k| hash[k] = self[k] if self.has_key?(k) }
+    keys.flatten.each { |key| hash[key] = self[key] if key?(key) }
     replace(hash)
   end
 
@@ -88,7 +95,7 @@ module ActiveObject::Hash
 
   def rename_keys!(*keys)
     keys = Hash[*keys.flatten]
-    keys.each { |k, v| self[v] = delete(k) if self[k] }
+    keys.each { |key, val| self[val] = delete(key) if self[key] }
     self
   end
 
@@ -117,7 +124,7 @@ module ActiveObject::Hash
   end
 
   def sample_key!
-    key, value = sample
+    key, = sample
     delete(key)
     key
   end
@@ -141,7 +148,9 @@ module ActiveObject::Hash
   end
 
   def slice(*keys)
-    keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
+    keys
+      .flatten
+      .each_with_object(self.class.new) { |key, hsh| hsh[key] = self[key] if key?(key) }
   end
 
   def slice!(*keys)
@@ -160,18 +169,17 @@ module ActiveObject::Hash
   end
 
   def stringify_keys!
-    inject({}) do |options, (key, value)|
-      options[key.to_s] = value
-      options
+    each_with_object({}) do |(key, val), options|
+      options[key.to_s] = val
     end
   end
 
   def strip
-    select { |k, v| !v.blank? }
+    select { |_, val| !val.blank? }
   end
 
   def strip!
-    reject! { |k, v| v.blank? }
+    reject! { |_, val| val.blank? }
   end
 
   def symbolize_keys
@@ -179,9 +187,8 @@ module ActiveObject::Hash
   end
 
   def symbolize_keys!
-    inject({}) do |options, (key, value)|
-      options[(key.to_sym rescue key) || key] = value
-      options
+    each_with_object({}) do |(key, val), options|
+      options[(key.to_sym rescue key) || key] = val
     end
   end
 
@@ -190,9 +197,8 @@ module ActiveObject::Hash
   end
 
   def symbolize_and_underscore_keys!
-    inject({}) do |options, (key, value)|
-      options[(key.to_s.gsub(" ", "_").underscore.to_sym rescue key) || key] = value
-      options
+    each_with_object({}) do |(key, val), options|
+      options[(key.to_s.tr(' ', '_').underscore.to_sym rescue key) || key] = val
     end
   end
 
@@ -200,23 +206,27 @@ module ActiveObject::Hash
     dup.transform_keys!(&block)
   end
 
+  # rubocop:disable Lint/UnusedMethodArgument
   def transform_keys!(&block)
     return(enum_for(:transform_keys!)) unless block_given?
 
-    keys.each { |k| self[yield(k)] = delete(k) }
+    each_key { |key| self[yield(key)] = delete(key) }
     self
   end
+  # rubocop:enable Lint/UnusedMethodArgument
 
   def transform_values(&block)
     dup.transform_values!(&block)
   end
 
+  # rubocop:disable Lint/UnusedMethodArgument
   def transform_values!(&block)
     return(enum_for(:transform_values!)) unless block_given?
 
-    each { |k, v| self[k] = yield(v) }
+    each { |key, val| self[key] = yield(val) }
   end
+  # rubocop:enable Lint/UnusedMethodArgument
 
 end
 
-Hash.send(:include, ActiveObject::Hash) if ActiveObject.configuration.autoload_hash
+Hash.send(:include, ActiveObject::Hash) if ActiveObject::Settings.config.autoload_hash

data/lib/active_object/integer.rb

@@ -1,13 +1,12 @@
 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
-  }
+    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) { |p, n| p * n }
+    2.upto(self).inject(1) { |a, e| a * e }
   end
 
   def of(&block)
@@ -15,10 +14,10 @@ module ActiveObject::Integer
   end
 
   def roman
-    return("") if zero?
-    return("-#{(-self).roman}") if self < 0
+    return('') if zero?
+    return("-#{(-self).roman}") if negative?
 
-    ROMAN_VALUES.each { |k, v| return("#{k}#{(self - v).roman}") if v <= self }
+    ROMAN_VALUES.each { |key, val| return("#{key}#{(self - val).roman}") if val <= self }
   end
 
   def time
@@ -27,4 +26,4 @@ module ActiveObject::Integer
 
 end
 
-Integer.send(:include, ActiveObject::Integer) if ActiveObject.configuration.autoload_integer
+Integer.send(:include, ActiveObject::Integer) if ActiveObject::Settings.config.autoload_integer

data/lib/active_object/numeric.rb

@@ -1,29 +1,24 @@
 module ActiveObject::Numeric
-
   MILLI = 0.001
   CENTI = MILLI * 10.0
   DECI = CENTI * 10.0
   DECA = 10.0
   HECTO = DECA * 10.0
   KILO = HECTO * 10.0
-
   KILOBYTE = 1024.0
   MEGABYTE = KILOBYTE * 1024.0
   GIGABYTE = MEGABYTE * 1024.0
   TERABYTE = GIGABYTE * 1024.0
   PETABYTE = TERABYTE * 1024.0
   EXABYTE = PETABYTE * 1024.0
-
   FEET = 12.0
   YARD = FEET * 3.0
   MILE = YARD * 1760.0
   NAUTICAL_MILE = MILE * 1.15078
-
   METRIC_TON = KILO * 1000.0
   POUND = 16.0
   STONE = POUND * 14.0
   TON = POUND * 2000.0
-
   MINUTE = 60.0
   HOUR = MINUTE * 60.0
   DAY = HOUR * 24.0
@@ -34,37 +29,34 @@ module ActiveObject::Numeric
   MILLENNIUM = CENTURY * 10.0
 
   BYTE_KEYS = [
-    :byte, :bytes, :kilobyte, :kilobytes, :megabyte, :megabytes, :gigabyte,
-    :gigabytes, :terabyte, :terabytes, :petabyte, :petabytes, :exabyte, :exabytes
-  ]
+    :byte, :bytes, :kilobyte, :kilobytes, :megabyte, :megabytes, :gigabyte, :gigabytes, :terabyte,
+    :terabytes, :petabyte, :petabytes, :exabyte, :exabytes
+  ].freeze
   LENGTH_KEYS = {
     metric: [
-      :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters,
-      :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers,
-      :kilometer, :kilometers
+      :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
+      :inch, :inches, :foot, :feet, :yard, :yards, :mile, :miles, :nautical_mile, :nautical_miles
     ]
-  }
+  }.freeze
   MASS_KEYS = {
     metric: [
-      :gram, :grams, :milligram, :milligrams, :centigram, :centigrams,
-      :decigram, :decigrams, :decagram, :decagrams, :hectogram, :hectograms,
-      :kilogram, :kilograms, :metric_ton, :metric_tons
+      :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]
+  }.freeze
+  TEMPERATURE_KEYS = [:celsius, :fahrenheit, :kelvin].freeze
   TIME_KEYS = [
-    :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days,
-    :week, :weeks, :year, :years, :decade, :decades, :century, :centuries,
-    :millennium, :millenniums
-  ]
+    :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days, :week, :weeks, :year, :years,
+    :decade, :decades, :century, :centuries, :millennium, :millenniums
+  ].freeze
 
-  def add(n)
-    self + n
+  def add(num)
+    self + num
   end
 
   def bytes_in_bytes
@@ -91,13 +83,20 @@ module ActiveObject::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
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def clamp(minimum, maximum = nil)
+    if maximum.nil? && minimum.is_a?(Range)
+      min_min = minimum.min
+      min_max = minimum.max
+
+      return(min_min) if self < min_min
+      self > min_max ? min_max : self
     else
-      self < min ? min : self > max ? max : self
+      return(minimum) if self < minimum
+      self > maximum ? maximum : self
     end
   end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   def days_in_seconds
     self * DAY
@@ -135,7 +134,7 @@ module ActiveObject::Numeric
 
   alias_method :decimeter_in_meters, :decimeters_in_meters
 
-  def decrement(amount=1.0)
+  def decrement(amount = 1.0)
     self + amount
   end
 
@@ -145,12 +144,12 @@ module ActiveObject::Numeric
 
   alias_method :degree_to_radians, :degrees_to_radians
 
-  def distance(n)
-    (self - n).abs
+  def distance(num)
+    (self - num).abs
   end
 
-  def divide(n)
-    self / n
+  def divide(num)
+    self / num
   end
 
   def exabytes_in_bytes
@@ -177,12 +176,12 @@ module ActiveObject::Numeric
 
   alias_method :gram_in_grams, :grams_in_grams
 
-  def greater_than?(n)
-    self > n
+  def greater_than?(num)
+    self > num
   end
 
-  def greater_than_or_equal_to?(n)
-    self >= n
+  def greater_than_or_equal_to?(num)
+    self >= num
   end
 
   def hectograms_in_grams
@@ -209,7 +208,7 @@ module ActiveObject::Numeric
 
   alias_method :inch_in_inches, :inches_in_inches
 
-  def increment(amount=1.0)
+  def increment(amount = 1.0)
     self + amount
   end
 
@@ -235,12 +234,12 @@ module ActiveObject::Numeric
 
   alias_method :kilogram_in_grams, :kilograms_in_grams
 
-  def less_than?(n)
-    self < n
+  def less_than?(num)
+    self < num
   end
 
-  def less_than_or_equal_to?(n)
-    self <= n
+  def less_than_or_equal_to?(num)
+    self <= num
   end
 
   def metric_tons_in_grams
@@ -291,12 +290,12 @@ module ActiveObject::Numeric
 
   alias_method :minute_in_seconds, :minutes_in_seconds
 
-  def multiply(n)
-    self * n
+  def multiply(num)
+    self * num
   end
 
   def multiple_of?(number)
-    number != 0 ? modulo(number).zero? : zero?
+    number.zero? ? zero? : modulo(number).zero?
   end
 
   def nautical_miles_in_inches
@@ -305,27 +304,27 @@ module ActiveObject::Numeric
 
   alias_method :nautical_mile_in_inches, :nautical_miles_in_inches
 
+  # rubocop:disable Style/NumericPredicate
   def negative?
     self < 0
   end
+  # rubocop:enable Style/NumericPredicate
 
   def ordinal
-    abs_number = abs
-
-    if (11..13).cover?(abs_number % 100)
-      "th"
+    if (11..13).cover?(abs % 100)
+      'th'
     else
-      case abs_number % 10
-      when 1; "st"
-      when 2; "nd"
-      when 3; "rd"
-      else "th"
+      case abs % 10
+      when 1 then 'st'
+      when 2 then 'nd'
+      when 3 then 'rd'
+      else 'th'
       end
     end
   end
 
   def ordinalize
-    "#{self}#{self.ordinal}"
+    "#{self}#{ordinal}"
   end
 
   def ounces_in_ounces
@@ -338,25 +337,32 @@ module ActiveObject::Numeric
     (self < start) || (finish < self)
   end
 
-  def pad(options={})
-    pad_number = options.fetch(:pad_number, 0)
-    precision = options.fetch(:precision, 3)
+  def pad(options = {})
+    pad_number = options[:pad_number] || 0
+    precision = options[: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, ".")
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+  def pad_precision(options = {})
+    pad_number = options[:pad_number] || 0
+    precision = options[:precision] || 2
+    separator = options[:separator] || '.'
     string = to_s
 
     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
-    ljust_count >= num_count ? string.ljust(ljust_count, pad_number.to_s) : string[0..(ljust_count - 1)]
+    ljust_count = string.split(separator).first.length
+    ljust_count += (string.count(separator) + precision) if precision.positive?
+    if ljust_count >= string.length
+      string.ljust(ljust_count, pad_number.to_s)
+    else
+      string[0..(ljust_count - 1)]
+    end
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
   def petabytes_in_bytes
     self * PETABYTE
@@ -364,9 +370,11 @@ module ActiveObject::Numeric
 
   alias_method :petabyte_in_bytes, :petabytes_in_bytes
 
+  # rubocop:disable Style/NumericPredicate
   def positive?
     self > 0
   end
+  # rubocop:enable Style/NumericPredicate
 
   def pounds_in_ounces
     self * POUND
@@ -374,12 +382,12 @@ module ActiveObject::Numeric
 
   alias_method :pound_in_ounces, :pounds_in_ounces
 
-  def power(n)
-    self ** n
+  def power(num)
+    self**num
   end
 
-  def root(n)
-    self ** (1.0 / n)
+  def root(num)
+    self**(1.0 / num)
   end
 
   def seconds_in_seconds
@@ -394,8 +402,8 @@ module ActiveObject::Numeric
 
   alias_method :stone_in_ounces, :stones_in_ounces
 
-  def subtract(n)
-    self - n
+  def subtract(num)
+    self - num
   end
 
   def terabytes_in_bytes
@@ -405,105 +413,96 @@ module ActiveObject::Numeric
   alias_method :terabyte_in_bytes, :terabytes_in_bytes
 
   def to_byte(from, 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: #{BYTE_KEYS.map(&:inspect).join(', ')}"
-    end
+    assert_valid_keys!(BYTE_KEYS, from, to)
 
     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, "$")
+  def to_currency(options = {})
+    unit = options[:unit] || '$'
 
     "#{unit}#{pad_precision(options.only(:precision))}"
   end
 
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
   def to_length(from, to)
+    assert_valid_keys!(LENGTH_KEYS.values.flatten, from, to)
     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(', ')}"
-    end
+    return(self) if from == to
+    metrics_included_from = metric_keys.include?(from)
 
     case to
-    when from
-      self
-    when :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters, :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers, :kilometer, :kilometers
-      if metric_keys.include?(from)
+    when :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters, :decimeter,
+         :decimeters, :decameter, :decameters, :hectometer, :hectometers, :kilometer, :kilometers
+      if metrics_included_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 metric_keys.include?(from)
+      if metrics_included_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
       end
     end
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
   def to_mass(from, to)
+    assert_valid_keys!(MASS_KEYS.values.flatten, from, to)
     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(', ')}"
-    end
+    return(self) if from == to
+    metrics_included_from = metric_keys.include?(from)
 
     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 metric_keys.include?(from)
+    when :gram, :grams, :milligram, :milligrams, :centigram, :centigrams, :decigram, :decigrams,
+         :decagram, :decagrams, :hectogram, :hectograms, :kilogram, :kilograms, :metric_ton,
+         :metric_tons
+      if metrics_included_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 metric_keys.include?(from)
+      if metrics_included_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
       end
     end
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-  def to_nearest_value(values=[])
+  def to_nearest_value(values = [])
     return(self) if values.length.zero?
 
     value = values.first
     difference = (self - value).abs
 
-    values.each do |v|
-      if (self - v).abs < difference
-        difference = (self - v).abs
-        value = v
+    values.each do |val|
+      if (self - val).abs < difference
+        difference = (self - val).abs
+        value = val
       end
     end
 
     value
   end
 
-  def to_percentage(options={})
-    unit = options.fetch(:unit, "%")
+  def to_percentage(options = {})
+    unit = options[:unit] || '%'
 
     "#{pad_precision(options.only(:precision))}#{unit}"
   end
 
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
   def to_temperature(from, 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: #{TEMPERATURE_KEYS.map(&:inspect).join(', ')}"
-    end
+    assert_valid_keys!(TEMPERATURE_KEYS, from, to)
+    return(self) if from == to
 
     case to
-    when from
-      self
     when :celsius
       from == :kelvin ? (self - 273.15) : ((self - 32.0) * 5.0 / 9.0)
     when :fahrenheit
@@ -512,12 +511,10 @@ module ActiveObject::Numeric
       from == :celsius ? (self + 273.15) : (((self - 32.0) * 5.0 / 9.0) + 273.15)
     end
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
   def to_time(from, 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: #{TIME_KEYS.map(&:inspect).join(', ')}"
-    end
+    assert_valid_keys!(TIME_KEYS, from, to)
 
     (to_f * 1.send("#{from}_in_seconds").to_f) / 1.send("#{to}_in_seconds").to_f
   end
@@ -534,12 +531,13 @@ module ActiveObject::Numeric
 
   alias_method :week_in_seconds, :weeks_in_seconds
 
-  def within?(number, epsilon=0.01)
+  def within?(number, epsilon = 0.01)
     return(self == number) if epsilon.zero?
 
-    a, b = to_f, number.to_f
+    alpha = to_f
+    beta = number.to_f
 
-    (a.zero? || b.zero?) ? ((a - b).abs < epsilon) : ((a / b - 1).abs < epsilon)
+    alpha.zero? || beta.zero? ? (alpha - beta).abs < epsilon : (alpha / beta - 1).abs < epsilon
   end
 
   def yards_in_inches
@@ -554,6 +552,18 @@ module ActiveObject::Numeric
 
   alias_method :year_in_seconds, :years_in_seconds
 
+  private
+
+  def assert_valid_keys!(cns, from, to)
+    unless cns.include?(from) && cns.include?(to)
+      raise ArgumentError,
+            [
+              "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}.",
+              "Valid keys are: #{cns.map(&:inspect).join(', ')}"
+            ].join(' ')
+    end
+  end
+
 end
 
-Numeric.send(:include, ActiveObject::Numeric) if ActiveObject.configuration.autoload_numeric
+Numeric.send(:include, ActiveObject::Numeric) if ActiveObject::Settings.config.autoload_numeric