tempura 0.0.1 → 0.1.0

data/README.md

@@ -1,25 +1,31 @@
 # Tempura
 
-Tempura is a library for temperature math and conversion.
+Tempura is a library for temperature arithmetic, comparison, and conversion. Currently supported scales are Fahrenheit, Celsius, Kelvin, Delisle, Newton, Rankine, Réaumer, and Rømer.
 
-## Installation
+Temperature objects may be instantiated directly, e.g. `Tempura::Celsius.new(100)`, or by using the methods defined on `Numeric`, e.g., `212.degrees_fahrenheit`
 
-Add this line to your application's Gemfile:
+## Usage
 
-    gem 'tempura'
+### Instantiation
 
-And then execute:
+Direct instantiation:
 
-    $ bundle
+		Tempura::Fahrenheit.new(212)
 
-Or install it yourself as:
+Via Numeric:
 
-    $ gem install tempura
+		100.degrees_celsius
 
-## Usage
+### Conversion
+
+`Tempura::Temperature` (each scales parent object) implements `#to`, which returns a `Tempura::Conversion`, which then may receive the name of a scale to convert to:
+
+		212.degrees_fahrenheit.to.celsius #=> <Tempura::Celsius...
 
 ### Arithmetic
 
+Subtract other temperatures of any scale, or native degrees:
+
     it 'subtracts another temperature' do
       fahrenheit = Tempura::Fahrenheit.new(212)
       celsius = Tempura::Celsius.new(0)
@@ -35,6 +41,8 @@ Or install it yourself as:
       expect(result).to be_a(Tempura::Fahrenheit)
     end
 
+Add temperatures of any scale, or native degrees:
+
     it 'adds another temperature' do
       fahrenheit = Tempura::Fahrenheit.new(212)
       celsius = Tempura::Celsius.new(0)
@@ -50,6 +58,8 @@ Or install it yourself as:
       expect(result).to be_a(Tempura::Fahrenheit)
     end
 
+Divide a temperature by a numeric:
+
     it 'divides by a Numeric' do
       fahrenheit = Tempura::Fahrenheit.new(212)
       result = fahrenheit / 2
@@ -57,13 +67,6 @@ Or install it yourself as:
       expect(result).to be_a(Tempura::Fahrenheit)
     end
 
-    it 'multiplies by a Numeric' do
-      fahrenheit = Tempura::Fahrenheit.new(212)
-      result = fahrenheit * 2
-      expect(result).to eq(424)
-      expect(result).to be_a(Tempura::Fahrenheit)
-    end
-
     it 'can average an array of temperatures' do
       f = Tempura::Fahrenheit.new(212)
       c = Tempura::Celsius.new(100)
@@ -74,68 +77,61 @@ Or install it yourself as:
       expect(result).to be_a(Tempura::Delisle)
     end
 
+Multiply a temperature by a numeric:
+
+    it 'multiplies by a Numeric' do
+      fahrenheit = Tempura::Fahrenheit.new(212)
+      result = fahrenheit * 2
+      expect(result).to eq(424)
+      expect(result).to be_a(Tempura::Fahrenheit)
+    end
+
 ### Comparison
 
