unit 0.3.0 → 0.4.0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Rakefile

@@ -1,6 +1,18 @@
-task :default => :test
 
-desc 'Run tests with bacon'
-task :test => FileList['test/*_test.rb'] do |t|
-  sh "bacon -q -Ilib:test #{t.prerequisites.join(' ')}"
+require 'rspec/core/rake_task'
+task :default => :spec
+
+desc "Run specs"
+task :spec => ["spec:no_dsl", "spec:dsl"]
+
+namespace :spec do
+  desc "Run specs without DSL"
+  RSpec::Core::RakeTask.new(:no_dsl) do |t|
+    t.rspec_opts = "-t ~dsl"
+  end
+
+  desc "Run specs with DSL"
+  RSpec::Core::RakeTask.new(:dsl) do |t|
+    # Run all tests
+  end
 end

data/lib/unit/class.rb

@@ -2,6 +2,8 @@
 class Unit < Numeric
   attr_reader :value, :normalized, :unit, :system
 
+  class IncompatibleUnitError < TypeError; end
+
   def initialize(value, unit, system)
     @system = system
     @value = value
@@ -44,21 +46,33 @@ class Unit < Numeric
   end
 
   def *(other)
-    a, b = coerce(other)
-    Unit.new(a.value * b.value, a.unit + b.unit, system)
+    if Numeric === other
+      other = coerce_numeric(other)
+      Unit.new(other.value * self.value, other.unit + self.unit, system)
+    else
+      apply_through_coercion(other, __method__)
+    end
   end
 
   def /(other)
-    a, b = coerce(other)
-    Unit.new(Integer === a.value && Integer === b.value ? Rational(a.value, b.value) : a.value / b.value,
-             a.unit + Unit.power_unit(b.unit, -1), system)
+    if Numeric === other
+      other = coerce_numeric(other)
+      Unit.new(Integer === value && Integer === other.value ?
+               Rational(value, other.value) : value / other.value,
+               unit + Unit.power_unit(other.unit, -1), system)
+    else
+      apply_through_coercion(other, __method__)
+    end
   end
 
   def +(other)
-    raise TypeError, "Incompatible units: #{self.inspect} and #{other.inspect}" if !compatible?(other)
-    a, b = coerce(other)
-    a, b = a.normalize, b.normalize
-    Unit.new(a.value + b.value, a.unit, system).in(self)
+    if Numeric === other
+      other = coerce_numeric_compatible(other)
+      a, b = self.normalize, other.normalize
+      Unit.new(a.value + b.value, b.unit, system).in(self)
+    else
+      apply_through_coercion(other, __method__)
+    end
   end
 
   def **(exp)
@@ -67,23 +81,49 @@ class Unit < Numeric
   end
 
   def -(other)
-    self + (-other)
+    if Numeric === other
+      other = coerce_numeric_compatible(other)
+      a, b = self.normalize, other.normalize
+      Unit.new(a.value - b.value, b.unit, system).in(self)
+    else
+      apply_through_coercion(other, __method__)
+    end
   end
 
   def -@
     Unit.new(-value, unit, system)
   end
 
+  def abs
+    Unit.new(value.abs, unit, system)
+  end
+
+  def zero?
+    value.zero?
+  end
+
   def ==(other)
-    a, b = coerce(other)
-    a, b = a.normalize, b.normalize
-    a.value == b.value && a.unit == b.unit
+    if Numeric === other
+      other = coerce_numeric(other)
+      a, b = self.normalize, other.normalize
+      a.value == b.value && a.unit == b.unit
+    else
+      apply_through_coercion(other, __method__)
+    end
+  end
+
+  def eql?(other)
+    Unit === other && value.eql?(other.value) && unit == other.unit
   end
 
   def <=>(other)
-    a, b = coerce(other)
-    a, b = a.normalize, b.normalize
-    a.value <=> b.value if a.unit == b.unit
+    if Numeric === other
+      other = coerce_numeric_compatible(other)
+      a, b = self.normalize, other.normalize
+      a.value <=> b.value
+    else
+      apply_through_coercion(other, __method__)
+    end
   end
 
   # Number without dimension
