unit 0.4.1 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a84061a71aee6a42474eabd1fbf16301f8395d74
+  data.tar.gz: 979a52da34a279ed995492f15e03dc946024b13c
+SHA512:
+  metadata.gz: 1aa9ee8eb10eafdf62ae69ca9010abaf9a14226c64d74845ca5df15975f98d6eb3b33a1fbf6f22c70f970c3c25ebd06c56308559e55e8af45d444cedcaafcdab
+  data.tar.gz: 6408e2577ceca493523554aba26a753651388d4ef9afddcae7ea8d7242f1253a3b000cc6b75f637cc8b1092d68f20153e833b8982cc598fffd3263fbd5f5924d

data/.gitignore

@@ -1 +1,2 @@
 Gemfile.lock
+*.gem

data/.travis.yml

@@ -1,7 +1,11 @@
+language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.3
   - ruby-head
-  - jruby
-  - rbx-18mode
-  - rbx-19mode
+  - 2.2.2
+  - 2.1.6
+  - 2.0.0
+  - rbx-2
+  - 1.9.3
+  - jruby-head
+  - jruby-19mode
+sudo: false

data/Gemfile

@@ -1,2 +1,2 @@
-source :rubygems
+source 'https://rubygems.org/'
 gemspec

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2011 Daniel Mendler
+Copyright (c) 2011-2015 Daniel Mendler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.markdown

@@ -1,10 +1,17 @@
 README
-======
+===
+**Unit** introduces computational units to Ruby. It offers built-in support for binary, mathematical, SI, imperial, scientific and temporal units, and a simple interface for adding your own, custom units.
 
