active_object 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 338a756fe3022d25112ff46e8ed0ecf5e440802f
-  data.tar.gz: a106f60c397ee297ea41cb25c14a41b41cedf409
+  metadata.gz: 0c35a60abef56e9ea9870c84558acaac13aa28ac
+  data.tar.gz: 09f6b138d6cb164223cb7ebe9a92646a928ca52e
 SHA512:
-  metadata.gz: e6934080ed8fb2ba7800456ba45060c5309abcc6a12421c5aa03977e7763f1fc3049ecdc215df479d51613d497a614c0959843bc0fdc685e9605f91a40c70458
-  data.tar.gz: 04d344c1bd0d18bfef39f1f842ccc1d232a1e28426ea96148cd3f2859c32b9e06c273611e82f8db94bd5e6614871a2fbd669a356ab11d0fb408d38deabee4f7e
+  metadata.gz: 3d6d2c9eb4fe5c059c75394453b32c421f41632049d73779b18661b4132ee649e38bf38887b3e5c51d3757f51f9fc73a54fc9c0e3bb2269b423e77046080b46e
+  data.tar.gz: 78eff913f5c5cd9bcb2389d8c19a48370516be2b9311224f7182fb60907645c0d1d3bdea3990ba3a698d12050c24c1053c9cec8ffa14c78afab88fe3a6f63f32

data/README.md

@@ -470,73 +470,73 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 4.add(2) #=> 6
 ```
 
-####Bytes:####
-`byte` and `bytes` returns self.
+####Bytes in Bytes:####
+`byte_in_bytes` and `bytes_in_bytes` returns self.
 
 ```ruby
-3.bytes #=> 3
+3.bytes_in_bytes #=> 3
 ```
 
-####Centigrams:####
-`centigram` and `centigrams` returns the amount of grams in n centigrams.
+####Centigrams in Grams:####
+`centigram_in_grams` and `centigrams_in_grams` returns the amount of grams in n centigrams.
 
 ```ruby
-3.centigrams #=> 0.03
+3.centigrams_in_grams #=> 0.03
 ```
 
-####Centimeters:####
-`centimeter` and `centimeters` returns the amount of meters in n centimeters.
+####Centimeters in Meters:####
+`centimeter_in_meters` and `centimeters_in_meters` returns the amount of meters in n centimeters.
 
 ```ruby
-3.centimeters #=> 0.03
+3.centimeters_in_meters #=> 0.03
 ```
 
-####Centuries:####
-`century` and `centuries` returns the amount of seconds in n centuries.
+####Centuries_in_seconds:####
+`century_in_seconds` and `centuries_in_seconds` returns the amount of seconds in n centuries.
 
 ```ruby
-3.centuries #=> 9467280000.0
+3.centuries_in_seconds #=> 9467280000.0
 ```
 
-####Decades:####
-`decade` and `decades` returns the amount of seconds in n decades.
+####Decades in Seconds:####
+`decade_in_seconds` and `decades_in_seconds` returns the amount of seconds in n decades.
 
 ```ruby
-3.decades #=> 946728000.0
+3.decades_in_seconds #=> 946728000.0
 ```
-####Decagrams:####
-`decagram` and `decagrams` returns the amount of grams in n decagrams.
+####Decagrams in Grams:####
+`decagram_in_grams` and `decagrams_in_grams` returns the amount of grams in n decagrams.
 
 ```ruby
-3.decagrams #=> 30
+3.decagrams_in_grams #=> 30
 ```
 
-####Decameters:####
-`decameter` and `decameters` returns the amount of meters in n decameters.
+####Decameters in Meters:####
+`decameter_in_meters` and `decameters_in_meters` returns the amount of meters in n decameters.
 
 ```ruby
-3.decameters #=> 30
+3.decameters_in_meters #=> 30
 ```
 
-####Decigrams:####
-`decigram` and `decigrams` returns the amount of grams in n decigrams.
+####Decigrams in Grams:####
+`decigram_in_grams` and `decigrams_in_grams` returns the amount of grams in n decigrams.
 
 ```ruby
-3.decigrams #=> 0.3
+3.decigrams_in_grams #=> 0.3
 ```
 
-####Decimeters:####
-`decimeter` and `decimeters` returns the amount of meters in n decimeters.
+####Decimeters in Meters:####
+`decimeter_in_meters` and `decimeters_in_meters` returns the amount of meters in n decimeters.
 
 ```ruby
-3.decimeters #=> 0.3
+3.decimeters_in_meters #=> 0.3
 ```
 
-####Days:####
-`day` and `days` returns the amount of seconds in n days.
+####Days in Seconds:####
+`day_in_seconds` and `days_in_seconds` returns the amount of seconds in n days.
 
 ```ruby
-3.days #=> 259200
+3.days_in_seconds #=> 259200
 ```
 
 ####Divide:####
@@ -546,137 +546,137 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 4.divide(2) #=> 2
 ```
 
-####Exabytes:####
-`exabyte` and `exabytes` returns the amount of bytes in n exabytes.
+####Exabytes in Bytes:####
+`exabyte_in_bytes` and `exabytes_in_bytes` returns the amount of bytes in n exabytes.
 
 ```ruby
-3.exabytes #=> 3458764513820540928
+3.exabytes_in_bytes #=> 3458764513820540928
 ```
 