@@ -91,22 +131,28 @@ class Unit < Numeric
     normalize.unit.empty?
   end
 
-  alias unitless? dimensionless?
+  alias_method :unitless?, :dimensionless?
 
   # Compatible units can be added
   def compatible?(other)
-    a, b = coerce(other)
-    a, b = a.normalize, b.normalize
-    a.unit == b.unit
+    self.normalize.unit == Unit.to_unit(other, system).normalize.unit
   end
 
-  alias compatible_with? compatible?
+  alias_method :compatible_with?, :compatible?
 
   # Convert to other unit
   def in(unit)
-    a, b = coerce(unit)
-    conversion = Unit.new(1, b.unit, system)
-    (a / conversion).normalize * conversion
+    conversion = Unit.new(1, Unit.to_unit(unit, system).unit, system)
+    (self / conversion).normalize * conversion
+  end
+
+  def in!(unit)
+    unit = coerce_object(unit)
+    result = self.in(unit)
+    unless result.unit == unit.unit
+      raise TypeError, "Unexpected #{result.inspect}, expected to be in #{other_unit.unit_string}"
+    end
+    result
   end
 
   def inspect
@@ -114,7 +160,7 @@ class Unit < Numeric
   end
 
   def to_s
-    unit.empty? ? value.to_s : "#{value} #{unit_string('·')}"
+    unit.empty? ? value.to_s : "#{value} #{unit_string}"
   end
 
   def to_tex
@@ -130,40 +176,20 @@ class Unit < Numeric
   end
 
   def approx
-    to_f.unit(unit)
-  end
-
-  def coerce(val)
-    [self, Unit.to_unit(val, system)]
-  end
-
-  def self.to_unit(object, system = nil)
-    system ||= Unit.default_system
-    case object
-    when Unit
-      raise TypeError, 'Different unit system' if object.system != system
-      object
-    when Array
-      system.validate_unit(object)
-      Unit.new(1, object, system)
-    when String, Symbol
-      unit = system.parse_unit(object.to_s)
-      system.validate_unit(unit)
-      Unit.new(1, unit, system)
-    when Numeric
-      Unit.new(object, [], system)
-    else
-      raise TypeError, "#{object.class} has no unit support"
-    end
+    Unit.new(self.to_f, unit, system)
   end
 
-  private
+  def coerce(other)
+    [coerce_numeric(other), self]
+  end
 
-  def unit_string(sep)
+  def unit_string(sep = '·')
     (unit_list(@unit.select {|factor, name, exp| exp >= 0 }) +
      unit_list(@unit.select {|factor, name, exp| exp < 0 })).join(sep)
   end
 
+  private
+
   def unit_list(list)
     units = []
     list.each do |factor, name, exp|
@@ -176,18 +202,14 @@ class Unit < Numeric
     units.sort
   end
 
-  def self.power_unit(unit, pow)
-    unit.map {|factor, name, exp| [factor, name, exp * pow] }
-  end
-
   # Reduce units and factors
   def reduce!
     # Remove numbers from units
     numbers = @unit.select {|factor, unit, exp| Numeric === unit }
     @unit -= numbers
     numbers.each do |factor, number, exp|
-       raise RuntimeError, 'Numeric unit with factor' if factor != :one
-       @value *= number ** exp
+      raise RuntimeError, 'Numeric unit with factor' if factor != :one
+      @value *= number ** exp
     end
 
     # Reduce units
@@ -227,7 +249,66 @@ class Unit < Numeric
     self
   end
 
-  class<< self
+  # Given another object and an operator, use the other object's #coerce method
+  # to perform the operation.
+  #
+  # Based on Matrix#apply_through_coercion
+  def apply_through_coercion(obj, oper)
+    coercion = obj.coerce(self)
+    raise TypeError unless coercion.is_a?(Array) && coercion.length == 2
+    first, last = coercion
+    first.send(oper, last)
+  rescue
+    raise TypeError, "#{obj.class} can't be coerced into #{self.class}"
+  end
+
+  def coerce_numeric_compatible(object)
+    object = coerce_numeric(object)
+    raise IncompatibleUnitError, "#{inspect} and #{object.inspect} are incompatible" if !compatible?(object)
+    object
+  end
+
+  def coerce_numeric(object)
+    Unit.numeric_to_unit(object, system)
+  end
+
+  def coerce_object(object)
+    Unit.to_unit(object, system)
+  end
+
+  class << self
     attr_accessor :default_system