-Units introduces computation with units to ruby.
+[![Gem Version](https://badge.fury.io/rb/unit.png)](http://badge.fury.io/rb/unit) [![Dependency Status](https://gemnasium.com/minad/unit.png)](https://gemnasium.com/minad/unit) [![Build Status](https://secure.travis-ci.org/minad/unit.png?branch=master)](http://travis-ci.org/minad/unit) [![Code Climate](https://codeclimate.com/github/minad/unit.png)](https://codeclimate.com/github/minad/unit)
 
-Usage
------
+- Define units for operands to avoid the inevitable mistakes that plague unit-less operations.
+- Perform complex mathematical operations while respecting the units of each operand.
+- Get meaningful errors when units aren't compatible.
+- Convert values between different systems of units with ease.
+
+Examples
+===
+### General Usage
 
     require 'unit'
     puts 1.meter.in_kilometer
@@ -13,9 +20,22 @@ Usage
     puts 10.KiB_per_second
     puts Unit('1 m/s^2')
 
-See the test cases for more examples.
+### Mathematics
+
+    Unit(1, 'km') + Unit(500, 'm') == Unit(1.5, 'km')
+    Unit(1, 'kg') - Unit(500, 'g') == Unit(0.5, 'kg')
+    Unit(100, 'miles/hour') * Unit(0.5, 'hours') == Unit('50 mi')
+    Unit(5.5, 'feet') / 2 == Unit(2.75, 'feet')
+    Unit(2, 'm') ** 2 == Unit(4, 'm^2')
+
+### Conversions
+
+    Unit(1, 'mile').in('km') == Unit(1.609344,  'km')
+    (Unit(10, 'A') * Unit(0.1, 'volt')).in('watts') == Unit(1, 'watt')
+
+See the test cases for many more examples.
 
-Authors
--------
+Maintainers
+---
+Daniel Mendler and [Chris Cashwell](https://github.com/ccashwell)
 
-Daniel Mendler

data/Rakefile

@@ -2,17 +2,16 @@
 require 'rspec/core/rake_task'
 task :default => :spec
 
-desc "Run specs"
-task :spec => ["spec:no_dsl", "spec:dsl"]
+desc 'Run specs'
+task :spec => ['spec:no_dsl', 'spec:dsl']
 
 namespace :spec do
-  desc "Run specs without DSL"
+  desc 'Run specs without DSL'
   RSpec::Core::RakeTask.new(:no_dsl) do |t|
-    t.rspec_opts = "-t ~dsl"
+    t.rspec_opts = '-t ~dsl'
   end
 
-  desc "Run specs with DSL"
+  desc 'Run specs with DSL'
   RSpec::Core::RakeTask.new(:dsl) do |t|
-    # Run all tests
   end
 end

data/lib/unit.rb

@@ -1,5 +1,4 @@
 require 'unit/version'
-require 'unit/compatibility'
 require 'unit/class'
 require 'unit/system'
 require 'unit/constructor'

data/lib/unit/class.rb

@@ -159,11 +159,11 @@ class Unit < Numeric
   end
 
   def inspect
-    unit.empty? ? %{Unit("#{value}")} : %{Unit("#{value} #{unit_string('.')}")}
+    unit.empty? ? %{Unit("#{value}")} : %{Unit("#{value_string} #{unit_string('.')}")}
   end
 
   def to_s
-    unit.empty? ? value.to_s : "#{value} #{unit_string}"
+    unit.empty? ? value.to_s : "#{value_string} #{unit_string}"
   end
 
   def to_tex
@@ -182,14 +182,26 @@ class Unit < Numeric
     Unit.new(self.to_f, unit, system)
   end
 
-  def round
-    Unit.new(value.round, unit, system)
+  def round(precision = 0)
+    Unit.new(value.round(precision), unit, system)
   end
 
   def coerce(other)
     [coerce_numeric(other), self]
   end
 
+  def value_string
+    if Rational === value
+      if value.denominator == 1
+        value.numerator.to_s
+      else
+        value.inspect
+      end
+    else
+      value.to_s
+    end
+  end
+
   def unit_string(sep = '·')
     (unit_list(@unit.select {|factor, name, exp| exp >= 0 }) +
      unit_list(@unit.select {|factor, name, exp| exp < 0 })).join(sep)

data/lib/unit/dsl.rb

@@ -5,6 +5,8 @@ class Numeric
 
   def method_missing(name, system = nil)
     Unit.to_unit(Unit.method_name_to_unit(name), system) * self
+  rescue TypeError
+    super
   end
 end
 

data/lib/unit/system.rb

@@ -11,7 +11,7 @@ class Unit < Numeric
       @unit_symbol = {}
 
       # one is internal trivial factor
-      @factor = {:one => {:symbol => 'one', :value => 1} }
+      @factor = {one: {symbol: 'one', value: 1} }
       @factor_symbol = {'one' => :one}
       @factor_value = {1 => :one}
 
@@ -45,11 +45,7 @@ class Unit < Numeric
       load_factors(data['factors']) if data['factors']
       load_units(data['units']) if data['units']
 
-      @unit.each do |name, unit|
-        defs = unit.delete(:defs)
-        unit[:def] = parse_unit(defs) if defs
-        validate_unit(unit[:def])
-      end
+      @unit.each {|name, unit| validate_unit(unit[:def]) }
 
       true
     end
@@ -141,7 +137,7 @@ class Unit < Numeric
         raise "Invalid definition for factor #{name}" unless base
         value = base ** exp
         $stderr.puts "Factor #{name} already defined" if @factor[name]
-        @factor[name] = { :symbol => symbols.first, :value => value }
+        @factor[name] = { symbol: symbols.first, value: value }
         symbols.each do |sym|
           $stderr.puts "Factor symbol #{sym} for #{name} already defined" if @factor_symbol[name]
           @factor_symbol[sym] = name
@@ -155,7 +151,7 @@ class Unit < Numeric
         name = name.to_sym
         symbols = [unit['sym'] || []].flatten
         $stderr.puts "Unit #{name} already defined" if @unit[name]
-        @unit[name] = { :symbol => symbols.first, :defs => unit['def'] }
+        @unit[name] = { symbol: symbols.first, def: parse_unit(unit['def'])  }
         symbols.each do |sym|
           $stderr.puts "Unit symbol #{sym} for #{name} already defined" if @unit_symbol[name]
           @unit_symbol[sym] = name

data/lib/unit/version.rb

@@ -1,3 +1,3 @@
 class Unit < Numeric
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

data/spec/error_spec.rb

@@ -6,7 +6,7 @@ describe "Errors" 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")
+      expect { a + b }.to raise_error(TypeError, "#{a.inspect} and #{b.inspect} are incompatible")
     end
   end
 
@@ -18,7 +18,7 @@ describe "Errors" do
       )
     end
 
-    it "should have a nice error message using the DSL", :dsl => true do
+    it "should have a nice error message using the DSL", dsl: true do
       unit = Unit(1000, "m / s")
       expect { unit.in_seconds! }.to(
         raise_error(TypeError, %{Unexpected #{unit.inspect}, expected to be in s})

data/spec/spec_helper.rb

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

data/spec/system_spec.rb

@@ -9,7 +9,7 @@ describe Unit::System do
       system.load(:si)
       test_file = File.join(File.dirname(__FILE__), "yml", "io.yml")
       File.open(test_file) { |file| system.load(file) }
-      Unit(1, "pim", system).should == Unit(3.14159, "m", system)
+      expect(Unit(1, "pim", system)).to eq(Unit(3.14159, "m", system))
     end
 
     context "when passed a String" do
@@ -18,14 +18,14 @@ describe Unit::System do
           filename = File.join(File.dirname(__FILE__), "yml", "filename.yml")
           system.load(:si)
           system.load(filename)
-          Unit(2, "dzm", system).should == Unit(24, "m", system)
+          expect(Unit(2, "dzm", system)).to eq(Unit(24, "m", system))
         end
       end
 
       context "that is not a filename" do
         it "should load the built-in system of that name" do
           system.load("si")
-          lambda { Unit(2, 'm', system) }.should_not raise_exception
+          expect { Unit(2, 'm', system) }.not_to raise_exception
         end
       end
     end
@@ -42,7 +42,7 @@ describe Unit::System do
               }
             }
           )
-          Unit(2, "dzm", system).should == Unit(24, "m", system)
+          expect(Unit(2, "dzm", system)).to eq(Unit(24, "m", system))
         end
       end
 
@@ -57,14 +57,14 @@ describe Unit::System do
               }
             }
           )
