ruby-units 1.2.0 → 1.3.0.a

data/TODO

@@ -1,3 +1,2 @@
-2010-03-05  update for ruby 1.9
-2010-03-05  update tests to use specs or cucumber stories
-2006-10-02  Currency handling remains to be implemented well
+2006-10-02  Currency handling remains to be implemented well
+2011-04-23  Refactor caching

data/spec/ruby-units/array_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Array do
+  
+  subject { [1, 'cm'] }
+  
+  it {should be_kind_of Array}
+  it {should respond_to :to_unit}
+  
+  specify { subject.to_unit.should be_instance_of Unit}
+  specify { subject.to_unit.should == "1 cm".to_unit }
+  specify { subject.to_unit('mm').should == "10 mm".to_unit}
+  
+end

data/spec/ruby-units/complex_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Complex numbers are a bit strange
+# Technically you can't really compare them using <=>, and ruby 1.9 does not implement this method for them
+# so it stands to reason that complex units should also not support :> or :<
+
+describe Complex do
+  subject { Complex(1,1) }
+  it { should respond_to :to_unit }
+end
+
+describe "Complex Unit" do
+  subject { Complex(1.0, -1.0).to_unit }
+  
+  it { should be_instance_of Unit}
+  it(:scalar) { should be_kind_of Complex }
+
+  it { should == "1-1i".to_unit }
+  it { should === "1-1i".to_unit }
+
+  if RUBY_VERSION < "1.9"
+    context "in Ruby < 1.9" do
+      it "is comparable" do
+        subject.should > "1+0.5i".to_unit
+        subject.should < "2+1i".to_unit
+      end
+    end
+  else
+    context "in Ruby >= 1.9" do
+      it "is not comparable" do 
+        expect { subject > "1+1i".to_unit }.to raise_error(NoMethodError)
+        expect { subject < "1+1i".to_unit }.to raise_error(NoMethodError) 
+      end
+    end
+  end
+  
+end

data/spec/ruby-units/date_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Date do
+  subject { Date.new(2011,4,1) }
+  
+  it {should be_instance_of Date}
+  it {should respond_to :to_unit}
+  it {should respond_to :to_time}
+  it {should respond_to :to_date}  
+  
+  specify { (subject + "5 days".unit).should == Date.new(2011,4,6) }
+  specify { (subject - "5 days".unit).should == Date.new(2011,3,27) }
+  # 2012 is a leap year...
+  specify { (subject + "1 year".unit).should == Date.new(2012,3,31) }
+  specify { (subject - "1 year".unit).should == Date.new(2010,4,1) }
+end
+
+describe "Date Unit" do
+
+  subject { Date.new(2011,4,1).to_unit }
+
+  it { should be_instance_of Unit }
+  its(:scalar) { should be_kind_of Rational }
+  its(:units) { should == "d" }
+  its(:kind) { should == :time }
+
+  specify { (subject + "5 days".unit).should == Date.new(2011,4,6) }
+  specify { (subject - "5 days".unit).should == Date.new(2011,3,27) }
+
+  specify { expect { subject + Date.new(2011,4,1) }.to raise_error(ArgumentError) }
+  specify { expect { subject + DateTime.new(2011,4,1,12,00,00) }.to raise_error(ArgumentError) }
+  specify { expect { subject + Time.parse("2011-04-01 12:00:00") }.to raise_error(ArgumentError) }
+
+  specify { (subject - Date.new(2011,4,1)).should be_zero }
+  specify { (subject - DateTime.new(2011,4,1,00,00,00)).should be_zero }
+  specify { expect {(subject - Time.parse("2011-04-01 00:00"))}.to raise_error(ArgumentError) }
+  specify { (Date.new(2011,4,1) + 1).should == Date.new(2011,4,2)}
+end