-####Feet:####
-`foot` and `feet` returns the amount of inches in n feet.
+####Feet in Inches:####
+`foot_in_inches` and `feet_in_inches` returns the amount of inches in n feet.
 
 ```ruby
-3.feet #=> 36
+3.feet_in_inches #=> 36
 ```
 
-####Gigabytes:####
-`gigabyte` and `gigabytes` returns the amount of bytes in n gigabytes.
+####Gigabytes in Bytes:####
+`gigabyte_in_bytes` and `gigabytes_in_bytes` returns the amount of bytes in n gigabytes.
 
 ```ruby
-3.gigabytes #=> 3221225472
+3.gigabytes_in_bytes #=> 3221225472
 ```
 
-####Grams:####
-`gram` and `grams` returns self.
+####Grams in Grams:####
+`gram_in_grams` and `grams_in_grams` returns self.
 
 ```ruby
-3.grams #=> 3
+3.grams_in_grams #=> 3
 ```
 
-####Hectograms:####
-`hectogram` and `hectograms` returns the amount of grams in n hectograms.
+####Hectograms in Grams:####
+`hectogram_in_grams` and `hectograms_in_grams` returns the amount of grams in n hectograms.
 
 ```ruby
-3.hectograms #=> 300
+3.hectograms_in_grams #=> 300
 ```
 
-####Hectometers:####
-`hectometer` and `hectometers` returns the amount of meters in n hectometers.
+####Hectometers in Meters:####
+`hectometer_in_meters` and `hectometers_in_meters` returns the amount of meters in n hectometers.
 
 ```ruby
-3.hectometers #=> 300
+3.hectometers_in_meters #=> 300
 ```
 
-####Hours:####
-`hour` and `hours` returns the amount of seconds in n hours.
+####Hours in Seconds:####
+`hour_in_seconds` and `hours_in_seconds` returns the amount of seconds in n hours.
 
 ```ruby
-3.hours #=> 10800
+3.hours_in_seconds #=> 10800
 ```
 
-####Inches:####
-`inch` and `inches` returns the amount of inches in n inches.
+####Inches in Inches:####
+`inch_in_inches` and `inches_in_inches` returns the amount of inches in n inches.
 
 ```ruby
-3.inches #=> 3
+3.inches_in_inches #=> 3
 ```
 
-####Kilobytes:####
-`kilobyte` and `kilobytes` returns the amount of bytes in n kilobytes.
+####Kilobytes in Bytes:####
+`kilobyte_in_bytes` and `kilobytes_in_bytes` returns the amount of bytes in n kilobytes.
 
 ```ruby
-3.kilobytes #=> 3072
+3.kilobytes_in_bytes #=> 3072
 ```
 
-####Kilograms:####
-`kilogram` and `kilograms` returns the amount of grams in n kilograms.
+####Kilograms in Grams:####
+`kilogram_in_grams` and `kilograms_in_grams` returns the amount of grams in n kilograms.
 
 ```ruby
-3.kilograms #=> 3000
+3.kilograms_in_grams #=> 3000
 ```
 
-####Kilometers:####
-`kilometer` and `kilometers` returns the amount of meters in n kilometers.
+####Kilometers in Meters:####
+`kilometer_in_meters` and `kilometers_in_meters` returns the amount of meters in n kilometers.
 
 ```ruby
-3.kilometers #=> 3000
+3.kilometers_in_meters #=> 3000
 ```
 
-####Metric Ton:####
-`metric_ton` and `metric_tons` returns the amount of grams in n metric_tons.
+####Metric Ton in Ounces:####
+`metric_ton_in_ounces` and `metric_tons_in_ounces` returns the amount of grams in n metric_tons.
 
 ```ruby
-3.metric_tons #=> 3000000
+3.metric_tons_in_ounces #=> 3000000
 ```
 
-####Megabytes:####
-`megabyte` and `megabytes` returns the amount of bytes in n megabytes.
+####Megabytes in Bytes:####
+`megabyte_in_bytes` and `megabytes_in_bytes` returns the amount of bytes in n megabytes.
 
 ```ruby
-3.megabytes #=> 3145728
+3.megabytes_in_bytes #=> 3145728
 ```
 
-####Meters:####
-`meter` and `meters` returns self.
+####Meters in Meters:####
+`meter_in_meters` and `meters_in_meters` returns self.
 
 ```ruby
-3.meters #=> 3
+3.meters_in_meters #=> 3
 ```
 
-####Miles:####
-`mile` and `miles` returns the amount of inches in n miles.
+####Miles in Inches:####
+`mile_in_inches` and `miles_in_inches` returns the amount of inches in n miles.
 
 ```ruby
-3.miles #=> 190080
+3.miles_in_inches #=> 190080
 ```
 
-####Millennium:####
-`millennium` and `millenniums` returns the amount of seconds in n millenniums.
+####Millenniums in Seconds:####
+`millennium_in_seconds` and `millenniums_in_seconds` returns the amount of seconds in n millenniums.
 
 ```ruby
-3.millenniums #=> 94672800000.0
+3.millenniums_in_seconds #=> 94672800000.0
 ```
 
-####Milligram:####
-`milligram` and `milligrams` returns the amount of grams in n milligrams.
+####Milligrams in Grams:####
+`milligram_in_grams` and `milligrams_in_grams` returns the amount of grams in n milligrams.
 
 ```ruby
-3.milligrams #=> 0.003
+3.milligrams_in_grams #=> 0.003
 ```
 