-          Unit(2, "dzm", system).should == Unit(24, "m", system)
+          expect(Unit(2, "dzm", system)).to eq(Unit(24, "m", system))
         end
       end
 
       context "when passed an invalid factor" do
         it "should raise an exception" do
           system.load(:si)
-          lambda {
+          expect {
             system.load(
               'factors' => {
                 'dozen' => {
@@ -72,26 +72,26 @@ describe Unit::System do
                 }
               }
             )
-          }.should raise_exception("Invalid definition for factor dozen")
+          }.to raise_exception("Invalid definition for factor dozen")
         end
       end
     end
 
     context "when called on the same filename a second time" do
       it "should be a no-op" do
-        $stderr.should_not_receive(:puts)
+        expect($stderr).not_to receive(:puts)
         test_file = File.join(File.dirname(__FILE__), "yml", "filename.yml")
         system.load(:si)
         system.load(test_file)
-        lambda { system.load(test_file) }.should_not raise_exception
+        expect { system.load(test_file) }.not_to raise_exception
       end
     end
 
     context "when called on the same symbol a second time" do
       it "should be a no-op" do
-        $stderr.should_not_receive(:puts)
+        expect($stderr).not_to receive(:puts)
         system.load(:si)
-        lambda { system.load(:si) }.should_not raise_exception
+        expect { system.load(:si) }.not_to raise_exception
       end
     end
   end

data/spec/unit_spec.rb