data/spec/ruby-units/math_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Math do
+  context "with '1 mm^6'" do
+    subject { '1 mm^6'.to_unit }
+    
+    specify { Math.sqrt(subject).should == '1 mm^3'.to_unit }
+    specify { Math.sqrt(4).should == 2 }
+    
+    if RUBY_VERSION > "1.9"
+      # cbrt is only defined in Ruby > 1.9
+      specify { Math.cbrt(subject).should == '1 mm^2'.to_unit }
+      specify { Math.cbrt(8).should == 2 }
+    end
+
+  end
+  
+  context "Trigonometry functions" do
+    
+    context "with '45 deg' unit" do
+      subject { "45 deg".unit }
+      specify { Math.sin(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.cos(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.tan(subject).should be_within(0.01).of(1) }
+      specify { Math.sinh(subject).should be_within(0.01).of(0.8686709614860095) }
+      specify { Math.cosh(subject).should be_within(0.01).of(1.3246090892520057) }
+      specify { Math.tanh(subject).should be_within(0.01).of(0.6557942026326724) }
+    end
+
+    context "with 'PI/4 radians' unit" do
+      subject { (Math::PI/4).unit('radians') }
+      specify { Math.sin(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.cos(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.tan(subject).should be_within(0.01).of(1) }
+      specify { Math.sinh(subject).should be_within(0.01).of(0.8686709614860095) }
+      specify { Math.cosh(subject).should be_within(0.01).of(1.3246090892520057) }
+      specify { Math.tanh(subject).should be_within(0.01).of(0.6557942026326724) }
+    end
+
+    context "with 'PI/4' continues to work" do
+      subject { (Math::PI/4) }
+      specify { Math.sin(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.cos(subject).should be_within(0.01).of(0.70710678) }
+      specify { Math.tan(subject).should be_within(0.01).of(1) }
+      specify { Math.sinh(subject).should be_within(0.01).of(0.8686709614860095) }
+      specify { Math.cosh(subject).should be_within(0.01).of(1.3246090892520057) }
+      specify { Math.tanh(subject).should be_within(0.01).of(0.6557942026326724) }
+    end
+
+    specify { Math.hypot("1 m".unit, "2 m".unit).should be_within("0.01 m".unit).of("2.23607 m".unit) }
+    specify { Math.hypot("1 m".unit, "2 ft".unit).should be_within("0.01 m".unit).of("1.17116 m".unit) }
+    specify { expect {Math.hypot("1 m".unit, "2 lbs".unit) }.to raise_error(ArgumentError) }
+    
+    specify { Math.atan2("1 m".unit, "2 m".unit).should be_within(0.01).of(0.4636476090008061) }
+    specify { Math.atan2("1 m".unit, "2 ft".unit).should be_within(0.01).of(1.0233478888629426) }
+    specify { Math.atan2(1,1).should be_within(0.01).of(0.785398163397448)}
+    specify { expect {Math.atan2("1 m".unit, "2 lbs".unit)}.to raise_error(ArgumentError) }
+    
+  end
+  
+  
+  
+end

data/spec/ruby-units/numeric_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# some rubies return an array of strings for .instance_methods and others return an array of symbols
+# so let's stringify them before we compare
+describe Numeric do
+  specify { Float.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+  specify { Integer.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+  specify { Fixnum.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+  specify { Complex.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+  specify { Bignum.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+  specify { Rational.instance_methods.map {|m| m.to_s}.should include("to_unit") }
+end

data/spec/ruby-units/object_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Object do
+  specify { Unit('1 mm').should be_instance_of Unit}
+  specify { U('1 mm').should be_instance_of Unit}
+  specify { u('1 mm').should be_instance_of Unit}
+end

data/spec/ruby-units/string_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe String do
+  context "Unit creation from strings" do
+    specify { "1 mm".to_unit.should be_instance_of Unit }
+    specify { "1 mm".unit.should be_instance_of Unit }
+    specify { "1 mm".u.should be_instance_of Unit }
+    specify { "1 m".to("ft").should be_within(Unit("0.01 ft")).of Unit("3.28084 ft") }
+  end
+  
+  context "Time syntax sugar" do
+    before(:each) do
+      Time.stub(:now).and_return(Time.at(1303656390))
+      Date.stub(:today).and_return(Date.new(2011,4,1))
+      DateTime.stub(:now).and_return(DateTime.new(2011,4,1,0,0,0))
+    end
+    specify { "5 min".ago.should be_instance_of Time }
+    
+    specify { "5 min".from.should be_instance_of Time }
+    specify { "5 min".from('now').should be_instance_of Time }
+    specify { "5 min".from_now.should be_instance_of Time }
+    
+    specify { "5 min".after('12:00').should be_instance_of Time }
+    
+    specify { "5 min".before.should be_instance_of Time}
+    specify { "5 min".before('now').should be_instance_of Time}
+    specify { "5 min".before_now.should be_instance_of Time}
+    specify { "5 min".before('12:00').should be_instance_of Time}
+    
+    specify { "min".since.should be_instance_of Unit}
+    specify { "min".since("12:00").should be_instance_of Unit}
+    specify { "min".since(Time.now - 60).should == Unit("1 min")}
+    specify { "days".since(Date.today - 3).should == Unit("3 d")}
+    specify { expect {"days".since(1000) }.to raise_error(ArgumentError, "Must specify a Time, DateTime, or String")}
+            
+    specify { "min".until.should be_instance_of Unit}
+    specify { "min".until("12:00").should be_instance_of Unit}
+    specify { "min".until(Time.now + 60).should == Unit("1 min")}
+    specify { "days".until(Date.today + 3).should == Unit("3 d")}
+    specify { expect {"days".until(1000) }.to raise_error(ArgumentError, "Must specify a Time, DateTime, or String")}
+    
+    specify { "today".to_date.should be_instance_of Date }
+    specify { "2011-4-1".to_date.should be_instance_of Date }
+
+    specify { "now".to_datetime.should be_instance_of DateTime }
+    specify { "now".to_time.should be_instance_of Time }
+    
+    if RUBY_VERSION < "1.9" && RUBY_PLATFORM != 'java'
+      specify {"10001-01-01 12:00".time.should be_instance_of DateTime }
+    else
+      specify { "10001-01-01 12:00".time.should be_instance_of Time }
+    end
+    specify { "2001-01-01 12:00".time.should be_instance_of Time }
+    
+  end
+  
+  context "output format" do
+    subject { Unit("1.23456 m/s^2") }
+    specify { ("" % subject).should == ""}
+    specify { ("%0.2f" % subject).should == "1.23 m/s^2"}
+    specify { ("%0.2f km/h^2" % subject).should == "15999.90 km/h^2"}
+    specify { ("km/h^2" % subject).should == "15999.9 km/h^2"}
+    specify { ("%H:%M:%S" % Unit("1.5 h")).should == "01:30:00"}
+  end
+end

data/spec/ruby-units/time_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Time do
+  before(:each) do
+    Time.stub(:now).and_return(Time.at(1303656390))
+  end
+
+  context ".at" do
+    subject { Date.new(2011,4,1).to_unit }
+    specify { Time.at(subject - Date.new(1970,1,1)).strftime("%D %T").should == "03/31/11 20:00:00"}
+  end
+  
+  context ".in" do
+    specify { Time.in("5 min").should be_a Time}
+    specify { Time.in("5 min").should > Time.now}
+  end
+  
+  context 'addition (+)' do
+    specify { (Time.now + 1).should == Time.at(1303656390 + 1)}
+    specify { (Time.now + Unit("10 min")).should == Time.at(1303656390 + 600)}
+  end
+
+  context 'subtraction (-)' do
+    specify { (Time.now - 1).should == Time.at(1303656390 - 1)}
+    specify { (Time.now - Unit("10 min")).should == Time.at(1303656390 - 600)}
+  end
+
+end

data/spec/ruby-units/unit_spec.rb

@@ -0,0 +1,855 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Create some simple units" do
+
+  describe Unit("0") do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === 0}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should be_zero}
+    its(:base) {should == subject}  
+  end
+
+  describe Unit("1") do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === 1}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == subject}  
+  end
+
+  describe Unit(1) do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === 1}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == subject}  
+  end
+  
+  describe Unit(Rational(1,2)) do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === Rational(1,2)}
+    its(:scalar) {should be_a Rational}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == subject}  
+  end
+
+  describe Unit(0.5) do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === 0.5}
+    its(:scalar) {should be_a Float}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == subject}  
+  end
+
+  describe Unit(Complex(1,1)) do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should === Complex(1,1)}
+    its(:scalar) {should be_a Complex}
+    its(:units) {should be_empty}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == subject}  
+  end
+
+  describe Unit("1 mm") do
+    it {should be_a Numeric}
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should == 1}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "mm"}
+    its(:kind) {should == :length}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == Unit("0.001 m")}
+  end
+
+  describe Unit("10 m/s^2") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should == 10}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "m/s^2"}
+    its(:kind) {should == :acceleration}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should == Unit("10 m/s^2")}  
+  end
+
+  describe Unit("5ft 6in") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should == 5.5}
+    its(:units) {should == "ft"}
+    its(:kind) {should == :length}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_within(Unit("0.01 m")).of Unit("1.6764 m")}
+    specify { subject.to_s(:ft).should == %{5'6"} }
+  end
+
+  describe Unit("6lbs 5oz") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_within(0.001).of 6.312}
+    its(:units) {should == "lbs"}
+    its(:kind) {should == :mass}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_within(Unit("0.01 kg")).of Unit("2.8633 kg")}
+    specify { subject.to_s(:lbs).should == "6 lbs, 5 oz" }
+  end
+
+  describe Unit("100 tempC") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_within(0.001).of 100}
+    its(:units) {should == "tempC"}
+    its(:kind) {should == :temperature}
+    it {should be_temperature}
+    it {should be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_within(Unit("0.01 degK")).of Unit("373.15 tempK")}
+    its(:temperature_scale) {should == "degC"}
+  end
+
+  describe Unit(Time.now) do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_a(Numeric)}
+    its(:units) {should == "s"}
+    its(:kind) {should == :time}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a(Numeric)}
+    its(:temperature_scale) {should be_nil}
+  end
+
+  describe Unit("100 degC") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_within(0.001).of 100}
+    its(:units) {should == "degC"}
+    its(:kind) {should == :temperature}
+    it {should_not be_temperature}
+    it {should be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    its(:base) {should be_within(Unit("0.01 degK")).of Unit("100 degK")}
+  end
+      
+  describe Unit("75%") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "%"}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a(Numeric)}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  describe Unit("180 deg") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_a Numeric}
+    its(:units) {should == "deg"}
+    its(:kind) {should == :angle}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a(Numeric)}
+    its(:temperature_scale) {should be_nil}    
+  end
+  
+  describe Unit("1 radian") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_a Numeric}
+    its(:units) {should == "rad"}
+    its(:kind) {should == :angle}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  describe Unit("12 dozen") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "doz"}
+    its(:kind) {should == :unitless}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  describe Unit("1/2 kg") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Rational}
+    its(:units) {should == "kg"}
+    its(:kind) {should == :mass}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  describe Unit("1/2 kg/m") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Rational}
+    its(:units) {should == "kg/m"}
+    its(:kind) {should be_nil}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+  
+  describe Unit("1:23:45") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Rational}
+    its(:units) {should == "h"}
+    its(:kind) {should == :time}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  # also  '1 hours as minutes'
+  #       '1 hour to minutes'
+  describe Unit.parse("1 hour in minutes") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "min"}
+    its(:kind) {should == :time}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}    
+  end
+
+  describe Unit.new("1 attoparsec/microfortnight") do
+    it {should be_an_instance_of Unit}
+    its(:scalar) {should be_an Integer}
+    its(:units) {should == "apc/ufortnight"}
+    its(:kind) {should == :speed}
+    it {should_not be_temperature}
+    it {should_not be_degree}
+    it {should_not be_base}
+    it {should_not be_unitless}
+    it {should_not be_zero}
+    its(:base) {should be_a Numeric}
+    its(:temperature_scale) {should be_nil}
+    it { subject.to("in/s").should be_within(Unit("0.0001 in/s")).of(Unit("1.0043269330917 in/s"))}
+  end
+
+
+end
+
+describe "Unit handles attempts to create bad units" do
+  specify "no empty strings" do
+    expect {Unit("")}.to raise_error(ArgumentError,"No Unit Specified")
+  end
+
+  specify "no blank strings" do
+    expect {Unit("   ")}.to raise_error(ArgumentError,"No Unit Specified")
+  end
+
+  specify "no strings with tabs" do
+    expect {Unit("\t")}.to raise_error(ArgumentError,"No Unit Specified")
+  end
+
+  specify "no strings with newlines" do
+    expect {Unit("\n")}.to raise_error(ArgumentError,"No Unit Specified")
+  end
+
+  specify "no strings that don't specify a valid unit" do
+    expect {Unit("random string")}.to raise_error(ArgumentError,"'random string' Unit not recognized")
+  end
+  
+  specify "no unhandled classes" do
+    expect {Unit(STDIN)}.to raise_error(ArgumentError,"Invalid Unit Format")
+  end
+
+  specify "no undefined units" do
+    expect {Unit("1 mFoo")}.to raise_error(ArgumentError,"'1 mFoo' Unit not recognized")
+  end
+
+  specify "no units with powers greater than 19" do
+    expect {Unit("1 m^20")}.to raise_error(ArgumentError, "Power out of range (-20 < net power of a unit < 20)")
+  end
+
+  specify "no units with powers less than 19" do
+    expect {Unit("1 m^-20")}.to raise_error(ArgumentError, "Power out of range (-20 < net power of a unit < 20)")
+  end
+
+  specify "no temperatures less than absolute zero" do
+    expect {Unit("-100 tempK")}.to raise_error(ArgumentError,"Temperatures must not be less than absolute zero")
+    expect {Unit("-100 tempR")}.to raise_error(ArgumentError,"Temperatures must not be less than absolute zero")
+    expect {Unit("-500/9 tempR")}.to raise_error(ArgumentError,"Temperatures must not be less than absolute zero")
+  end
+
+end
+
+describe Unit do
+  it "is a subclass of Numeric" do
+     described_class.should < Numeric
+  end
+  it "is Comparable" do 
+    described_class.should < Comparable
+  end
+end
+
+describe "Unit Comparisons" do
+  context "Unit should detect if two units are 'compatible' (i.e., can be converted into each other)" do
+    specify { Unit("1 ft").should =~ Unit('1 m')}
+    specify { Unit("1 ft").should =~ "m"}
+    specify { Unit("1 ft").should be_compatible_with Unit('1 m')}
+    specify { Unit("1 ft").should be_compatible_with "m"}
+    specify { Unit("1 m").should be_compatible_with Unit('1 kg*m/kg')}    
+    specify { Unit("1 ft").should_not =~ Unit('1 kg')}
+    specify { Unit("1 ft").should_not be_compatible_with Unit('1 kg')}
+  end
+  
+  context "Equality" do
+    context "units of same kind" do
+      specify { Unit("1000 m").should == Unit('1 km')}
+      specify { Unit("100 m").should_not == Unit('1 km')}
+      specify { Unit("1 m").should == Unit('100 cm')}
+    end
+    
+    context "units of incompatible types" do
+      specify { Unit("1 m").should_not == Unit("1 kg")}
+    end
+    
+    context "units with a zero scalar are equal" do
+      specify {Unit("0 m").should == Unit("0 s")}
+      specify {Unit("0 m").should == Unit("0 kg")}
+      
+      context "except for temperature units" do
+        specify {Unit("0 tempK").should == Unit("0 m")}
+        specify {Unit("0 tempR").should == Unit("0 m")}
+        specify {Unit("0 tempC").should_not == Unit("0 m")}
+        specify {Unit("0 tempF").should_not == Unit("0 m")}
+      end
+    end
+  end
+  
+  context "Equivalence" do
+    context "units and scalars are the exactly the same" do
+      specify { Unit("1 m").should === Unit("1 m")}
+      specify { Unit("1 m").should be_same Unit("1 m")}
+      specify { Unit("1 m").should be_same_as Unit("1 m")}
+    end
+    
+    context "units are compatible but not identical" do
+      specify { Unit("1000 m").should_not === Unit("1 km")}
+      specify { Unit("1000 m").should_not be_same Unit("1 km")}
+      specify { Unit("1000 m").should_not be_same_as Unit("1 km")}      
+    end
+    
+    context "units are not compatible" do
+      specify { Unit("1000 m").should_not === Unit("1 hour")}
+      specify { Unit("1000 m").should_not be_same Unit("1 hour")}
+      specify { Unit("1000 m").should_not be_same_as Unit("1 hour")}
+    end
+    
+    context "scalars are different" do
+      specify { Unit("1 m").should_not === Unit("2 m")}
+      specify { Unit("1 m").should_not be_same Unit("2 m")}
+      specify { Unit("1 m").should_not be_same_as Unit("2 m")}      
+    end
+  end
+  
+  context "Comparisons" do
+    context "compatible units can be compared" do
+      specify { Unit("1 m").should < Unit("2 m")}
+      specify { Unit("2 m").should > Unit("1 m")}
+      specify { Unit("1 m").should < Unit("1 mi")}
+      specify { Unit("2 m").should > Unit("1 ft")}
+      specify { Unit("70 tempF").should > Unit("10 degC")}
+      specify { Unit("1 m").should > 0 }
+    end
+    
+    context "incompatible units cannot be compared" do
+      specify { expect { Unit("1 m") < Unit("1 liter")}.to raise_error(ArgumentError,"Incompatible Units (m !~ l)")}
+      specify { expect { Unit("1 kg") > Unit("60 mph")}.to raise_error(ArgumentError,"Incompatible Units (kg !~ mph)")}
+    end
+  end
+  
+end
+
+describe "Unit Conversions" do
+  
+  context "between compatible units" do
+    specify { Unit("1 s").to("ns").should == Unit("1e9 ns")}
+    specify { Unit("1 s").convert_to("ns").should == Unit("1e9 ns")}
+    specify { (Unit("1 s") >> "ns").should == Unit("1e9 ns")}
+
+    specify { Unit("1 m").to(Unit("ft")).should be_within(Unit("0.001 ft")).of(Unit("3.28084 ft"))}
+  end
+  
+  context "between incompatible units" do
+    specify { expect { Unit("1 s").to("m")}.to raise_error(ArgumentError,"Incompatible Units")}
+  end
+  
+  context "given bad input" do
+    specify { expect { Unit("1 m").to("random string")}.to raise_error(ArgumentError,"'random string' Unit not recognized")}
+    specify { expect { Unit("1 m").to(STDOUT)}.to raise_error(ArgumentError,"Unknown target units")}
+  end
+  
+  context "between temperature scales" do
+    # note that 'temp' units are for temperature readings on a scale, while 'deg' units are used to represent
+    # differences between temperatures, offsets, or other differential temperatures.
+    
+    specify { Unit("100 tempC").should be_within(Unit("0.001 degK")).of(Unit("373.15 tempK")) }
+    specify { Unit("0 tempC").should be_within(Unit("0.001 degK")).of(Unit("273.15 tempK")) }
+    specify { Unit("37 tempC").should be_within(Unit("0.01 degK")).of(Unit("310.15 tempK"))}
+    specify { Unit("-273.15 tempC").should == Unit("0 tempK") }
+    
+    specify { Unit("212 tempF").should be_within(Unit("0.001 degK")).of(Unit("373.15 tempK")) }
+    specify { Unit("32 tempF").should be_within(Unit("0.001 degK")).of(Unit("273.15 tempK")) }
+    specify { Unit("98.6 tempF").should be_within(Unit("0.01 degK")).of(Unit("310.15 tempK"))}
+    specify { Unit("-459.67 tempF").should == Unit("0 tempK") }
+
+    specify { Unit("671.67 tempR").should be_within(Unit("0.001 degK")).of(Unit("373.15 tempK")) }
+    specify { Unit("491.67 tempR").should be_within(Unit("0.001 degK")).of(Unit("273.15 tempK")) }
+    specify { Unit("558.27 tempR").should be_within(Unit("0.01 degK")).of(Unit("310.15 tempK"))}
+    specify { Unit("0 tempR").should == Unit("0 tempK") }
+    
+    specify { Unit("100 tempK").to("tempC").should be_within(U"0.01 degC").of(Unit("-173.15 tempC"))}
+    specify { Unit("100 tempK").to("tempF").should be_within(U"0.01 degF").of(Unit("-279.67 tempF"))}
+    specify { Unit("100 tempK").to("tempR").should be_within(U"0.01 degR").of(Unit("180 tempR"))}
+            
+    specify { Unit("1 degC").should == Unit("1 degK")}
+    specify { Unit("1 degF").should == Unit("1 degR")}
+    specify { Unit("1 degC").should == Unit("1.8 degR")}
+    specify { Unit("1 degF").should be_within(Unit("0.001 degK")).of(Unit("0.5555 degK"))}
+  end
+end
+
+describe "Unit Math" do
+  context "operators:" do
+    context "addition (+)" do
+      context "between compatible units" do
+        specify { (Unit("0 m") + Unit("10 m")).should == Unit("10 m")}
+        specify { (Unit("5 kg") + Unit("10 kg")).should == Unit("15 kg")}
+      end
+    
+      context "between a zero unit and another unit" do
+        specify { (Unit("0 kg") + Unit("10 m")).should == Unit("10 m")}
+        specify { (Unit("0 m") + Unit("10 kg")).should == Unit("10 kg")}
+      end
+    
+      context "between incompatible units" do
+        specify { expect {Unit("10 kg") + Unit("10 m")}.to raise_error(ArgumentError)}
+        specify { expect {Unit("10 m") + Unit("10 kg")}.to raise_error(ArgumentError)}
+      end
+
+      context "a number from a unit" do
+        specify { expect { Unit("10 kg") + 1 }.to raise_error(ArgumentError)}
+        specify { expect { 10 + Unit("10 kg") }.to raise_error(ArgumentError)}
+      end
+      
+      context "between two temperatures" do
+        specify { expect {(Unit("100 tempK") + Unit("100 tempK"))}.to raise_error(ArgumentError,"Cannot add two temperatures") }
+      end
+      
+      context "between a temperature and a degree" do
+        specify { (Unit("100 tempK") + Unit("100 degK")).should == Unit("200 tempK") }
+      end
+
+      context "between a degree and a temperature" do
+        specify { (Unit("100 degK") + Unit("100 tempK")).should == Unit("200 tempK") }
+      end
+    
+    end 
+  
+    context "subtracting (-)" do
+      context "compatible units" do
+        specify { (Unit("0 m") - Unit("10 m")).should == Unit("-10 m")}
+        specify { (Unit("5 kg") - Unit("10 kg")).should == Unit("-5 kg")}
+      end
+    
+      context "a unit from a zero unit" do
+        specify { (Unit("0 kg") - Unit("10 m")).should == Unit("-10 m")}
+        specify { (Unit("0 m") - Unit("10 kg")).should == Unit("-10 kg")}
+      end
+    
+      context "incompatible units" do
+        specify { expect {Unit("10 kg") - Unit("10 m")}.to raise_error(ArgumentError)}
+        specify { expect {Unit("10 m") - Unit("10 kg")}.to raise_error(ArgumentError)}
+      end
+    
+      context "a number from a unit" do
+        specify { expect { Unit("10 kg") - 1 }.to raise_error(ArgumentError)}
+        specify { expect { 10 - Unit("10 kg") }.to raise_error(ArgumentError)}
+      end
+
+      context "between two temperatures" do
+        specify { (Unit("100 tempK") - Unit("100 tempK")).should == Unit("0 degK") }
+      end
+      
+      context "between a temperature and a degree" do
+        specify { (Unit("100 tempK") - Unit("100 degK")).should == Unit("0 tempK") }
+      end
+
+      context "between a degree and a temperature" do
+        specify { expect {(Unit("100 degK") - Unit("100 tempK"))}.to raise_error(ArgumentError,"Cannot subtract a temperature from a differential degree unit")}
+      end
+    
+    end
+  
+    context "multiplying (*)" do
+      context "between compatible units" do
+        specify { (Unit("0 m") * Unit("10 m")).should == Unit("0 m^2")}
+        specify { (Unit("5 kg") * Unit("10 kg")).should == Unit("50 kg^2")}
+      end
+        
+      context "between incompatible units" do
+        specify { (Unit("0 m") * Unit("10 kg")).should == Unit("0 kg*m")}
+        specify { (Unit("5 m") * Unit("10 kg")).should == Unit("50 kg*m")}
+      end
+    
+      context "by a temperature" do
+        specify { expect { Unit("5 kg") * Unit("100 tempF")}.to raise_exception(ArgumentError) }
+      end
+
+      context "by a number" do
+        specify { (10 * Unit("5 kg")).should == Unit("50 kg")}
+      end
+    
+    end
+  
+    context "dividing (/)" do
+      context "compatible units" do
+        specify { (Unit("0 m") / Unit("10 m")).should == Unit(0)}
+        specify { (Unit("5 kg") / Unit("10 kg")).should == Rational(1,2)}
+      end
+        
+      context "incompatible units" do
+        specify { (Unit("0 m") / Unit("10 kg")).should == Unit("0 m/kg")}
+        specify { (Unit("5 m") / Unit("10 kg")).should == Unit("1/2 m/kg")}
+      end
+    
+      context "by a temperature" do
+        specify { expect { Unit("5 kg") / Unit("100 tempF")}.to raise_exception(ArgumentError) }
+      end
+
+      context "a number by a unit" do
+        specify { (10 / Unit("5 kg")).should == Unit("2 1/kg")}
+      end
+
+      context "a unit by a number" do
+        specify { (Unit("5 kg") / 2).should == Unit("2.5 kg")}
+      end
+    
+      context "by zero" do
+        specify { expect { Unit("10 m") / 0}.to raise_error(ZeroDivisionError)}
+        specify { expect { Unit("10 m") / Unit("0 m")}.to raise_error(ZeroDivisionError)}
+        specify { expect { Unit("10 m") / Unit("0 kg")}.to raise_error(ZeroDivisionError)}
+      end
+    end
+  
+    context "exponentiating (**)" do
+    
+      specify "a temperature raises an execption" do
+        expect { Unit("100 tempK")**2 }.to raise_error(ArgumentError,"Cannot raise a temperature to a power")
+      end
+    
+      context Unit("0 m") do
+        it { (subject**1).should == subject }
+        it { (subject**2).should == subject }
+      end
+
+      context Unit("1 m") do
+        it { (subject**0).should == 1 }
+        it { (subject**1).should == subject }
+        it { (subject**(-1)).should == 1/subject }
+        it { (subject**(2)).should == Unit("1 m^2")}
+        it { (subject**(-2)).should == Unit("1 1/m^2")}
+        specify { expect { subject**(1/2)}.to raise_error(ArgumentError, "Illegal root")}
+          # because 1 m^(1/2) doesn't make any sense
+        specify { expect { subject**(Complex(1,1))}.to raise_error(ArgumentError, "exponentiation of complex numbers is not yet supported.")}
+        specify { expect { subject**(Unit("1 m"))}.to raise_error(ArgumentError, "Invalid Exponent")}
+      end
+    
+      context Unit("1 m^2") do
+        it { (subject**(Rational(1,2))).should == Unit("1 m")}
+        it { (subject**(0.5)).should == Unit("1 m")}
+      
+        specify { expect { subject**(0.12345) }.to raise_error(ArgumentError,"Not a n-th root (1..9), use 1/n")}
+        specify { expect { subject**("abcdefg") }.to raise_error(ArgumentError,"Invalid Exponent")}
+      end
+    
+    end
+  
+    context "modulo (%)" do
+      context "compatible units" do
+        specify { (Unit("2 m") % Unit("1 m")).should == 0 }
+        specify { (Unit("5 m") % Unit("2 m")).should == 1 }
+      end
+    
+      specify "incompatible units raises an exception" do 
+        expect { Unit("1 m") % Unit("1 kg")}.to raise_error(ArgumentError,"Incompatible Units")
+      end
+    end
+  end
+  
+  context "#power" do
+    subject { Unit("1 m") }
+    it "raises an exception when passed a Float argument" do
+      expect {subject.power(1.5)}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when passed a Rational argument" do
+      expect {subject.power(Rational(1,2))}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when passed a Complex argument" do
+      expect {subject.power(Complex(1,2))}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when called on a temperature unit" do
+      expect { Unit("100 tempC").power(2)}.to raise_error(ArgumentError,"Cannot raise a temperature to a power")
+    end
+    
+    specify { (subject.power(-1)).should == Unit("1 1/m") }    
+    specify { (subject.power(0)).should == 1 }
+    specify { (subject.power(1)).should == subject }
+    specify { (subject.power(2)).should == Unit("1 m^2") }
+    
+  end
+  
+  context "#root" do
+    subject { Unit("1 m") }
+    it "raises an exception when passed a Float argument" do
+      expect {subject.root(1.5)}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when passed a Rational argument" do
+      expect {subject.root(Rational(1,2))}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when passed a Complex argument" do
+      expect {subject.root(Complex(1,2))}.to raise_error(ArgumentError,"Exponent must an Integer")
+    end
+    it "raises an exception when called on a temperature unit" do
+      expect { Unit("100 tempC").root(2)}.to raise_error(ArgumentError,"Cannot take the root of a temperature")
+    end
+    
+    specify { (Unit("1 m^2").root(-2)).should == Unit("1 1/m") }
+    specify { (subject.root(-1)).should == Unit("1 1/m") }    
+    specify { expect {(subject.root(0))}.to raise_error(ArgumentError, "0th root undefined")}
+    specify { (subject.root(1)).should == subject }
+    specify { (Unit("1 m^2").root(2)).should == Unit("1 m") }
+    
+  end
+  
+  context "#inverse" do
+    specify { Unit("1 m").inverse.should == Unit("1 1/m") }
+    specify { expect {Unit("100 tempK").inverse}.to raise_error(ArgumentError,"Cannot divide with temperatures") }
+  end
+  
+  context "convert to scalars" do
+    specify {Unit("10").to_i.should be_kind_of(Integer)}
+    specify { expect { Unit("10 m").to_i }.to raise_error(RuntimeError,"Cannot convert '10 m' to Integer unless unitless.  Use Unit#scalar") }
+
+    specify {Unit("10.0").to_f.should be_kind_of(Float)}
+    specify { expect { Unit("10.0 m").to_f }.to raise_error(RuntimeError,"Cannot convert '10 m' to Float unless unitless.  Use Unit#scalar") }
+
+    specify {Unit("1+1i").to_c.should be_kind_of(Complex)}
+    specify { expect { Unit("1+1i m").to_c }.to raise_error(RuntimeError,"Cannot convert '1.0+1.0i m' to Complex unless unitless.  Use Unit#scalar") }
+
+    specify {Unit("3/7").to_r.should be_kind_of(Rational)}
+    specify { expect { Unit("3/7 m").to_r }.to raise_error(RuntimeError,"Cannot convert '3/7 m' to Rational unless unitless.  Use Unit#scalar") }
+    
+  end
+  
+  context "absolute value (#abs)" do
+    context "of a unitless unit" do
+      specify "returns the absolute value of the scalar" do
+        Unit("-10").abs.should == 10
+      end
+    end
+    
+    context "of a unit" do
+      specify "returns a unit with the absolute value of the scalar" do
+        Unit("-10 m").abs.should == Unit("10 m")
+      end
+    end
+  end
+  
+  context "#ceil" do
+    context "of a unitless unit" do
+      specify "returns the ceil of the scalar" do
+        Unit("10.1").ceil.should == 11
+      end
+    end
+    
+    context "of a unit" do
+      specify "returns a unit with the ceil of the scalar" do
+        Unit("10.1 m").ceil.should == Unit("11 m")
+      end
+    end
+  end
+
+  context "#floor" do
+    context "of a unitless unit" do
+      specify "returns the floor of the scalar" do
+        Unit("10.1").floor.should == 10
+      end
+    end
+    
+    context "of a unit" do
+      specify "returns a unit with the floor of the scalar" do
+        Unit("10.1 m").floor.should == Unit("10 m")
+      end
+    end
+  end
+
+  context "#round" do
+    context "of a unitless unit" do
+      specify "returns the round of the scalar" do
+        Unit("10.5").round.should == 11
+      end
+    end
+    
+    context "of a unit" do
+      specify "returns a unit with the round of the scalar" do
+        Unit("10.5 m").round.should == Unit("11 m")
+      end
+    end
+  end
+  
+  context "#truncate" do
+    context "of a unitless unit" do
+      specify "returns the truncate of the scalar" do
+        Unit("10.5").truncate.should == 10
+      end
+    end
+    
+    context "of a unit" do
+      specify "returns a unit with the truncate of the scalar" do
+        Unit("10.5 m").truncate.should == Unit("10 m")
+      end
+    end
+  end
+  
+  context '#zero?' do
+    it "is true when the scalar is zero on the base scale" do
+      Unit("0").should be_zero
+      Unit("0 mm").should be_zero
+      Unit("-273.15 tempC").should be_zero
+    end
+
+    it "is false when the scalar is not zero" do
+      Unit("1").should_not be_zero
+      Unit("1 mm").should_not be_zero
+      Unit("0 tempC").should_not be_zero
+    end
+  end
+  
+  context '#succ' do
+    specify { Unit("1").succ.should == Unit("2")}
+    specify { Unit("1 mm").succ.should == Unit("2 mm")}
+    specify { Unit("1 mm").next.should == Unit("2 mm")}
+    specify { Unit("-1 mm").succ.should == Unit("0 mm")}
+    specify { expect {Unit("1.5 mm").succ}.to raise_error(ArgumentError,"Non Integer Scalar")}
+  end
+
+  context '#pred' do
+    specify { Unit("1").pred.should == Unit("0")}
+    specify { Unit("1 mm").pred.should == Unit("0 mm")}
+    specify { Unit("-1 mm").pred.should == Unit("-2 mm")}
+    specify { expect {Unit("1.5 mm").pred}.to raise_error(ArgumentError,"Non Integer Scalar")}
+  end
+
+  context '#divmod' do
+    specify { Unit("5 mm").divmod(Unit("2 mm")).should == [2,1] }
+    specify { Unit("1 km").divmod(Unit("2 m")).should == [500,0] }
+  end
+
+end
+
+describe "Unit Output formatting" do
+  context Unit("10.5 m/s^2") do
+    specify { subject.to_s.should == "10.5 m/s^2" }
+    specify { subject.to_s("%0.2f").should == "10.50 m/s^2"}
+    specify { subject.to_s("%0.2e km/s^2").should == "1.05e-02 km/s^2"}
+    specify { subject.to_s("km/s^2").should == "0.0105 km/s^2"}
+    specify { subject.to_s(STDOUT).should == "10.5 m/s^2" }
+    specify { expect {subject.to_s("random string")}.to raise_error(ArgumentError,"'random' Unit not recognized")}
+  end
+  
+end