-####Millimeters:####
-`millimeter` and `millimeters` returns the amount of meters in n millimeters.
+####Millimeters in Meters:####
+`millimeter_in_meters` and `millimeters_in_meters` returns the amount of meters in n millimeters.
 
 ```ruby
-3.millimeters #=> 0.003
+3.millimeters_in_meters #=> 0.003
 ```
 
-####Minutes:####
-`minute` and `minutes` returns the amount of seconds in n minutes.
+####Minutes in Seconds:####
+`minute_in_seconds` and `minutes_in_seconds` returns the amount of seconds in n minutes.
 
 ```ruby
-3.minutes #=> 180
+3.minutes_in_seconds #=> 180
 ```
 
 ####Multiply:####
@@ -694,11 +694,11 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 7.multiple_of?(3) #=> false
 ```
 
-####Nautical Miles:####
-`nautical_mile` and `nautical_miles` returns the amount of inches in n nautical miles.
+####Nautical Miles in Inches:####
+`nautical_mile_in_inches` and `nautical_miles_in_inches` returns the amount of inches in n nautical miles.
 
 ```ruby
-3.nautical_miles #=> 218740.26239999998
+3.nautical_miles_in_inches #=> 218740.26239999998
 ```
 
 ####Negative:####
@@ -729,11 +729,11 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 "11".ordinalize #=> "4th"
 ```
 
-####Ounces:####
-`ounce` and `ounces` returns self.
+####Ounces in Ounces:####
+`ounce_in_ounces` and `ounces_in_ounces` returns self.
 
 ```ruby
-3.ounces #=> 48
+3.ounces_in_ounces #=> 48
 ```
 
 ####Pad:####
@@ -759,11 +759,11 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.pad_precision(pad_number: 1) #=> "3.11"
 ```
 
-####Petabytes:####
-`petabyte` and `pegabytes` returns the amount of bytes in n petabytes.
+####Petabytes in Bytes:####
+`petabyte_in_bytes` and `pegabytes_in_bytes` returns the amount of bytes in n petabytes.
 
 ```ruby
-3.petabytes #=> 3377699720527872
+3.petabytes_in_bytes #=> 3377699720527872
 ```
 
 ####Positive:####
@@ -774,11 +774,11 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 -1.positive? #=> false
 ```
 
-####Pounds:####
-`pounds` and `pounds` returns the amount of ounces in n pounds.
+####Pounds in Ounces:####
+`pound_in_ounces` and `pounds_in_ounces` returns the amount of ounces in n pounds.
 
 ```ruby
-3.pounds #=> 48
+3.pounds_in_ounces #=> 48
 ```
 
 ####Power:####
@@ -795,18 +795,18 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 4.root(2) #=> 2
 ```
 
-####Seconds:####
-`second` and `seconds` returns self.
+####Seconds in Seconds:####
+`second_in_seconds` and `seconds_in_seconds` returns self.
 
 ```ruby
 3.seconds #=> 3
 ```
 
-####Stones:####
-`stone` and `stone` returns the amount of ounces in n stones.
+####Stones in Ounces:####
+`stone_in_ounces` and `stone_in_ounces` returns the amount of ounces in n stones.
 
 ```ruby
-3.stones #=> 672
+3.stones_in_ounces #=> 672
 ```
 
 ####Subtract:####
@@ -816,15 +816,15 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 4.subtract(2) #=> 2
 ```
 
-####Terabytes:####
-`terabyte` and `terabytes` returns the amount of bytes in n terabytes.
+####Terabytes in Bytes:####
+`terabyte_in_bytes` and `terabytes_in_bytes` returns the amount of bytes in n terabytes.
 
 ```ruby
-3.terabytes #=> 3298534883328
+3.terabytes_in_bytes #=> 3298534883328
 ```
 
 ####To Byte:####
-`to_byte` converts a byte size from one unit to another unit.
+`to_byte_in_bytes` converts a byte size from one unit to another unit.
 
 ```ruby
 1.to_byte(:byte, :byte)          #=> 1 #B
@@ -910,32 +910,32 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 1825.to_time(:days, :years)     #=> 4.996577686516085 #YR
 ```
 
-####Tons:####
-`ton` and `ton` returns the amount of ounces in n tons.
+####Tons in Ounces:####
+`ton_in_ounces` and `ton_in_ounces` returns the amount of ounces in n tons.
 
 ```ruby
-3.tons #=> 96000
+3.tons_in_ounces #=> 96000
 ```
 
-####Weeks:####
-`week` and `weeks` returns the amount of seconds in n weeks.
+####Weeks in Seconds:####
+`week_in_seconds` and `weeks_in_seconds` returns the amount of seconds in n weeks.
 
 ```ruby
-3.weeks #=> 1814400
+3.weeks_in_seconds #=> 1814400
 ```
 
-####Yards:####
-`yard` and `yards` returns the amount of inches in n yards.
+####Yards in Inches:####
+`yard_in_inches` and `yards_in_inches` returns the amount of inches in n yards.
 
 ```ruby
-3.yards #=> 108
+3.yards_in_inches #=> 108
 ```
 