-		it 'has >' do
-			fahrenheit = Tempura::Fahrenheit.new(212)
-			celsius = Tempura::Celsius.new(99)
-			expect(fahrenheit > celsius).to be_true
-		end
-
-		it 'has <' do
-			fahrenheit = Tempura::Fahrenheit.new(212)
-			celsius = Tempura::Celsius.new(101)
-			expect(fahrenheit < celsius).to be_true
-		end
-
-		it 'has <=' do
-			fahrenheit = Tempura::Fahrenheit.new(212)
-			celsius = Tempura::Celsius.new(101)
-			expect(fahrenheit <= celsius).to be_true
-		end
-
-		it 'has >=' do
-			fahrenheit = Tempura::Fahrenheit.new(212)
-			celsius = Tempura::Celsius.new(99)
-			expect(fahrenheit >= celsius).to be_true
-		end
-
-		it 'has ==' do
-			c = Tempura::Celsius.new(100)
-			d = Tempura::Delisle.new(0)
-			f = Tempura::Fahrenheit.new(212)
-			n = Tempura::Newton.new(33)
-			ra = Tempura::Rankine.new(671.67)
-			ré = Tempura::Réaumur.new(80)
-			rø = Tempura::Rømer.new(60)
-
-			scales = [c, d, f, n, ra, ré, rø]
-			scales.each { |s1|
-				scales.each { |s2|
-					expect(s1 == s2).to be_true
-				}
+`>`, `<`, `<=`, `>=`, `<=>`, and `==` are supported. Temperatures of the same or different scales may be compared, or a temperature may be compared with native degrees.
+
+    Tempura::Fahrenheit.new(212) > Tempura::Celsius.new(99)
+    Tempura::Fahrenheit.new(212) < Tempura::Celsius.new(101)
+    Tempura::Fahrenheit.new(212) >= Tempura::Celsius.new(99)
+    Tempura::Fahrenheit.new(212) <= Tempura::Celsius.new(101)
+
+    scales = [
+		  Tempura::Celsius.new(100),
+		  Tempura::Delisle.new(0),
+		  Tempura::Fahrenheit.new(212),
+		  Tempura::Newton.new(33),
+		  Tempura::Rankine.new(671.67),
+		  Tempura::Réaumur.new(80),
+		  Tempura::Rømer.new(60),
+		]
+
+		scales.all? { |s1|
+			scales.each { |s2|
+		    s1 == s2
 			}
-		end
+		}
+
+    #=> true
 
 ### Casting
 
-    it 'casts to_f' do
-      temp = Tempura::Fahrenheit.new(212)
-      expect(temp.to_f).to eq(212.0)
-      expect(temp.to_f).to be_a(Float)
-    end
+    Tempura::Fahrenheit.new(212).to_f
+    Tempura::Kelvin.new(373.15).to_i
+    Tempura::Celsius.new(100).to_d
 
-    it 'casts to_i' do
-      temp = Tempura::Kelvin.new(373.15)
-      expect(temp.to_i).to eq(373)
-      expect(temp.to_i).to be_a(Integer)
-    end
+## Installation
 
-    it 'casts to_d' do
-      temp = Tempura::Celsius.new(100)
-      expect(temp.to_d).to eq(100.0)
-      expect(temp.to_d).to be_a(BigDecimal)
-    end
+Add this line to your application's Gemfile:
+
+    gem 'tempura'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tempura
 
 ## Contributing
 

data/lib/tempura.rb

@@ -11,6 +11,8 @@ require 'tempura/newton'
 require 'tempura/rankine'
 require 'tempura/réaumur'
 require 'tempura/rømer'
+require 'tempura/core_ext/numeric'
+require 'tempura/conversion'
 
 module Tempura
 end

data/lib/tempura/celsius.rb

@@ -1 +1,11 @@
-class Tempura::Celsius < Tempura::Temperature; end
+class Tempura::Celsius < Tempura::Temperature
+
+  def from_native(given)
+    given + BigDecimal("273.15")
+  end
+
+  def self.as_native(k)
+    k - BigDecimal("273.15")
+  end
+
+end

data/lib/tempura/conversion.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class Tempura::Conversion
+  
+  def initialize(klass)
+    @klass = klass
+  end
+
+  def celsius
+    Tempura::Celsius.new(klass)
+  end
+
+  def delisle
+    Tempura::Delisle.new(klass)
+  end
+
+  def fahrenheit
+    Tempura::Fahrenheit.new(klass)
+  end
+
+  def kelvin
+    Tempura::Kelvin.new(klass)
+  end
+
+  def newton
+    Tempura::Newton.new(klass)
+  end
+
+  def rankine
+    Tempura::Rankine.new(klass)
+  end
+
+  def réaumur
+    Tempura::Réaumur.new(klass)
+  end
+  alias :reaumur :réaumur
+
+  def rømer
+    Tempura::Rømer.new(klass)
+  end
+  alias :romer :rømer
+
+  private
+
+  attr_reader :klass
+
+end

data/lib/tempura/core_ext/numeric.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+class Numeric
+
+  def degrees_celsius
+    Tempura::Celsius.new(self)
+  end
+
+  def degrees_delisle
+    Tempura::Delisle.new(self)
+  end
+
+  def degrees_fahrenheit
+    Tempura::Fahrenheit.new(self)
+  end
+
+  def degrees_kelvin
+    Tempura::Kelvin.new(self)
+  end
+
+  def degrees_newton
+    Tempura::Newton.new(self)
+  end
+
+  def degrees_rankine
+    Tempura::Rankine.new(self)
+  end
+
+  def degrees_réaumur
+    Tempura::Réaumur.new(self)
+  end
+  alias :degrees_reaumur :degrees_réaumur
+
+  def degrees_rømer
+    Tempura::Rømer.new(self)
+  end
+  alias :degrees_romer :degrees_rømer
+  
+end

data/lib/tempura/delisle.rb

@@ -1 +1,11 @@
-class Tempura::Delisle < Tempura::Temperature; end
+class Tempura::Delisle < Tempura::Temperature
+
+  def from_native(given)
+    BigDecimal("373.15") - ((given * 2) / 3)
+  end
+
+  def self.as_native(k)
+    ((BigDecimal("373.15") - k) * 3) / 2
+  end
+
+end

data/lib/tempura/fahrenheit.rb

@@ -1 +1,11 @@
-class Tempura::Fahrenheit < Tempura::Temperature; end
+class Tempura::Fahrenheit < Tempura::Temperature
+
+  def from_native(given)
+    ((given + BigDecimal("459.67")) * 5) / 9
+  end
+
+  def self.as_native(k)
+    ((k * 9)/5) - BigDecimal("459.67")
+  end
+
+end

data/lib/tempura/kelvin.rb

@@ -1 +1,11 @@
-class Tempura::Kelvin < Tempura::Temperature; end
+class Tempura::Kelvin < Tempura::Temperature
+
+  def from_native(given)
+    given
+  end
+
+  def self.as_native(k)
+    k
+  end
+
+end

data/lib/tempura/newton.rb

@@ -1 +1,11 @@
-class Tempura::Newton < Tempura::Temperature; end
+class Tempura::Newton < Tempura::Temperature
+
+  def from_native(given)
+    ((given * 100) / 33) + BigDecimal("273.15")
+  end
+
+  def self.as_native
+    ((k - BigDecimal("273.15")) * 33) / 100
+  end
+
+end

data/lib/tempura/rankine.rb

@@ -1 +1,11 @@
-class Tempura::Rankine < Tempura::Temperature; end
+class Tempura::Rankine < Tempura::Temperature
+
+  def from_native(given)
+    (given * 5) / 9
+  end
+
+  def self.as_native(k)
+    (k * 9) / 5
+  end
+
+end

data/lib/tempura/r/303/251aumur.rb

@@ -1,2 +1,12 @@
 # encoding: utf-8
-class Tempura::Réaumur < Tempura::Temperature; end
+class Tempura::Réaumur < Tempura::Temperature
+
+  def from_native(given)
+    ((given * 5) / 4) + BigDecimal("273.15")
+  end
+
+  def self.as_native(k)
+    ((k - BigDecimal("273.15")) * 4) / 5
+  end
+
+end

data/lib/tempura/r/303/270mer.rb

@@ -1,2 +1,12 @@
 # encoding: utf-8
-class Tempura::Rømer < Tempura::Temperature; end
+class Tempura::Rømer < Tempura::Temperature
+
+  def from_native(given)
+    (((given - BigDecimal("7.5")) * 40) / 21) + BigDecimal("273.15")
+  end
+
+  def self.as_native(k)
+    (((k - BigDecimal("273.15")) * 21) / 40) + BigDecimal("7.5")
+  end
+
+end

data/lib/tempura/temperature.rb

@@ -1,14 +1,20 @@
 # encoding: utf-8
 
-require 'bigdecimal'
-
+# Parent class of all +Temperature+ objects in +Tempura+, inherited by +Tempura::Celsius+, etc.
 class Tempura::Temperature
   include Comparable
 
-  def initialize(value)
-    @common = to_common(value)
+  def initialize(temp)
+    if temp.is_a?(Tempura::Temperature)
+      @common = temp.send(:common)
+    else
+      @common = to_common(temp)
+    end
   end
 
+  # Compares against a +Temperature+ of any scale, or a numeric representation of the same scale as the receiver.
+  #
+  # @param temp [Tempura::Temperature, Numeric]
   def <=>(temp)
     if temp.is_a?(Tempura::Temperature)
       @common <=> temp.send(:common)
@@ -17,20 +23,23 @@ class Tempura::Temperature
     end
   end
 
+  # Subtracts a +Temperature+ of any scale, or a numeric representation of the same scale as the receiver.
+  #
+  # @param temp [Tempura::Temperature, Numeric]
   def -(temp)
-    if temp.is_a?(Tempura::Temperature)
-      temp = to_native(temp)
-    end
-    self.class.new(in_native - temp)
+    self.class.new(in_native - numericalize(temp))
   end
 
+  # Adds a +Temperature+ of any scale, or a numeric representation of the same scale as the receiver.
+  #
+  # @param temp [Tempura::Temperature, Numeric]
   def +(temp)
-    if temp.is_a?(Tempura::Temperature)
-      temp = to_native(temp)
-    end
-    self.class.new(in_native + temp)
+    self.class.new(in_native + numericalize(temp))
   end
 
+  # Divides by +Numeric+.
+  #
+  # @param temp [Numeric]
   def /(temp)
     if temp.is_a?(Tempura::Temperature)
       raise ArgumentError, "cannot divide by a Tempura::Temperature, only a Numeric"
@@ -38,6 +47,9 @@ class Tempura::Temperature
     self.class.new(in_native.div(temp))
   end
 
+  # Multiplies by +Numeric+.
+  #
+  # @param temp [Numeric]
   def *(temp)
     if temp.is_a?(Tempura::Temperature)
       raise ArgumentError, "cannot multiply by a Tempura::Temperature, only a Numeric"
@@ -45,131 +57,51 @@ class Tempura::Temperature
     self.class.new(in_native * temp)
   end
 
+  # Returns {Tempura::Conversion} for the receiver, which recieves the name of the scale to convert to. E.g.,
+  #
+  #     c = Tempura::Celsius.new(100)
+  #     c.to.fahrenheit #=> <Tempura::Fahrenheit ...
+  # 
+  def to
+    Tempura::Conversion.new(self)
+  end
+
+  # Float representation of receiver
   def to_f
     in_native.to_f
   end
 
+  # Integer representation of receiver
   def to_i
     in_native.to_i
   end
 
+  # BigDecimal representation of receiver
   def to_d
     in_native
   end
 
-  def to_native(temp)
-    temp.send("in_#{self.class.name.split('::').last.downcase}")
-  end
-
-  def from_celsius(given)
-    given + BigDecimal("273.15")
-  end
-
-  def in_celsius
-    common - BigDecimal("273.15")
-  end
-
-  def to_celsius
-    Tempura::Celsius.new(in_celsius)
-  end
-
-  def from_delisle(given)
-    BigDecimal("373.15") - ((given * 2) / 3)
-  end
-
-  def in_delisle
-    ((BigDecimal("373.15") - common) * 3) / 2
-  end
-
-  def to_delisle
-    Tempura::Delisle.new(in_delisle)
-  end
-
-  def from_fahrenheit(given)
-    ((given + BigDecimal("459.67")) * 5) / 9
-  end
-
-  def in_fahrenheit
-    ((common * 9)/5) - BigDecimal("459.67")
-  end
-
-  def to_fahrenheit
-    Tempura::Fahrenheit.new(in_fahrenheit)
-  end
-
-  def from_kelvin(given)
-    given
-  end
-
-  def in_kelvin
-    common
-  end
-  
-  def to_kelvin
-    Tempura::Kelvin.new(in_kelvin)
-  end
-
-  def from_newton(given)
-    ((given * 100) / 33) + BigDecimal("273.15")
-  end
-
-  def in_newton
-    ((common - BigDecimal("273.15")) * 33) / 100
-  end
-
-  def to_newton
-    Tempura::Newton.new(in_newton)
-  end
-
-  def from_rankine(given)
-    (given * 5) / 9
-  end
-
-  def in_rankine
-    (common * 9) / 5
-  end
-
-  def to_rankine
-    Tempura::Rankine.new(in_rankine)
-  end
-
-  def from_réaumur(given)
-    ((given * 5) / 4) + BigDecimal("273.15")
-  end
-
-  def in_réaumur
-    ((common - BigDecimal("273.15")) * 4) / 5
-  end
-  alias :in_reaumur :in_réaumur
-
-  def to_réaumur
-    Tempura::Réaumur.new(in_réaumur)
-  end
-  alias :to_reaumur :to_réaumur
-
-  def from_rømer(given)
-    (((given - BigDecimal("7.5")) * 40) / 21) + BigDecimal("273.15")
-  end
-
-  def in_rømer
-    (((common - BigDecimal("273.15")) * 21) / 40) + BigDecimal("7.5")
-  end
-  alias :in_romer :in_rømer
-
-  def to_rømer
-    Tempura::Rømer.new(in_rømer)
-  end
-  alias :to_romer :to_rømer
-
   private
   
   attr_reader :common
 
   def to_common(given)
-    self.send("from_#{self.class.name.split('::').last.downcase}", BigDecimal(given.to_s))
+    self.from_native(BigDecimal(given.to_s))
   end
 
   def in_native
     to_native(self)
   end
+
+  def to_native(temp)
+    self.class.as_native(temp.send(:common))
+  end
+
+  def numericalize(temp)
+    if temp.is_a?(Tempura::Temperature)
+      to_native(temp)
+    else
+      temp
+    end
+  end
 end

data/lib/tempura/version.rb

@@ -1,3 +1,3 @@
 module Tempura
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -4,46 +4,46 @@ require 'tempura'
 
 shared_examples_for '373.15 K' do
   it 'is expressable in Celsius (C)' do
-    expect(subject.to_celsius).to eq(100)
-    expect(subject.to_celsius).to be_a(Tempura::Celsius)
+    expect(subject.to.celsius).to eq(100)
+    expect(subject.to.celsius).to be_a(Tempura::Celsius)
   end
 
   it 'is expressable in Delisle (De)' do
-    expect(subject.to_delisle).to eq(0)
-    expect(subject.to_delisle).to be_a(Tempura::Delisle)
+    expect(subject.to.delisle).to eq(0)
+    expect(subject.to.delisle).to be_a(Tempura::Delisle)
   end
 
   it 'is expressable in Fahrenheit (F)' do
-    expect(subject.to_fahrenheit).to eq(212)
-    expect(subject.to_fahrenheit).to be_a(Tempura::Fahrenheit)
+    expect(subject.to.fahrenheit).to eq(212)
+    expect(subject.to.fahrenheit).to be_a(Tempura::Fahrenheit)
   end
 
   it 'is expressable in Kelvin (K)' do
-    expect(subject.to_kelvin).to eq(373.15)
-    expect(subject.to_kelvin).to be_a(Tempura::Kelvin)
+    expect(subject.to.kelvin).to eq(373.15)
+    expect(subject.to.kelvin).to be_a(Tempura::Kelvin)
   end
   
   it 'is expressable in Newton (N)' do
-    expect(subject.to_newton).to eq(33)
-    expect(subject.to_newton).to be_a(Tempura::Newton)
+    expect(subject.to.newton).to eq(33)
+    expect(subject.to.newton).to be_a(Tempura::Newton)
   end
 
   it 'is expressable in Rankine (R)' do
-    expect(subject.to_rankine).to eq(671.67)
-    expect(subject.to_rankine).to be_a(Tempura::Rankine)
+    expect(subject.to.rankine).to eq(671.67)
+    expect(subject.to.rankine).to be_a(Tempura::Rankine)
   end
   
   it 'is expressable in Réaumur (Ré)' do
-    expect(subject.to_réaumur).to eq(80)
-    expect(subject.to_réaumur).to be_a(Tempura::Réaumur)
-    expect(subject.to_reaumur).to eq(80)
-    expect(subject.to_reaumur).to be_a(Tempura::Réaumur)
+    expect(subject.to.réaumur).to eq(80)
+    expect(subject.to.réaumur).to be_a(Tempura::Réaumur)
+    expect(subject.to.reaumur).to eq(80)
+    expect(subject.to.reaumur).to be_a(Tempura::Réaumur)
   end
   
   it 'is expressable in Rømer (Rø)' do
-    expect(subject.to_rømer).to eq(60)
-    expect(subject.to_rømer).to be_a(Tempura::Rømer)
-    expect(subject.to_romer).to eq(60)
-    expect(subject.to_rømer).to be_a(Tempura::Rømer)
+    expect(subject.to.rømer).to eq(60)
+    expect(subject.to.rømer).to be_a(Tempura::Rømer)
+    expect(subject.to.romer).to eq(60)
+    expect(subject.to.rømer).to be_a(Tempura::Rømer)
   end
 end

data/spec/tempura/conversion_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tempura::Conversion do
+  let(:c) { 100.degrees_celsius }
+  let(:d) { 0.degrees_delisle }
+  let(:f) { 212.degrees_fahrenheit }
+  let(:n) { 33.degrees_newton }
+  let(:ra) { 671.67.degrees_rankine }
+  let(:ré) { 80.degrees_réaumur }
+  let(:rø) { 60.degrees_rømer }
+
+  it 'provides a common interface' do
+    [c, d, f, n, ra, ré, rø].each do |t|
+      expect(t.to).to be_a(Tempura::Conversion)
+    end
+  end
+
+  describe 'converting to temps' do
+
+    it 'converts to a scale' do
+      c2f = c.to.fahrenheit
+      expect(c2f).to be_a(Tempura::Fahrenheit)
+      expect(c2f).to eq(f)
+    end
+
+    it 'converts to an aliased scale' do
+      n2ro = n.to.romer
+      expect(n2ro).to be_a(Tempura::Rømer)
+      expect(n2ro).to eq(rø)
+    end
+
+  end
+end

data/spec/tempura/core_ext_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Numeric do
+
+  describe 'converting to temps' do
+    let(:c) { 100.degrees_celsius }
+    let(:d) { 0.degrees_delisle }
+    let(:f) { 212.degrees_fahrenheit }
+    let(:n) { 33.degrees_newton }
+    let(:ra) { 671.67.degrees_rankine }
+    let(:ré) { 80.degrees_réaumur }
+    let(:re) { 80.degrees_reaumur }
+    let(:rø) { 60.degrees_rømer }
+    let(:ro) { 60.degrees_romer }
+
+    it 'converts to celsius' do
+      expect(c).to be_a(Tempura::Celsius)
+    end
+
+    it 'converts to delisle' do
+      expect(d).to be_a(Tempura::Delisle)
+    end
+
+    it 'converts to fahrenheit' do
+      expect(f).to be_a(Tempura::Fahrenheit)
+    end
+
+    it 'converts to newton' do
+      expect(n).to be_a(Tempura::Newton)
+    end
+
+    it 'converts to rankine' do
+      expect(ra).to be_a(Tempura::Rankine)
+    end
+
+    it 'converts to réaumur' do
+      expect(ré).to be_a(Tempura::Réaumur)
+      expect(re).to be_a(Tempura::Réaumur)
+    end
+
+    it 'converts to rømer' do
+      expect(rø).to be_a(Tempura::Rømer)
+      expect(ro).to be_a(Tempura::Rømer)
+    end
+
+    it 'correctly converted them all' do
+      scales = [c, d, f, n, ra, ré, re, rø, ro]
+      scales.each { |s1|
+        scales.each { |s2|
+          expect(s1 == s2).to be_true
+        }
+      }
+    end
+  end
+
+end

data/spec/tempura/temperature_spec.rb

@@ -54,7 +54,7 @@ describe Tempura::Temperature do
       c = Tempura::Celsius.new(100)
       r = Tempura::Rømer.new(60)
       k = Tempura::Kelvin.new(373.15)
-      result = ((f + c + r + k) / 4 ).to_delisle
+      result = ((f + c + r + k) / 4 ).to.delisle
       expect(result).to eq(0)
       expect(result).to be_a(Tempura::Delisle)
     end
@@ -64,8 +64,8 @@ describe Tempura::Temperature do
     it 'compares internal value' do
       fahrenheit = Tempura::Fahrenheit.new(212)
       celsius = Tempura::Celsius.new(101)
-      leg = fahrenheit <=> celsius
-      expect(leg).to eq(-1)
+      comp = fahrenheit <=> celsius
+      expect(comp).to eq(-1)
     end
 
     describe 'comparison operators' do

data/tempura.gemspec

@@ -18,7 +18,9 @@ Gem::Specification.new do |gem|
                         README.md
                         Rakefile
                         lib/tempura.rb
+                        lib/tempura/core_ext/numeric.rb
                         lib/tempura/celsius.rb
+                        lib/tempura/conversion.rb
                         lib/tempura/delisle.rb
                         lib/tempura/fahrenheit.rb
                         lib/tempura/kelvin.rb
@@ -30,6 +32,8 @@ Gem::Specification.new do |gem|
                         lib/tempura/version.rb
                         spec/spec_helper.rb
                         spec/tempura/celsius_spec.rb
+                        spec/tempura/conversion_spec.rb
+                        spec/tempura/core_ext_spec.rb
                         spec/tempura/delisle_spec.rb
                         spec/tempura/fahrenheit_spec.rb
                         spec/tempura/kelvin_spec.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tempura
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-23 00:00:00.000000000 Z
+date: 2013-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -41,7 +41,9 @@ files:
 - README.md
 - Rakefile
 - lib/tempura.rb
+- lib/tempura/core_ext/numeric.rb
 - lib/tempura/celsius.rb
+- lib/tempura/conversion.rb
 - lib/tempura/delisle.rb
 - lib/tempura/fahrenheit.rb
 - lib/tempura/kelvin.rb
@@ -53,6 +55,8 @@ files:
 - lib/tempura/version.rb
 - spec/spec_helper.rb
 - spec/tempura/celsius_spec.rb
+- spec/tempura/conversion_spec.rb
+- spec/tempura/core_ext_spec.rb
 - spec/tempura/delisle_spec.rb
 - spec/tempura/fahrenheit_spec.rb
 - spec/tempura/kelvin_spec.rb
@@ -76,7 +80,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -301657800019721027
+      hash: 2341544860719829605
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -85,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -301657800019721027
+      hash: 2341544860719829605
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -95,6 +99,8 @@ summary: Tempura is a library for temperature math and conversion.
 test_files:
 - spec/spec_helper.rb
 - spec/tempura/celsius_spec.rb
+- spec/tempura/conversion_spec.rb
+- spec/tempura/core_ext_spec.rb
 - spec/tempura/delisle_spec.rb
 - spec/tempura/fahrenheit_spec.rb
 - spec/tempura/kelvin_spec.rb