+
+    def power_unit(unit, pow)
+      unit.map {|factor, name, exp| [factor, name, exp * pow] }
+    end
+
+    def numeric_to_unit(object, system = nil)
+      system ||= Unit.default_system
+      case object
+      when Unit
+        raise IncompatibleUnitError, "Unit system of #{object.inspect} is incompatible with #{system.name}" if object.system != system
+        object
+      when Numeric
+        Unit.new(object, [], system)
+      else
+        raise TypeError, "#{object.class} can't be coerced into Unit"
+      end
+    end
+
+    def to_unit(object, system = nil)
+      system ||= Unit.default_system
+      case object
+      when String, Symbol
+        unit = system.parse_unit(object.to_s)
+        system.validate_unit(unit)
+        Unit.new(1, unit, system)
+      when Array
+        system.validate_unit(object)
+        Unit.new(1, object, system)
+      else
+        numeric_to_unit(object, system)
+      end
+    end
   end
 end

data/lib/unit/dsl.rb

@@ -13,11 +13,12 @@ class Unit < Numeric
     name.to_s.sub(/^per_/, '1/').gsub('_per_', '/').gsub('_', ' ')
   end
 
-  def method_missing(name)
-    if name.to_s =~ /^in_/
-      self.in(Unit.method_name_to_unit($'))
+  def method_missing(name, system = nil)
+    if name.to_s =~ /^in_(.*?)(!?)$/
+      unit = Unit.method_name_to_unit($1)
+      $2.empty? ? self.in(unit) : self.in!(unit)
     else
-      Unit.to_unit(Unit.method_name_to_unit(name), system) * self
+      super(name, system || @system)
     end
   end
 end

data/lib/unit/system.rb

@@ -20,6 +20,9 @@ class Unit < Numeric
 
     def load(input)
       case input
+      when Hash
+        raise "Invalid hash format to load system" unless (input["units"] && input["units"].first.last['def']) || input.first.last['def']
+        data = input['units'] || input
       when IO
         data = YAML.load(input.read)
       when String

data/lib/unit/systems/si.yml

@@ -44,7 +44,7 @@ units:
     def: newton * meter
   watt:
     sym: W
-    def: joule * second
+    def: joule / second
   coloumb:
     sym: C
     def: ampere * second

data/lib/unit/version.rb

@@ -1,3 +1,3 @@
 class Unit < Numeric
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/error_spec.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe "Errors" do
+  describe "TypeError when adding incompatible units" do
+    it "should have a nice error message" do
+      a = Unit(1, "meter")
+      b = Unit(1, "second")
+      lambda { a + b }.should raise_error(TypeError, "#{a.inspect} and #{b.inspect} are incompatible")
+    end
+  end
+
+  describe "TypeError when trying to convert incompatible unit using #in!" do
+    it "should have a nice error message" do
+      unit = Unit(1000, "m / s")
+      lambda { unit.in!("seconds") }.should
+        raise_error(TypeError, %{Unexpected Unit("1000/1 m.s^-1"), expected to be in s})
+    end
+
+    it "should have a nice error message using the DSL", :dsl => true do
+      unit = Unit(1000, "m / s")
+      lambda { unit.in_seconds!  }.should
+        raise_error(TypeError, %{Unexpected Unit("1000/1 m.s^-1"), expected to be in s})
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'unit'
+require './spec/support/unit_one'
+
+RSpec.configure do |config|
+  unless config.exclusion_filter[:dsl]
+    config.before(:suite) do
+      require "unit/dsl"
+    end
+  end
+end
+

data/spec/support/unit_one.rb

@@ -0,0 +1,46 @@
+# Example test class for coercion
+#
+# UnitOne behaves as Unit(1) when added to a Unit, and as 1 when added to anything else.
+class UnitOne
+  def coerce(other)
+    case other
+    when Unit
+      [other, Unit(1)]
+    else
+      [other, 1]
+    end
+  end
+
+  def +(other)
+    apply_through_coercion(other, __method__)
+  end
+
+  def -(other)
+    apply_through_coercion(other, __method__)
+  end
+
+  def /(other)
+    apply_through_coercion(other, __method__)
+  end
+
+  def *(other)
+    apply_through_coercion(other, __method__)
+  end
+
+  def ==(other)
+    apply_through_coercion(other, __method__)
+  end
+
+  private
+
+  def apply_through_coercion(other, operation)
+    case other
+    when Unit
+      a, b = other.coerce(Unit(1))
+    else
+      a, b = other.coerce(1)
+    end
+
+    a.send(operation, b)
+  end
+end

data/{test/system_test.rb → spec/system_spec.rb}

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
-require 'bacon'
-require 'unit'
-require 'unit/dsl'
+require 'spec_helper'
 
 describe "Unit" do
   describe "#default_system" do
@@ -11,13 +9,23 @@ describe "Unit" do
         File.open(test_file) do |file|
           Unit.default_system.load(file)
         end
-        Unit(1, "pim").should.equal Unit(3.14159, "m")
+        Unit(1, "pim").should == Unit(3.14159, "m")
       end
 
       it "should load a file" do
         test_file = File.join(File.dirname(__FILE__), "yml", "filename.yml")
         Unit.default_system.load(test_file)
-        Unit(2, "dzm").should.equal Unit(24, "m")
+        Unit(2, "dzm").should == Unit(24, "m")
+      end
+
+      it "should load a hash" do
+        Unit.default_system.load({
+          'dozen_meter' => {
+            'sym' => 'dzm',
+            'def' => '12 m'
+          }
+        })
+        Unit(2, "dzm").should == Unit(24, "m")
       end
     end
   end

data/spec/unit_spec.rb

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+Unit.default_system.load(:scientific)
+Unit.default_system.load(:imperial)
+Unit.default_system.load(:misc)
+
+describe 'Unit' do
+  it 'should support multiplication' do
+    (Unit(2, 'm') * Unit(3, 'm')).should == Unit(6, 'm^2')
+    (Unit(2, 'm') * 3).should == Unit(6, 'm')
+    (Unit(2, 'm') * Rational(3, 4)).should == Unit(3, 2, 'm')
+    (Unit(2, 'm') * 0.5).should == Unit(1.0, 'm')
+  end
+
+  it 'should support division' do
+    (Unit(2, 'm') / Unit(3, 'm^2')).should == Unit(2, 3, '1/m')
+    (Unit(2, 'm') / 3).should == Unit(2, 3, 'm')
+    (Unit(2, 'm') / Rational(3, 4)).should == Unit(8, 3, 'm')
+    (Unit(2, 'm') / 0.5).should == Unit(4.0, 'm')
+  end
+
+  it 'should support addition' do
+    (Unit(42, 'm') + Unit(1, 'km')).should == Unit(1042, 'm')
+  end
+
+  it 'should support subtraction' do
+    (Unit(1, 'm') - Unit(1, 'cm')).should == Unit(99, 100, 'm')
+    (Unit(2, 'm') - Unit(1, 'm')).should == Unit(1, 'm')
+  end
+
+  it "should support arithmetic with Integers when appropriate" do
+    (1 + Unit(1)).should == Unit(2)
+    (2 - Unit(1)).should == Unit(1)
+    (Unit(2) - 1).should == Unit(1)
+    (2 - Unit(-1)).should == Unit(3)
+    (Unit(2) - -1).should == Unit(3)
+  end
+
+  it "should support arithmetic with other classes using #coerce" do
+    (Unit(2) + UnitOne.new).should == Unit(3)
+    (2 + UnitOne.new).should == 3
+    (Unit(2) - UnitOne.new).should == Unit(1)
+    (2 - UnitOne.new).should == 1
+    (Unit(2) * UnitOne.new).should == Unit(2)
+    (2 * UnitOne.new).should == 2
+    (Unit(2) / UnitOne.new).should == Unit(2)
+    (2 / UnitOne.new).should == 2
+
+    (UnitOne.new + Unit(4)).should == Unit(5)
+    (UnitOne.new + 4).should == 5
+    (UnitOne.new - Unit(4)).should == Unit(-3)
+    (UnitOne.new - 4).should == -3
+    (UnitOne.new * Unit(4)).should == Unit(4)
+    (UnitOne.new * 4).should == 4
+    (UnitOne.new / Unit(4)).should == Unit(1, 4)
+    (UnitOne.new / 4).should == 0
+  end
+
+  it "should support logic with other classes using #coerce" do
+    Unit(1).should == UnitOne.new
+    Unit(2).should > UnitOne.new
+  end
+
+  it "should support eql comparison" do
+    Unit(1).should eql(Unit(1))
+    Unit(1.0).should_not eql(Unit(1))
+
+    Unit(1).should_not eql(UnitOne.new)
+    Unit(1.0).should_not eql(UnitOne.new)
+  end
+
+  it "should not support adding anything but numeric unless object is coerceable" do
+    expect { Unit(1) + 'string'}.to raise_error(TypeError)
+    expect { Unit(1) + []}.to raise_error(TypeError)
+    expect { Unit(1) + :symbol }.to raise_error(TypeError)
+    expect { Unit(1) + {}}.to raise_error(TypeError)
+  end
+
+  it "should support adding through zero" do
+    (Unit(0, "m") + Unit(1, "m")).should == Unit(1, "m")
+    (Unit(1, "m") + Unit(-1, "m") + Unit(1, "m")).should == Unit(1, "m")
+  end
+
+  it 'should check unit compatiblity' do
+    expect {Unit(42, 'm') + Unit(1, 's')}.to raise_error(TypeError)
+    expect {Unit(42, 'g') + Unit(1, 'm')}.to raise_error(TypeError)
+    expect {Unit(0, 'g') + Unit(1, 'm')}.to raise_error(TypeError)
+  end
+
+  it 'should support exponentiation' do
+    (Unit(2, 'm') ** 3).should == Unit(8, 'm^3')
+    (Unit(9, 'm^2') ** 0.5).should == Unit(3.0, 'm')
+    (Unit(9, 'm^2') ** Rational(1, 2)).should == Unit(3, 'm')
+    (Unit(2, 'm') ** 1.3).should == Unit(2 ** 1.3, 'm^1.3')
+  end
+
+  it 'should not allow units as exponent' do
+    expect { Unit(42, 'g') ** Unit(1, 'm') }.to raise_error(TypeError)
+  end
+
+  describe "#normalize" do
+    it "should return a normalized unit" do
+      unit = Unit(1, 'joule')
+      normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
+
+      unit.normalize.should eql normalized_unit
+    end
+
+    it "should not modify the receiver" do
+      unit = Unit(1, 'joule')
+      normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
+
+      unit.normalize
+      unit.should_not eql normalized_unit
+    end
+  end
+
+  describe "#normalize!" do
+    it "should return a normalized unit" do
+      unit = Unit(1, 'joule')
+      normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
+
+      unit.normalize!.should eql normalized_unit
+    end
+
+    it "should modify the receiver" do
+      unit = Unit(1, 'joule')
+      normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
+
+      unit.normalize!
+      unit.should eql normalized_unit
+    end
+  end
+
+  it 'should convert units' do
+    Unit(1, "MeV").in("joule").should == Unit(1.602176487e-13, 'joule')
+    Unit(1, "kilometer").in("meter").should == Unit(1000, 'meter')
+    Unit(1, "liter").in('meter^3').should == Unit(1, 1000, 'meter^3')
+    Unit(1, "kilometer/hour").in("meter/second").should == Unit(5, 18, 'meter/second')
+  end
+
+  it 'should have a working compatible? method' do
+    Unit(7, "meter").compatible?('kilogram').should == false
+    Unit(3, "parsec").compatible_with?('meter').should == true
+  end
+
+  it 'should have a pretty string representation' do
+    Unit(7, "joule").normalize.to_s.should == '7000 g·m^2·s^-2'
+  end
+
+  it 'should parse units' do
+    Unit(1, 'KiB s^-1').unit.should == [[:kibi, :byte, 1], [:one, :second, -1]].sort
+    Unit(1, 'KiB/s').unit.should == [[:kibi, :byte, 1], [:one, :second, -1]].sort
+    Unit(1, 'kilometer^2 / megaelectronvolt^7 * gram centiliter').unit.should == [[:kilo, :meter, 2], [:mega, :electronvolt, -7],
+                                                                                     [:one, :gram, 1], [:centi, :liter, 1]].sort
+  end
+
+  it 'should reduce units' do
+    Unit(1, "joule/kilogram").normalize.unit.should == [[:one, :meter, 2], [:one, :second, -2]].sort
+    Unit(1, "megaton/kilometer").unit.should == [[:kilo, :ton, 1], [:one, :meter, -1]].reverse
+  end
+
+  it 'should work with floating point values' do
+    w = 5.2 * Unit('kilogram')
+    w.in("pounds").to_int.should == 11
+  end
+
+  it 'should have dimensionless? method' do
+    Unit(100, "m/km").should be_dimensionless
+    Unit(42, "meter/second").should_not be_unitless
+    Unit(100, "meter/km").should == Unit(Rational(1, 10))
+  end
+
+  it 'should be equal to rational if dimensionless' do
+    Unit(100, "meter/km").should == Rational(1, 10)
+    Unit(100, "meter/km").approx.should == 0.1
+  end
+
+  it 'should be comparable' do
+    Unit(1, 'm').should < Unit(2, 'm')
+    Unit(1, 'm').should <= Unit(2, 'm')
+
+    Unit(1, 'm').should <= Unit(1, 'm')
+    Unit(1, 'm').should >= Unit(1, 'm')
+
+    Unit(1, 'm').should > Unit(0, 'm')
+    Unit(1, 'm').should >= Unit(0, 'm')
+
+    Unit(100, "m").should < Unit(1, "km")
+    Unit(100, "m").should > Unit(0.0001, "km")
+  end
+
+  it "should fail comparison on differing units" do
+    expect { Unit(1, "second") > Unit(1, "meter") }.to raise_error(Unit::IncompatibleUnitError)
+  end
+
+  it "should keep units when the value is zero" do
+    Unit(0, "m").unit.should == [[:one, :meter, 1]]
+  end
+
+  it "should support absolute value" do
+    Unit(1, "m").abs.should == Unit(1, "m")
+    Unit(-1, "m").abs.should == Unit(1, "m")
+  end
+
+  it "should have #zero?" do
+    Unit(0, "m").zero?.should == true
+    Unit(1, "m").zero?.should == false
+  end
+
+  it "should produce an approximation" do
+    Unit(Rational(1,3), "m").approx.should == Unit(1.0/3.0, "m")
+  end
+
+end
+
+describe "Unit DSL", :dsl => true do
+  it 'should provide method sugar' do
+    1.meter.should == Unit('1 meter')
+    1.meter_per_second.should == Unit('1 m/s')
+    1.meter.in_kilometer.should == Unit('1 m').in('km')
+    1.unit('°C').should == Unit(1, '°C')
+  end
+end

data/unit.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.version = Unit::VERSION
 
   s.authors = ["Daniel Mendler"]
-  s.date = %q{2009-05-17}
+  s.date  = Date.today.to_s
   s.email = ["mail@daniel-mendler.de"]
 
   s.files         = `git ls-files`.split("\n")
@@ -19,5 +19,5 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/minad/unit}
 
   s.add_development_dependency('rake', ['>= 0.8.7'])
-  s.add_development_dependency('bacon')
+  s.add_development_dependency('rspec')
 end

metadata

@@ -1,50 +1,46 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: unit
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.4.0
   prerelease: 
-  version: 0.3.0
 platform: ruby
-authors: 
+authors:
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-05-17 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &7079200 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.8.7
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bacon
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *7079200
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &7078560 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *7078560
 description: 
-email: 
+email:
 - mail@daniel-mendler.de
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- .gitignore
 - .travis.yml
 - Gemfile
 - LICENSE
@@ -64,39 +60,36 @@ files:
 - lib/unit/systems/si.yml
 - lib/unit/systems/time.yml
 - lib/unit/version.rb
-- test/error_test.rb
-- test/system_test.rb
-- test/unit_test.rb
-- test/yml/filename.yml
-- test/yml/io.yml
+- spec/error_spec.rb
+- spec/spec_helper.rb
+- spec/support/unit_one.rb
+- spec/system_spec.rb
+- spec/unit_spec.rb
+- spec/yml/filename.yml
+- spec/yml/io.yml
 - unit.gemspec
-has_rdoc: true
 homepage: http://github.com/minad/unit
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: unit
-rubygems_version: 1.6.2
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Scientific unit support for ruby for calculations
 test_files: []
-

data/test/error_test.rb

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'bacon'
-require 'unit'
-require 'unit/dsl'
-
-describe "Errors" do
-  describe "TypeError when adding incompatible units" do
-    it "should have a nice error message" do
-      unit_1 = Unit(1, "meter")
-      unit_2 = Unit(1, "second")
-      lambda {
-        unit_1 + unit_2
-      }.should.raise(TypeError).message.should.equal("Incompatible units: #{unit_1.inspect} and #{unit_2.inspect}")
-    end
-  end
-end

data/test/unit_test.rb

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'bacon'
-require 'unit'
-require 'unit/dsl'
-
-Unit.default_system.load(:scientific)
-Unit.default_system.load(:imperial)
-Unit.default_system.load(:misc)
-
-describe 'Unit' do
-  it 'should support multiplication' do
-    (Unit(2, 'm') * Unit(3, 'm')).should.equal Unit(6, 'm^2')
-    (Unit(2, 'm') * 3).should.equal Unit(6, 'm')
-    (Unit(2, 'm') * Rational(3, 4)).should.equal Unit(3, 2, 'm')
-    (Unit(2, 'm') * 0.5).should.equal Unit(1.0, 'm')
-  end
-
-  it 'should support division' do
-    (Unit(2, 'm') / Unit(3, 'm^2')).should.equal Unit(2, 3, '1/m')
-    (Unit(2, 'm') / 3).should.equal Unit(2, 3, 'm')
-    (Unit(2, 'm') / Rational(3, 4)).should.equal Unit(8, 3, 'm')
-    (Unit(2, 'm') / 0.5).should.equal Unit(4.0, 'm')
-  end
-
-  it 'should support addition' do
-    (Unit(42, 'm') + Unit(1, 'km')).should.equal Unit(1042, 'm')
-    (Unit(1, 'm') - Unit(1, 'cm')).should.equal Unit(99, 100, 'm')
-  end
-
-  it "should support adding through zero" do
-    (Unit(0, "m") + Unit(1, "m")).should.equal Unit(1, "m")
-    (Unit(1, "m") + Unit(-1, "m") + Unit(1, "m")).should.equal Unit(1, "m")
-  end
-
-  it 'should check unit compatiblity' do
-    should.raise TypeError do
-      (Unit(42, 'm') + Unit(1, 's'))
-    end
-    should.raise TypeError do
-      (Unit(42, 'g') + Unit(1, 'm'))
-    end
-    should.raise TypeError do
-      (Unit(0, 'g') + Unit(1, 'm'))
-    end
-  end
-
-  it 'should support exponentiation' do
-    (Unit(2, 'm') ** 3).should.equal Unit(8, 'm^3')
-    (Unit(9, 'm^2') ** 0.5).should.equal Unit(3.0, 'm')
-    (Unit(9, 'm^2') ** Rational(1, 2)).should.equal Unit(3, 'm')
-    (Unit(2, 'm') ** 1.3).should.equal Unit(2 ** 1.3, 'm^1.3')
-  end
-
-  it 'should not allow units as exponent' do
-    should.raise TypeError do
-      Unit(42, 'g') ** Unit(1, 'm')
-    end
-  end
-
-  it 'should provide method sugar' do
-    1.meter.should.equal Unit('1 meter')
-    1.meter_per_second.should.equal Unit('1 m/s')
-    1.meter.in_kilometer.should.equal Unit('1 m').in('km')
-    1.unit('°C').should.equal Unit(1, '°C')
-  end
-
-  it 'should have a normalizer' do
-    1.joule.normalize.should.equal Unit(1000, 'gram meter^2 / second^2')
-    unit = 1.joule.normalize!
-    unit.should.equal unit.normalized
-  end
-
-  it 'should convert units' do
-    1.MeV.in_joule.should.equal Unit(1.602176487e-13, 'joule')
-    1.kilometer.in_meter.should.equal Unit(1000, 'meter')
-    1.liter.in('meter^3').should.equal Unit(1, 1000, 'meter^3')
-    1.kilometer_per_hour.in_meter_per_second.should.equal Unit(5, 18, 'meter/second')
-  end
-
-  it 'should have a working compatible? method' do
-    7.meter.compatible?('kilogram').should.equal false
-    3.parsec.compatible_with?('meter').should.equal true
-  end
-
-  it 'should have a pretty string representation' do
-    7.joule.normalize.to_s.should.equal '7000 g·m^2·s^-2'
-  end
-
-  it 'should parse units' do
-    Unit(1, 'KiB s^-1').unit.should.equal [[:kibi, :byte, 1], [:one, :second, -1]].sort
-    Unit(1, 'KiB/s').unit.should.equal [[:kibi, :byte, 1], [:one, :second, -1]].sort
-    Unit(1, 'kilometer^2 / megaelectronvolt^7 * gram centiliter').unit.should.equal [[:kilo, :meter, 2], [:mega, :electronvolt, -7],
-                                                                                     [:one, :gram, 1], [:centi, :liter, 1]].sort
-  end
-
-  it 'should reduce units' do
-    1.joule_per_kilogram.normalize.unit.should.equal [[:one, :meter, 2], [:one, :second, -2]].sort
-    1.megaton_per_kilometer.unit.should.equal [[:kilo, :ton, 1], [:one, :meter, -1]].sort
-  end
-
-  it 'should work with floating point values' do
-    #w = (5.2).kilogram
-    w = 5.2 * Unit('kilogram')
-    w.in_pounds.to_int.should.equal 11
-  end
-
-  it 'should have dimensionless? method' do
-    100.meter_per_km.should.be.dimensionless
-    100.meter.per_km.should.be.dimensionless
-    100.meter.per_km.should.be.unitless
-    42.meter.per_second.should.not.be.unitless
-    100.meter.per_km.should.equal Unit(Rational(1, 10))
-  end
-
-  it 'should be equal to rational if dimensionless' do
-    100.meter.per_km.should.equal Rational(1, 10)
-    100.meter.per_km.approx.should.equal 0.1
-  end
-
-  it 'should be comparable' do
-    Unit(1,'m').should < Unit(2,'m')
-    Unit(1,'m').should <= Unit(2,'m')
-
-    Unit(1,'m').should <= Unit(1,'m')
-    Unit(1,'m').should >= Unit(1,'m')
-
-    Unit(1,'m').should > Unit(0,'m')
-    Unit(1,'m').should >= Unit(0,'m')
-
-    Unit(100, "m").should < Unit(1, "km")
-    Unit(100, "m").should > Unit(0.0001, "km")
-  end
-
-  it "should fail comparison on differing units" do
-    lambda do
-      Unit(1, "second") > Unit(1, "meter")
-    end.should.raise(ArgumentError)
-  end
-
-  it "should keep units when the value is zero" do
-    Unit(0, "m").unit.should.equal [[:one, :meter, 1]]
-  end
-end
-