-####Years:####
-`year` and `years` returns the amount of seconds in n years.
+####Years in Seconds:####
+`year_in_seconds` and `years_in_seconds` returns the amount of seconds in n years.
 
 ```ruby
-3.years #=> 94672800.0
+3.years_in_seconds #=> 94672800.0
 ```
 
 ### Object

data/lib/active_object/numeric.rb

@@ -40,192 +40,192 @@ class Numeric
   end
 
   unless defined?(Rails)
-    def bytes
+    def bytes_in_bytes
       self
     end
 
-    alias_method :byte, :bytes
+    alias_method :byte_in_bytes, :bytes_in_bytes
   end
 
-  def centigrams
+  def centigrams_in_grams
     self * CENTI
   end
 
-  alias_method :centigram, :centigrams
+  alias_method :centigram_in_grams, :centigrams_in_grams
 
-  def centimeters
+  def centimeters_in_meters
     self * CENTI
   end
 
-  alias_method :centimeter, :centimeters
+  alias_method :centimeter_in_meters, :centimeters_in_meters
 
-  def centuries
+  def centuries_in_seconds
     self * CENTURY
   end
 
-  alias_method :century, :centuries
+  alias_method :century_in_seconds, :centuries_in_seconds
 
-  def days
+  def days_in_seconds
     self * DAY
   end
 
-  alias_method :day, :days
+  alias_method :day_in_seconds, :days_in_seconds
 
-  def decades
+  def decades_in_seconds
     self * DECADE
   end
 
-  alias_method :decade, :decades
+  alias_method :decade_in_seconds, :decades_in_seconds
 
-  def decagrams
+  def decagrams_in_grams
     self * DECA
   end
 
-  alias_method :decagram, :decagrams
+  alias_method :decagram_in_grams, :decagrams_in_grams
 
-  def decameters
+  def decameters_in_meters
     self * DECA
   end
 
-  alias_method :decameter, :decameters
+  alias_method :decameter_in_meters, :decameters_in_meters
 
-  def decigrams
+  def decigrams_in_grams
     self * DECI
   end
 
-  alias_method :decigram, :decigrams
+  alias_method :decigram_in_grams, :decigrams_in_grams
 
-  def decimeters
+  def decimeters_in_meters
     self * DECI
   end
 
-  alias_method :decimeter, :decimeters
+  alias_method :decimeter_in_meters, :decimeters_in_meters
 
   def divide(n)
     self / n
   end
 
   unless defined?(Rails)
-    def exabytes
+    def exabytes_in_bytes
       self * EXABYTE
     end
 
-    alias_method :exabyte, :exabytes
+    alias_method :exabyte_in_bytes, :exabytes_in_bytes
   end
 
-  def feet
+  def feet_in_inches
     self * FEET
   end
 
-  alias_method :foot, :feet
+  alias_method :foot_in_inches, :feet_in_inches
 
   unless defined?(Rails)
-    def gigabytes
+    def gigabytes_in_bytes
       self * GIGABYTE
     end
 
-    alias_method :gigabyte, :gigabytes
+    alias_method :gigabyte_in_bytes, :gigabytes_in_bytes
   end
 
-  def grams
+  def grams_in_grams
     self
   end
 
-  alias_method :gram, :grams
+  alias_method :gram_in_grams, :grams_in_grams
 
-  def hectograms
+  def hectograms_in_grams
     self * HECTO
   end
 
-  alias_method :hectogram, :hectograms
+  alias_method :hectogram_in_grams, :hectograms_in_grams
 
-  def hectometers
+  def hectometers_in_meters
     self * HECTO
   end
 
-  alias_method :hectometer, :hectometers
+  alias_method :hectometer_in_meters, :hectometers_in_meters
 
-  def hours
+  def hours_in_seconds
     self * HOUR
   end
 
-  alias_method :hour, :hours
+  alias_method :hour_in_seconds, :hours_in_seconds
 
-  def inches
+  def inches_in_inches
     self
   end
 
-  alias_method :inch, :inches
+  alias_method :inch_in_inches, :inches_in_inches
 
   unless defined?(Rails)
-    def kilobytes
+    def kilobytes_in_bytes
       self * KILOBYTE
     end
 
-    alias_method :kilobyte, :kilobytes
+    alias_method :kilobyte_in_bytes, :kilobytes_in_bytes
   end
 
-  def kilometers
+  def kilometers_in_meters
     self * KILO
   end
 
-  alias_method :kilometer, :kilometers
+  alias_method :kilometer_in_meters, :kilometers_in_meters
 
-  def kilograms
+  def kilograms_in_grams
     self * KILO
   end
 
-  alias_method :kilogram, :kilograms
+  alias_method :kilogram_in_grams, :kilograms_in_grams
 
-  def metric_tons
+  def metric_tons_in_grams
     self * METRIC_TON
   end
 
-  alias_method :metric_ton, :metric_tons
+  alias_method :metric_ton_in_grams, :metric_tons_in_grams
 
   unless defined?(Rails)
-    def megabytes
+    def megabytes_in_bytes
       self * MEGABYTE
     end
 
-    alias_method :megabyte, :megabytes
+    alias_method :megabyte_in_bytes, :megabytes_in_bytes
   end
 
-  def meters
+  def meters_in_meters
     self
   end
 
-  alias_method :meter, :meters
+  alias_method :meter_in_meters, :meters_in_meters
 