@@ -7,67 +7,67 @@ 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')
+    expect(Unit(2, 'm') * Unit(3, 'm')).to eq(Unit(6, 'm^2'))
+    expect(Unit(2, 'm') * 3).to eq(Unit(6, 'm'))
+    expect(Unit(2, 'm') * Rational(3, 4)).to eq(Unit(3, 2, 'm'))
+    expect(Unit(2, 'm') * 0.5).to eq(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')
+    expect(Unit(2, 'm') / Unit(3, 'm^2')).to eq(Unit(2, 3, '1/m'))
+    expect(Unit(2, 'm') / 3).to eq(Unit(2, 3, 'm'))
+    expect(Unit(2, 'm') / Rational(3, 4)).to eq(Unit(8, 3, 'm'))
+    expect(Unit(2, 'm') / 0.5).to eq(Unit(4.0, 'm'))
   end
 
   it 'should support addition' do
-    (Unit(42, 'm') + Unit(1, 'km')).should == Unit(1042, 'm')
+    expect(Unit(42, 'm') + Unit(1, 'km')).to eq(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')
+    expect(Unit(1, 'm') - Unit(1, 'cm')).to eq(Unit(99, 100, 'm'))
+    expect(Unit(2, 'm') - Unit(1, 'm')).to eq(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)
+    expect(1 + Unit(1)).to eq(Unit(2))
+    expect(2 - Unit(1)).to eq(Unit(1))
+    expect(Unit(2) - 1).to eq(Unit(1))
+    expect(2 - Unit(-1)).to eq(Unit(3))
+    expect(Unit(2) - -1).to eq(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
+    expect(Unit(2) + UnitOne.new).to eq(Unit(3))
+    expect(2 + UnitOne.new).to eq(3)
+    expect(Unit(2) - UnitOne.new).to eq(Unit(1))
+    expect(2 - UnitOne.new).to eq(1)
+    expect(Unit(2) * UnitOne.new).to eq(Unit(2))
+    expect(2 * UnitOne.new).to eq(2)
+    expect(Unit(2) / UnitOne.new).to eq(Unit(2))
+    expect(2 / UnitOne.new).to eq(2)
+
+    expect(UnitOne.new + Unit(4)).to eq(Unit(5))
+    expect(UnitOne.new + 4).to eq(5)
+    expect(UnitOne.new - Unit(4)).to eq(Unit(-3))
+    expect(UnitOne.new - 4).to eq(-3)
+    expect(UnitOne.new * Unit(4)).to eq(Unit(4))
+    expect(UnitOne.new * 4).to eq(4)
+    expect(UnitOne.new / Unit(4)).to eq(Unit(1, 4))
+    expect(UnitOne.new / 4).to eq(0)
   end
 
   it "should support logic with other classes using #coerce" do
-    Unit(1).should == UnitOne.new
-    Unit(2).should > UnitOne.new
+    expect(Unit(1)).to eq(UnitOne.new)
+    expect(Unit(2)).to be > UnitOne.new
   end
 
   it "should support eql comparison" do
-    Unit(1).should eql(Unit(1))
-    Unit(1.0).should_not eql(Unit(1))
+    expect(Unit(1)).to eql(Unit(1))
+    expect(Unit(1.0)).not_to eql(Unit(1))
 
-    Unit(1).should_not eql(UnitOne.new)
-    Unit(1.0).should_not eql(UnitOne.new)
+    expect(Unit(1)).not_to eql(UnitOne.new)
+    expect(Unit(1.0)).not_to eql(UnitOne.new)
   end
 
   it "should not support adding anything but numeric unless object is coerceable" do
@@ -78,8 +78,8 @@ describe 'Unit' do
   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")
+    expect(Unit(0, "m") + Unit(1, "m")).to eq(Unit(1, "m"))
+    expect(Unit(1, "m") + Unit(-1, "m") + Unit(1, "m")).to eq(Unit(1, "m"))
   end
 
   it 'should check unit compatiblity' do
@@ -89,10 +89,10 @@ describe 'Unit' do
   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')
+    expect(Unit(2, 'm') ** 3).to eq(Unit(8, 'm^3'))
+    expect(Unit(9, 'm^2') ** 0.5).to eq(Unit(3.0, 'm'))
+    expect(Unit(9, 'm^2') ** Rational(1, 2)).to eq(Unit(3, 'm'))
+    expect(Unit(2, 'm') ** 1.3).to eq(Unit(2 ** 1.3, 'm^1.3'))
   end
 
   it 'should not allow units as exponent' do
@@ -104,7 +104,7 @@ describe 'Unit' do
       unit = Unit(1, 'joule')
       normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
 
-      unit.normalize.should eql normalized_unit
+      expect(unit.normalize).to eql normalized_unit
     end
 
     it "should not modify the receiver" do
@@ -112,7 +112,7 @@ describe 'Unit' do
       normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
 
       unit.normalize
-      unit.should_not eql normalized_unit
+      expect(unit).not_to eql normalized_unit
     end
   end
 
@@ -121,7 +121,7 @@ describe 'Unit' do
       unit = Unit(1, 'joule')
       normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
 
-      unit.normalize!.should eql normalized_unit
+      expect(unit.normalize!).to eql normalized_unit
     end
 
     it "should modify the receiver" do
@@ -129,66 +129,94 @@ describe 'Unit' do
       normalized_unit =  Unit(1000, 'gram meter^2 / second^2')
 
       unit.normalize!
-      unit.should eql normalized_unit
+      expect(unit).to 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')
+    expect(Unit(1, "MeV").in("joule")).to eq(Unit(1.602176487e-13, 'joule'))
+    expect(Unit(1, "kilometer").in("meter")).to eq(Unit(1000, 'meter'))
+    expect(Unit(1, "liter").in('meter^3')).to eq(Unit(1, 1000, 'meter^3'))
+    expect(Unit(1, "kilometer/hour").in("meter/second")).to eq(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
+    expect(Unit(7, "meter").compatible?('kilogram')).to eq(false)
+    expect(Unit(3, "parsec").compatible_with?('meter')).to eq(true)
   end
 
   it 'should have a pretty string representation' do
-    Unit(7, "joule").normalize.to_s.should == '7000 g·m^2·s^-2'
+    expect(Unit(7, "joule").normalize.to_s).to eq('7000 g·m^2·s^-2')
+  end
+
+  it 'should have a pretty string representation after subtraction' do
+    expect((Unit('5 cm') - Unit('1 cm')).to_s).to eq('4 cm')
+  end
+
+  describe "#value_string" do
+    it 'should behave like to_s normally' do
+      expect(Unit(1, "liter").send(:value_string)).to eq("1")
+      expect(Unit(0.5, "parsec").send(:value_string)).to eq("0.5")
+    end
+
+    it 'should wrap fractions in parentheses' do
+      expect(Unit(Rational(1, 2), "m").send(:value_string)).to eq("(1/2)")
+    end
+
+    it 'should show reduced fractions' do
+      expect(Unit(Rational(16, 6), "m").send(:value_string)).to eq("(8/3)")
+    end
+
+    it 'should not show 1 in the denominator' do
+      expect(Unit(Rational(1), "foot").send(:value_string)).to eq("1")
+      expect(Unit(Rational(4, 1), "inch").send(:value_string)).to eq("4")
+    end
+  end
+
+  it 'should support round trip through to_s' do
+    expect(Unit(Unit('(1/2) cm').to_s)).to eq(Unit('(1/2) cm'))
   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
+    expect(Unit(1, 'KiB s^-1').unit).to eq([[:kibi, :byte, 1], [:one, :second, -1]].sort)
+    expect(Unit(1, 'KiB/s').unit).to eq([[:kibi, :byte, 1], [:one, :second, -1]].sort)
+    expect(Unit(1, 'kilometer^2 / megaelectronvolt^7 * gram centiliter').unit).to eq([[: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 == [[:one, :meter, -1], [:kilo, :ton, 1]]
+    expect(Unit(1, "joule/kilogram").normalize.unit).to eq([[:one, :meter, 2], [:one, :second, -2]].sort)
+    expect(Unit(1, "megaton/kilometer").unit).to eq([[:one, :meter, -1], [:kilo, :ton, 1]])
   end
 
   it 'should work with floating point values' do
     w = 5.2 * Unit('kilogram')
-    w.in("pounds").to_int.should == 11
+    expect(w.in("pounds").to_int).to eq(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))
+    expect(Unit(100, "m/km")).to be_dimensionless
+    expect(Unit(42, "meter/second")).not_to be_unitless
+    expect(Unit(100, "meter/km")).to eq(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
+    expect(Unit(100, "meter/km")).to eq(Rational(1, 10))
+    expect(Unit(100, "meter/km").approx).to eq(0.1)
   end
 
   it 'should be comparable' do
-    Unit(1, 'm').should < Unit(2, 'm')
-    Unit(1, 'm').should <= Unit(2, 'm')
+    expect(Unit(1, 'm')).to be < Unit(2, 'm')
+    expect(Unit(1, 'm')).to be <= Unit(2, 'm')
 
-    Unit(1, 'm').should <= Unit(1, 'm')
-    Unit(1, 'm').should >= Unit(1, 'm')
+    expect(Unit(1, 'm')).to be <= Unit(1, 'm')
+    expect(Unit(1, 'm')).to be >= Unit(1, 'm')
 
-    Unit(1, 'm').should > Unit(0, 'm')
-    Unit(1, 'm').should >= Unit(0, 'm')
+    expect(Unit(1, 'm')).to be > Unit(0, 'm')
+    expect(Unit(1, 'm')).to be >= Unit(0, 'm')
 
-    Unit(100, "m").should < Unit(1, "km")
-    Unit(100, "m").should > Unit(0.0001, "km")
+    expect(Unit(100, "m")).to be < Unit(1, "km")
+    expect(Unit(100, "m")).to be > Unit(0.0001, "km")
   end
 
   it "should fail comparison on differing units" do
@@ -196,38 +224,46 @@ describe 'Unit' do
   end
 
   it "should keep units when the value is zero" do
-    Unit(0, "m").unit.should == [[:one, :meter, 1]]
+    expect(Unit(0, "m").unit).to eq([[: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")
+    expect(Unit(1, "m").abs).to eq(Unit(1, "m"))
+    expect(Unit(-1, "m").abs).to eq(Unit(1, "m"))
   end
 
   it "should have #zero?" do
-    Unit(0, "m").zero?.should == true
-    Unit(1, "m").zero?.should == false
+    expect(Unit(0, "m").zero?).to eq(true)
+    expect(Unit(1, "m").zero?).to eq(false)
   end
 
   it "should produce an approximation" do
-    Unit(Rational(1,3), "m").approx.should == Unit(1.0/3.0, "m")
+    expect(Unit(Rational(1,3), "m").approx).to eq(Unit(1.0/3.0, "m"))
   end
 
-  it "should be able to round and return a unit" do
-    Unit(Rational(1,3), "m").round.should == Unit(0, "m")
-    Unit(Rational(2,3), "m").round.should == Unit(1, "m")
-    Unit(0.1, "m").round.should == Unit(0, "m")
-    Unit(0.5, "m").round.should == Unit(1, "m")
-    Unit(1, "m").round.should == Unit(1, "m")
+  describe "#round" do
+    it "should be able to round and return a unit" do
+      expect(Unit(Rational(1,3), "m").round).to eq(Unit(0, "m"))
+      expect(Unit(Rational(2,3), "m").round).to eq(Unit(1, "m"))
+      expect(Unit(0.1, "m").round).to eq(Unit(0, "m"))
+      expect(Unit(0.5, "m").round).to eq(Unit(1, "m"))
+      expect(Unit(1, "m").round).to eq(Unit(1, "m"))
+    end
+
+    it "should respect rounding precision" do
+      expect(Unit(0.1234, "m").round(0)).to eq(Unit(0, "m"))
+      expect(Unit(1.2345, "m").round(1)).to eq(Unit(1.2, "m"))
+      expect(Unit(5.4321, "m").round(2)).to eq(Unit(5.43, "m"))
+    end
   end
 
 end
 
-describe "Unit DSL", :dsl => true do
+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')
+    expect(1.meter).to eq(Unit('1 meter'))
+    expect(1.meter_per_second).to eq(Unit('1 m/s'))
+    expect(1.meter.in_kilometer).to eq(Unit('1 m').in('km'))
+    expect(1.unit('°C')).to eq(Unit(1, '°C'))
   end
 end

data/unit.gemspec

@@ -1,22 +1,21 @@
 # -*- encoding: utf-8 -*-
 require File.dirname(__FILE__) + '/lib/unit/version'
+require 'date'
 
 Gem::Specification.new do |s|
-  s.name = %q{unit}
+  s.name = 'unit'
   s.version = Unit::VERSION
+  s.description =
+  s.summary = 'Scientific unit support for ruby for calculations'
+  s.homepage = 'http://github.com/minad/unit'
+  s.license = 'MIT'
 
-  s.authors = ["Daniel Mendler"]
+  s.authors = ['Daniel Mendler', 'Chris Cashwell']
   s.date  = Date.today.to_s
-  s.email = ["mail@daniel-mendler.de"]
+  s.email = ['mail@daniel-mendler.de']
 
   s.files         = `git ls-files`.split("\n")
-  s.require_paths = %w(lib)
-
-  s.has_rdoc = true
-  s.require_paths = ["lib"]
-  s.rubyforge_project = s.name
-  s.summary = 'Scientific unit support for ruby for calculations'
-  s.homepage = %q{http://github.com/minad/unit}
+  s.require_paths = ['lib']
 
   s.add_development_dependency('rake', ['>= 0.8.7'])
   s.add_development_dependency('rspec')

metadata

@@ -1,54 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: unit
 version: !ruby/object:Gem::Version
-  version: 0.4.1
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Daniel Mendler
+- Chris Cashwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-19 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &11788980 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.7
   type: :development
   prerelease: false
-  version_requirements: *11788980
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.7
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &11978500 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *11978500
-description: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Scientific unit support for ruby for calculations
 email:
 - mail@daniel-mendler.de
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.markdown
 - Rakefile
 - lib/unit.rb
 - lib/unit/class.rb
-- lib/unit/compatibility.rb
 - lib/unit/constructor.rb
 - lib/unit/dsl.rb
 - lib/unit/system.rb
@@ -69,27 +74,28 @@ files:
 - spec/yml/io.yml
 - unit.gemspec
 homepage: http://github.com/minad/unit
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: unit
-rubygems_version: 1.8.15
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Scientific unit support for ruby for calculations
 test_files: []
+has_rdoc: 

data/lib/unit/compatibility.rb

@@ -1,9 +0,0 @@
-# Units use symbols which must be sortable (Fix for Ruby 1.8)
-unless :test.respond_to? :<=>
-  class Symbol
-    include Comparable
-    def <=>(other)
-      self.to_i <=> other.to_i
-    end
-  end
-end