-  def miles
+  def miles_in_inches
     self * MILE
   end
 
-  alias_method :mile, :miles
+  alias_method :mile_in_inches, :miles_in_inches
 
-  def millenniums
+  def millenniums_in_seconds
     self * MILLENNIUM
   end
 
-  alias_method :millennium, :millenniums
+  alias_method :millennium_in_seconds, :millenniums_in_seconds
 
-  def milligrams
+  def milligrams_in_grams
     self * MILLI
   end
 
-  alias_method :milligram, :milligrams
+  alias_method :milligram_in_grams, :milligrams_in_grams
 
-  def millimeters
+  def millimeters_in_meters
     self * MILLI
   end
 
-  alias_method :millimeter, :millimeters
+  alias_method :millimeter_in_meters, :millimeters_in_meters
 
-  def minutes
+  def minutes_in_seconds
     self * MINUTE
   end
 
-  alias_method :minute, :minutes
+  alias_method :minute_in_seconds, :minutes_in_seconds
 
   def multiply(n)
     self * n
@@ -237,11 +237,11 @@ class Numeric
     end
   end
 
-  def nautical_miles
+  def nautical_miles_in_inches
     self * NAUTICAL_MILE
   end
 
-  alias_method :nautical_mile, :nautical_miles
+  alias_method :nautical_mile_in_inches, :nautical_miles_in_inches
 
   def negative?
     self < 0
@@ -270,11 +270,11 @@ class Numeric
     end
   end
 
-  def ounces
+  def ounces_in_ounces
     self
   end
 
-  alias_method :ounce, :ounces
+  alias_method :ounce_in_ounces, :ounces_in_ounces
 
   def pad(options={})
     pad_number = options.fetch(:pad_number, 0)
@@ -297,22 +297,22 @@ class Numeric
   end
 
   unless defined?(Rails)
-    def petabytes
+    def petabytes_in_bytes
       self * PETABYTE
     end
 
-    alias_method :petabyte, :petabytes
+    alias_method :petabyte_in_bytes, :petabytes_in_bytes
   end
 
   def positive?
     self > 0
   end
 
-  def pounds
+  def pounds_in_ounces
     self * POUND
   end
 
-  alias_method :pound, :pounds
+  alias_method :pound_in_ounces, :pounds_in_ounces
 
   def power(n)
     self ** n
@@ -322,28 +322,28 @@ class Numeric
     self ** (1.0 / n)
   end
 
-  def seconds
+  def seconds_in_seconds
     self
   end
 
-  alias_method :second, :seconds
+  alias_method :second_in_seconds, :seconds_in_seconds
 
-  def stones
+  def stones_in_ounces
     self * STONE
   end
 
-  alias_method :stone, :stones
+  alias_method :stone_in_ounces, :stones_in_ounces
 
   def subtract(n)
     self - n
   end
 
   unless defined?(Rails)
-    def terabytes
+    def terabytes_in_bytes
       self * TERABYTE
     end
 
-    alias_method :terabyte, :terabytes
+    alias_method :terabyte_in_bytes, :terabytes_in_bytes
   end
 
   def to_byte(from, to)
@@ -362,7 +362,7 @@ class Numeric
         "Unknown key(s): form: #{from.inspect} and to: #{to.inspect}, Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
 
-    to_f * 1.send(from) / 1.send(to)
+    to_f * 1.send("#{from}_in_bytes") / 1.send("#{to}_in_bytes")
   end
 
   def to_currency(options={})
@@ -397,15 +397,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) / 1.send(to)
+        to_f * 1.send("#{from}_in_meters") / 1.send("#{to}_in_meters")
       else
-        to_f * ((1.send(from) * 0.0254) / 1.send(to))
+        to_f * ((1.send("#{from}_in_inches") * 0.0254) / 1.send("#{to}_in_meters"))
       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) * 39.3701) / 1.send(to))
+        to_f * ((1.send("#{from}_in_meters") * 39.3701) / 1.send("#{to}_in_inches"))
       else
-        to_f * 1.send(from) / 1.send(to)
+        to_f * 1.send("#{from}_in_inches") / 1.send("#{to}_in_inches")
       end
     end
   end
@@ -436,15 +436,15 @@ 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) / 1.send(to)
+        to_f * 1.send("#{from}_in_grams") / 1.send("#{to}_in_grams")
       else
-        to_f * ((1.send(from) * 28.3495) / 1.send(to))
+        to_f * ((1.send("#{from}_in_ounces") * 28.3495) / 1.send("#{to}_in_grams"))
       end
     when :ounce, :ounces, :pound, :pounds, :stone, :stones, :ton, :tons
       if valid_keys.first(16).include?(from)
-        to_f * ((1.send(from) * 0.035274) / 1.send(to))
+        to_f * ((1.send("#{from}_in_grams") * 0.035274) / 1.send("#{to}_in_ounces"))
       else
-        to_f * 1.send(from) / 1.send(to)
+        to_f * 1.send("#{from}_in_ounces") / 1.send("#{to}_in_ounces")
       end
     end
   end
@@ -507,31 +507,31 @@ class Numeric
         "Unknown key(s): form: #{from.inspect} and to: #{to.inspect}, Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
 
-    to_f * 1.send(from) / 1.send(to)
+    to_f * 1.send("#{from}_in_seconds") / 1.send("#{to}_in_seconds")
   end
 
-  def tons
+  def tons_in_ounces
     self * TON
   end
 
-  alias_method :ton, :tons
+  alias_method :ton_in_ounces, :tons_in_ounces
 
-  def weeks
+  def weeks_in_seconds
     self * WEEK
   end
 
-  alias_method :week, :weeks
+  alias_method :week_in_seconds, :weeks_in_seconds
 
-  def yards
+  def yards_in_inches
     self * YARD
   end
 
-  alias_method :yard, :yards
+  alias_method :yard_in_inches, :yards_in_inches
 
-  def years
+  def years_in_seconds
     self * YEAR
   end
 
-  alias_method :year, :years
+  alias_method :year_in_seconds, :years_in_seconds
 
 end

data/lib/active_object/version.rb

@@ -1,3 +1,3 @@
 module ActiveObject
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/spec/lib/numeric_spec.rb

@@ -8,73 +8,73 @@ describe Numeric do
     end
   end
 
-  describe "#byte(s)" do
+  describe "#byte_in_bytes" do
     it "to be 3" do
-      expect(3.byte).to eq(3)
-      expect(3.bytes).to eq(3)
+      expect(3.byte_in_bytes).to eq(3)
+      expect(3.bytes_in_bytes).to eq(3)
     end
   end
 
-  describe "#centigram(s)" do
+  describe "#centigram_in_grams" do
     it "to be 0.03" do
-      expect(3.centigram).to eq(0.03)
-      expect(3.centigram).to eq(0.03)
+      expect(3.centigram_in_grams).to eq(0.03)
+      expect(3.centigrams_in_grams).to eq(0.03)
     end
   end
 
-  describe "#centimeter(s)" do
+  describe "#centimeter_in_meters" do
     it "to be 0.03" do
-      expect(3.centimeter).to eq(0.03)
-      expect(3.centimeters).to eq(0.03)
+      expect(3.centimeter_in_meters).to eq(0.03)
+      expect(3.centimeters_in_meters).to eq(0.03)
     end
   end
 
-  describe "#century(s)" do
+  describe "#century_in_second" do
     it "to be 259200" do
-      expect(3.century).to eq(9467280000.0)
-      expect(3.centuries).to eq(9467280000.0)
+      expect(3.century_in_seconds).to eq(9467280000.0)
+      expect(3.centuries_in_seconds).to eq(9467280000.0)
     end
   end
 
-  describe "#decade(s)" do
+  describe "#decade_in_second" do
     it "to be 259200" do
-      expect(3.decade).to eq(946728000.0)
-      expect(3.decades).to eq(946728000.0)
+      expect(3.decade_in_seconds).to eq(946728000.0)
+      expect(3.decades_in_seconds).to eq(946728000.0)
     end
   end
 
-  describe "#decagram(s)" do
+  describe "#decagram_in_grams" do
     it "to be 30" do
-      expect(3.decagram).to eq(30)
-      expect(3.decagrams).to eq(30)
+      expect(3.decagram_in_grams).to eq(30)
+      expect(3.decagrams_in_grams).to eq(30)
     end
   end
 
-  describe "#decameter(s)" do
+  describe "#decameter_in_meters" do
     it "to be 30" do
-      expect(3.decameter).to eq(30)
-      expect(3.decameters).to eq(30)
+      expect(3.decameter_in_meters).to eq(30)
+      expect(3.decameters_in_meters).to eq(30)
     end
   end
 
-  describe "#decigrams(s)" do
+  describe "#decigrams_in_grams" do
     it "to be 0.3" do
-      expect(3.decigram).to eq(0.30000000000000004)
-      expect(3.decigrams).to eq(0.30000000000000004)
+      expect(3.decigram_in_grams).to eq(0.30000000000000004)
+      expect(3.decigrams_in_grams).to eq(0.30000000000000004)
     end
   end
 
-  describe "#decimeter(s)" do
+  describe "#decimeter_in_meters" do
     it "to be 0.3" do
-      expect(3.decimeter).to eq(0.30000000000000004)
-      expect(3.decimeters).to eq(0.30000000000000004)
+      expect(3.decimeter_in_meters).to eq(0.30000000000000004)
+      expect(3.decimeters_in_meters).to eq(0.30000000000000004)
     end
   end
 
-  describe "#day(s)" do
+  describe "#day_in_second" do
     it "to be 259200" do
-      expect(3.day).to eq(259200)
-      expect(3.days).to eq(259200)
+      expect(3.day_in_seconds).to eq(259200)
+      expect(3.days_in_seconds).to eq(259200)
     end
   end
 
@@ -84,136 +84,136 @@ describe Numeric do
     end
   end
 
-  describe "#exabyte(s)" do
+  describe "#exabyte_in_bytes" do
     it "to be 3458764513820540928" do
-      expect(3.exabyte).to eq(3458764513820540928)
-      expect(3.exabytes).to eq(3458764513820540928)
+      expect(3.exabyte_in_bytes).to eq(3458764513820540928)
+      expect(3.exabytes_in_bytes).to eq(3458764513820540928)
     end
   end
 
-  describe "#feet(s)" do
+  describe "#feet_in_inches" do
     it "to be 36" do
-      expect(3.foot).to eq(36)
-      expect(3.feet).to eq(36)
+      expect(3.foot_in_inches).to eq(36)
+      expect(3.feet_in_inches).to eq(36)
     end
   end
 
-  describe "#gigabyte(s)" do
+  describe "#gigabyte_in_bytes" do
     it "to be 3221225472" do
-      expect(3.gigabyte).to eq(3221225472)
-      expect(3.gigabytes).to eq(3221225472)
+      expect(3.gigabyte_in_bytes).to eq(3221225472)
+      expect(3.gigabytes_in_bytes).to eq(3221225472)
     end
   end
 
-  describe "#gram(s)" do
+  describe "#gram_in_grams" do
     it "to be 300" do
-      expect(3.gram).to eq(3)
-      expect(3.grams).to eq(3)
+      expect(3.gram_in_grams).to eq(3)
+      expect(3.grams_in_grams).to eq(3)
     end
   end
 
-  describe "#hectogram(s)" do
+  describe "#hectogram_in_grams" do
     it "to be 300" do
-      expect(3.hectogram).to eq(300)
-      expect(3.hectograms).to eq(300)
+      expect(3.hectogram_in_grams).to eq(300)
+      expect(3.hectograms_in_grams).to eq(300)
     end
   end
 
-  describe "#hectometer(s)" do
+  describe "#hectometer_in_meters" do
     it "to be 300" do
-      expect(3.hectometer).to eq(300)
-      expect(3.hectometers).to eq(300)
+      expect(3.hectometer_in_meters).to eq(300)
+      expect(3.hectometers_in_meters).to eq(300)
     end
   end
 
-  describe "#hour(s)" do
+  describe "#hour_in_second" do
     it "to be 10800" do
-      expect(3.hour).to eq(10800)
-      expect(3.hours).to eq(10800)
+      expect(3.hour_in_seconds).to eq(10800)
+      expect(3.hours_in_seconds).to eq(10800)
     end
   end
 
-  describe "#inch(s)" do
+  describe "#inch_in_inches" do
     it "to be 3" do
-      expect(3.inch).to eq(3)
-      expect(3.inches).to eq(3)
+      expect(3.inch_in_inches).to eq(3)
+      expect(3.inches_in_inches).to eq(3)
     end
   end
 
-  describe "#kilobyte(s)" do
+  describe "#kilobytes_in_bytes" do
     it "to be 3072" do
-      expect(3.kilobyte).to eq(3072)
-      expect(3.kilobytes).to eq(3072)
+      expect(3.kilobyte_in_bytes).to eq(3072)
+      expect(3.kilobytes_in_bytes).to eq(3072)
     end
   end
 
-  describe "#kilograms(s)" do
+  describe "#kilograms_in_grams" do
     it "to be 3000" do
-      expect(3.kilogram).to eq(3000)
-      expect(3.kilograms).to eq(3000)
+      expect(3.kilogram_in_grams).to eq(3000)
+      expect(3.kilograms_in_grams).to eq(3000)
     end
   end
 
-  describe "#kilometer(s)" do
+  describe "#kilometer_in_meters" do
     it "to be 3000" do
-      expect(3.kilometer).to eq(3000)
-      expect(3.kilometers).to eq(3000)
+      expect(3.kilometer_in_meters).to eq(3000)
+      expect(3.kilometers_in_meters).to eq(3000)
     end
   end
 
-  describe "#metric_ton(s)" do
+  describe "#metric_ton_in_grams" do
     it "to be 3000000" do
-      expect(3.metric_ton).to eq(3000000)
-      expect(3.metric_tons).to eq(3000000)
+      expect(3.metric_ton_in_grams).to eq(3000000)
+      expect(3.metric_tons_in_grams).to eq(3000000)
     end
   end
 
-  describe "#megabyte(s)" do
+  describe "#megabyte_in_bytes" do
     it "to be 3145728" do
-      expect(3.megabyte).to eq(3145728)
-      expect(3.megabytes).to eq(3145728)
+      expect(3.megabyte_in_bytes).to eq(3145728)
+      expect(3.megabytes_in_bytes).to eq(3145728)
     end
   end
 
-  describe "#meter(s)" do
+  describe "#meter_in_meters" do
     it "to be 3" do
-      expect(3.meter).to eq(3)
-      expect(3.meters).to eq(3)
+      expect(3.meter_in_meters).to eq(3)
+      expect(3.meters_in_meters).to eq(3)
     end
   end
 
-  describe "#mile(s)" do
+  describe "#mile_in_inches" do
     it "to be 36" do
-      expect(3.mile).to eq(190080)
-      expect(3.miles).to eq(190080)
+      expect(3.mile_in_inches).to eq(190080)
+      expect(3.miles_in_inches).to eq(190080)
     end
   end
 
-  describe "#millennium(s)" do
+  describe "#millennium_in_second" do
     it "to be 94672800000.0" do
-      expect(3.millennium).to eq(94672800000.0)
-      expect(3.millenniums).to eq(94672800000.0)
+      expect(3.millennium_in_seconds).to eq(94672800000.0)
+      expect(3.millenniums_in_seconds).to eq(94672800000.0)
     end
   end
 
-  describe "#milligrams(s)" do
+  describe "#milligrams_in_grams" do
     it "to be 0.003" do
-      expect(3.milligram).to eq(0.003)
-      expect(3.milligrams).to eq(0.003)
+      expect(3.milligram_in_grams).to eq(0.003)
+      expect(3.milligrams_in_grams).to eq(0.003)
     end
   end
 
-  describe "#millimeter(s)" do
+  describe "#millimeter_in_meters" do
     it "to be 0.003" do
-      expect(3.millimeter).to eq(0.003)
-      expect(3.millimeters).to eq(0.003)
+      expect(3.millimeter_in_meters).to eq(0.003)
+      expect(3.millimeters_in_meters).to eq(0.003)
     end
   end
 
-  describe "#minute(s)" do
+  describe "#minute_in_second" do
     it "to be 180" do
-      expect(3.minute).to eq(180)
-      expect(3.minutes).to eq(180)
+      expect(3.minute_in_seconds).to eq(180)
+      expect(3.minutes_in_seconds).to eq(180)
     end
   end
 
@@ -234,10 +234,10 @@ describe Numeric do
     end
   end
 
-  describe "#nautical_mile(s)" do
+  describe "#nautical_mile_in_inches" do
     it "to be 218740.26239999998" do
-      expect(3.nautical_mile).to eq(218740.26239999998)
-      expect(3.nautical_miles).to eq(218740.26239999998)
+      expect(3.nautical_mile_in_inches).to eq(218740.26239999998)
+      expect(3.nautical_miles_in_inches).to eq(218740.26239999998)
     end
   end
 
@@ -287,10 +287,10 @@ describe Numeric do
     end
   end
 
-  describe "#ounce(s)" do
+  describe "#ounce_in_ounces" do
     it "to be 3" do
-      expect(3.ounce).to eq(3)
-      expect(3.ounces).to eq(3)
+      expect(3.ounce_in_ounces).to eq(3)
+      expect(3.ounces_in_ounces).to eq(3)
     end
   end
 
@@ -334,10 +334,10 @@ describe Numeric do
     end
   end
 
-  describe "#petabyte(s)" do
+  describe "#petabyte_in_bytes" do
     it "to be 3377699720527872" do
-      expect(3.petabyte).to eq(3377699720527872)
-      expect(3.petabytes).to eq(3377699720527872)
+      expect(3.petabyte_in_bytes).to eq(3377699720527872)
+      expect(3.petabytes_in_bytes).to eq(3377699720527872)
     end
   end
 
@@ -351,10 +351,10 @@ describe Numeric do
     end
   end
 
-  describe "#pound(s)" do
+  describe "#pound_in_ounces" do
     it "to be 48" do
-      expect(3.pound).to eq(48)
-      expect(3.pounds).to eq(48)
+      expect(3.pound_in_ounces).to eq(48)
+      expect(3.pounds_in_ounces).to eq(48)
     end
   end
 
@@ -370,17 +370,17 @@ describe Numeric do
     end
   end
 
-  describe "#second(s)" do
+  describe "#second_in_seconds" do
     it "to be 3" do
-      expect(3.second).to eq(3)
-      expect(3.seconds).to eq(3)
+      expect(3.second_in_seconds).to eq(3)
+      expect(3.seconds_in_seconds).to eq(3)
     end
   end
 
-  describe "#stone(s)" do
+  describe "#stone_in_ounces" do
     it "to be 672" do
-      expect(3.stone).to eq(672)
-      expect(3.stones).to eq(672)
+      expect(3.stone_in_ounces).to eq(672)
+      expect(3.stones_in_ounces).to eq(672)
     end
   end
 
@@ -390,10 +390,10 @@ describe Numeric do
     end
   end
 
-  describe "#terabyte(s)" do
+  describe "#terabyte_in_bytes" do
     it "to be 3298534883328" do
-      expect(3.terabyte).to eq(3298534883328)
-      expect(3.terabytes).to eq(3298534883328)
+      expect(3.terabyte_in_bytes).to eq(3298534883328)
+      expect(3.terabytes_in_bytes).to eq(3298534883328)
     end
   end
 
@@ -625,31 +625,31 @@ describe Numeric do
     end
   end
 
-  describe "#ton(s)" do
+  describe "#ton_in_ounces" do
     it "to be 96000" do
-      expect(3.ton).to eq(96000)
-      expect(3.tons).to eq(96000)
+      expect(3.ton_in_ounces).to eq(96000)
+      expect(3.tons_in_ounces).to eq(96000)
     end
   end
 
-  describe "#week(s)" do
+  describe "#week_in_seconds" do
     it "to be 1814400" do
-      expect(3.week).to eq(1814400)
-      expect(3.weeks).to eq(1814400)
+      expect(3.week_in_seconds).to eq(1814400)
+      expect(3.weeks_in_seconds).to eq(1814400)
     end
   end
 
-  describe "#yard(s)" do
+  describe "#yard_in_inches" do
     it "to be 36" do
-      expect(3.yard).to eq(108)
-      expect(3.yards).to eq(108)
+      expect(3.yard_in_inches).to eq(108)
+      expect(3.yards_in_inches).to eq(108)
     end
   end
 
-  describe "#year(s)" do
+  describe "#year_in_seconds" do
     it "to be 94672800.0" do
-      expect(3.year).to eq(94672800.0)
-      expect(3.years).to eq(94672800.0)
+      expect(3.year_in_seconds).to eq(94672800.0)
+      expect(3.years_in_seconds).to eq(94672800.0)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_object
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler