m9t 0.1.12 → 0.2.1

data/README.rdoc

@@ -11,6 +11,44 @@ The emphasis is on:
 * coherent interface,
 * ease of translation (using i18n).
 
+== Internals
+
+Internally, values are stored in SI units, with the exception of temperature:
+* distance - meters,
+* direction - degrees,
+* speed - meters per second,
+* temperature - degrees celcius,
+* weight - kilograms.
+
+== Interface
+
+new: accepts the S.I. unit as a parameter:
+
+    height = M9t::Distance.new(1.75)
+
+to_f: returns the decimal value(s):
+
+    height.to_f -> 1.75
+
+other units:
+there are class methods named after each known unit,
+which take values in that unit
+(actually, they are defined as needed):
+
+    marathon = M9t::Distance.miles(26.21875)
+    marathon.to_f -> 42194.988
+
+to_s: returns a localized string with units:
+
+    I18n.locale = :it
+    puts M9t::Distance.new(3).to_s -> '3 metri'
+
+=== Class methods for conversion
+
+Methods are available for conversion between any pair of units:
+
+    M9t::Distance.miles_to_meters(26.21875) -> 42194.988
+
 == Other Software
 
 * ruby-units

data/Rakefile

@@ -1,42 +1,20 @@
 require 'rubygems'
-require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'rake/testtask'
 require 'rake/clean'
 
-$:.unshift(File.dirname(__FILE__) + '/lib')
-require 'm9t'
+$:.unshift( File.dirname(__FILE__) + '/lib' )
+require "bundler/version"
 
 RDOC_OPTS = ['--quiet', '--title', 'm9t: Measurement units', '--main', 'README.rdoc', '--inline-source']
 CLEAN.include 'doc'
 
 task :default => :test
 
-spec = Gem::Specification.new do |s|
-  s.name        = 'm9t'
-  s.summary     = 'Classes for handling measurement units'
-  s.description = 'Classes for handling measurement units, conversions and translations'
-  s.version     = M9t::VERSION::STRING
-
-  s.homepage    = 'http://github.com/joeyates/m9t'
-  s.author      = 'Joe Yates'
-  s.email       = 'joe.g.yates@gmail.com'
-
-  s.files         = ['README.rdoc', 'COPYING', 'Rakefile'] + FileList['{lib,test}/**/*.rb'] + FileList['locales/**/*.{rb,yml}']
-  s.require_paths = ['lib']
-  s.add_dependency('i18n', '>= 0.3.5')
-
-  s.has_rdoc         = true
-  s.rdoc_options     += RDOC_OPTS
-  s.extra_rdoc_files = ['README.rdoc', 'COPYING']
-
-  s.test_file = 'test/test_all.rb'
-end
-
 Rake::TestTask.new do |t|
-  t.libs << 'test'
+  t.libs       << 'test'
   t.test_files = FileList['test/*_test.rb']
-  t.verbose = true
+  t.verbose    = true
 end
 
 Rake::RDocTask.new do |rdoc|
@@ -46,5 +24,12 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.add ['README.rdoc', 'COPYING', 'lib/**/*.rb']
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
+desc "Build the gem"
+task :build do
+  system "gem build m9t.gemspec"
+end
+ 
+desc "Publish a new version of the gem"
+task :release => :build do
+  system "gem push m9t-#{M9t::VERSION}"
 end

data/lib/m9t.rb

@@ -27,6 +27,7 @@ require 'i18n'
 
 locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'locales'))
 I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
+I18n.reload!
 
 Dir[File.dirname(__FILE__) + '/m9t/*.rb'].each do |file|
   require file
@@ -34,14 +35,6 @@ end
 
 module M9t
 
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY = 12
- 
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-
   # Base class for all M9t exceptions
   class M9tError < StandardError
   end

data/lib/m9t/base.rb

@@ -6,10 +6,49 @@ module M9t
 
   module Base
 
-    def self.add_options(klass)
+    def self.generate_conversions(klass)
+      klass.instance_eval do |klass|
+        def convert(from, to, value)
+          value * self::CONVERSIONS[from] / self::CONVERSIONS[to]
+        end
 
-      klass.instance_eval do
+        def method_missing(name, *args, &block)
+          # Define class conversion methods as required
+          if name.to_s =~ /^(\w+)_to_(\w+)$/
+            return send(name, args[0]) if define_conversion($1, $2)
+          end
+          return send(name, args[0]) if define_constructor(name)
+          raise "Method '#{ name }' unknown" # TODO use standard exception
+        end
+
+        private
+
+        def define_conversion(from, to)
+          return false if not self::CONVERSIONS[from.to_sym]
+          return false if not self::CONVERSIONS[to.to_sym]
+          self.class.instance_exec do
+            define_method("#{ from }_to_#{ to }") do |value|
+              convert(from.to_sym, to.to_sym, value)
+            end
+          end
+          true
+        end
+
+        # Define klass.unit(value) which converts the parameter
+        # from the unit and returns an instance
+        def define_constructor(name)
+          return false if not self::CONVERSIONS[name.to_sym]
+          self.class.instance_exec do
+            define_method( name.to_sym ) do | *args |
+              new( args[ 0 ].to_f * self::CONVERSIONS[ name ] )
+            end
+          end
+        end
+      end
+    end
 
+    def self.add_options(klass)
+      klass.instance_eval do
         # Make sure derived classes get the extra methods
         def inherited(sub) #:nodoc:
           sub.instance_eval do
@@ -33,43 +72,66 @@ module M9t
           name.downcase.split('::')[1]
         end
 
+        def default_unit
+          self::DEFAULT_OPTIONS[:units]
+        end
+
         reset_options!
       end
-
     end
 
     # Adds methods for handling options
     def self.included(base) #:nodoc:
       M9t::Base.add_options(base)
+      M9t::Base.generate_conversions(base)
     end
 
     attr_reader :value, :options
+    alias :to_f :value
+
+    def initialize( value )
+      @value = value.to_f
+    end
 
-    # ==== Parameters
-    # * +options+ - See individual classes for options
-    def initialize(value, options = self.class.options.clone)
-      @value, @options = value.to_f, self.class.options.merge(options)
-      units_error(@options[:units]) if not self.class::KNOWN_UNITS.find_index(@options[:units])
+    # define conversion instance methods as required
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /^to_(\w+)$/
+        return send(name, @value) if define_conversion($1)
+      end
+      raise "Method '#{ name }' unknown" # TODO use standard exception
     end
 
     # Returns the string representation of the measurement,
     # taking into account locale, desired units and abbreviation.
-    def to_s
-      value_in_units = self.class.send("to_#{ @options[:units] }", @value)
-      localized_value = I18n.localize_float(value_in_units, {:format => "%0.#{ @options[:precision] }f"})
-
-      key = 'units.' + self.class.measurement_name + '.' + @options[:units].to_s
-      @options[:abbreviated] ? key += '.abbreviated' : key += '.full'
+    def to_s( options = {} )
+      options = self.class.options.merge( options )
+      units_error( options[ :units ] ) if not self.class::CONVERSIONS.has_key?( options[ :units ] )
+      value_in_units = self.send("to_#{ options[:units] }")
+      localized_value = I18n.localize_float(value_in_units, {:format => "%0.#{ options[:precision] }f"})
+
+      key = 'units.' + self.class.measurement_name + '.' + options[:units].to_s
+      options[:abbreviated] ? key += '.abbreviated' : key += '.full'
       unit = I18n.t(key, {:count => value_in_units})
 
-      "#{ localized_value }%s#{ unit }" % (@options[:abbreviated] ? '' : ' ')
+      "#{ localized_value }%s#{ unit }" % (options[:abbreviated] ? '' : ' ')
     end
 
     private
 
     def units_error(units)
-      raise M9t::UnitError.new("Unknown units '#{ units }'. Known: #{ self.class::KNOWN_UNITS.collect{|unit| unit.to_s}.join(', ') }")
+      raise M9t::UnitError.new("Unknown units '#{ units }'. Known: #{ self.class::CONVERSIONS.keys.collect{|unit| unit.to_s}.join(', ') }")
     end
+
+    def define_conversion(to)
+      return false if not self.class::CONVERSIONS[to.to_sym]
+      self.class.instance_exec do
+        define_method("to_#{ to }") do
+          self.class.convert(self.class.default_unit, to.to_sym, self.to_f)
+        end
+      end
+      true
+    end
+
   end
 
 end

data/lib/m9t/direction.rb

@@ -7,7 +7,10 @@ module M9t
   # Represents a geographical direction
   class Direction
     DEFAULT_OPTIONS = {:units => :degrees, :abbreviated => false, :decimals => 5}
-    KNOWN_UNITS     = [:degrees, :compass]
+    CONVERSIONS          = {
+      :degrees  => 1.0,
+      :compass  => nil,
+    }
 
     # Conversions
     CIRCLE                 = 360.0
@@ -17,18 +20,17 @@ module M9t
 
     class << self
 
-      # Identity conversion. Simply returns the supplied number
-      def to_degrees(degrees)
-        degrees.to_f
-      end
-
       # Given a value in degrees, returns the nearest (localized) compass direction
       #  M9t::Directions.to_compass(42) => 'NE'
-      def to_compass(degrees)
+      def degrees_to_compass(degrees)
         sector = (normalize(degrees) / COMPASS_SECTOR_DEGREES).round
         I18n.t(self.measurement_name + '.sectors')[sector]
       end
 
+      def compass_to_degrees(compass_direction)
+        compass(compass_direction).to_f
+      end
+
       # Accepts a localized compass direction (e.g. 'N') and returns the equivalent M9t::Direction
       #  M9t::Direction.compass('NE') => #<M9t::Direction:0xb76cc750 @value=45.0, @options={:units=>:degrees, :decimals=>5, :abbreviated=>false}>
       def compass(compass_direction)
@@ -53,14 +55,18 @@ module M9t
     end
 
     # Handles the special case where compass directions are the desired output.
-    def to_s
-      if @options[:units] == :compass
-        Direction.to_compass(@value)
+    def to_s( options = {} )
+      if options[:units] == :compass
+        Direction.degrees_to_compass(@value)
       else
         super
       end
     end
 
+    def to_compass
+      self.class.degrees_to_compass(@value)
+    end
+
   end
 
 end

data/lib/m9t/distance.rb

@@ -8,76 +8,17 @@ module M9t
   # Represents a distance
   class Distance
     DEFAULT_OPTIONS      = {:units => :meters, :abbreviated => false, :precision => 5}
-    KNOWN_UNITS          = [:meters, :kilometers, :feet, :miles]
-
-    # Conversions
-    KILOMETER = 1000.0
-    MILE      = 1609.344
-    FOOT      = 0.3048
+    CONVERSIONS          = {
+      :meters     => 1.0,
+      :kilometers => 1000.0,
+      :feet       => 0.3048,
+      :miles      => 1609.344
+    }
 
     include M9t::Base
 
-    class << self
-
-      # Alias for new
-      def meters(*args)
-        new(*args)
-      end
-
-      # Accepts a value in kilometers and returns the equivalent M9t::Distance
-      def kilometers(km, options = {})
-        new(km.to_f * KILOMETER, options)
-      end
-
-      # Accepts a value in miles and returns the equivalent M9t::Distance
-      def miles(miles, options = {})
-        new(miles.to_f * MILE, options)
-      end
-
-      # Accepts a value in miles and returns the equivalent M9t::Distance
-      def feet(feet, options = {})
-        new(feet.to_f * FOOT, options)
-      end
-
-      # Identity conversion. Simply returns the supplied number
-      def to_meters(meters)
-        meters.to_f
-      end
-
-      # Converts meters into kilometers
-      def to_kilometers(meters)
-        meters.to_f / KILOMETER
-      end
-
-      # Converts meters into miles
-      def to_miles(meters)
-        meters.to_f / MILE
-      end
-
-      # Converts meters into miles
-      def to_feet(meters)
-        meters.to_f / FOOT
-      end
-
-    end
-
     alias :to_meters :value
 
-    # Returns the value converted to kilometers
-    def to_kilometers
-      self.class.to_kilometers(@value)
-    end
-
-    # Returns the value converted to miles
-    def to_miles
-      self.class.to_miles(@value)
-    end
-
-    # Returns the value converted to feet
-    def to_feet
-      self.class.to_feet(@value)
-    end
-
   end
 
 end

data/lib/m9t/pressure.rb

@@ -8,40 +8,16 @@ module M9t
   # Represents atmospheric (or other) pressure
   class Pressure
     DEFAULT_OPTIONS  = {:units => :bar, :abbreviated => false, :precision => 5}
-    KNOWN_UNITS      = [:bar, :pascals, :hectopascals, :kilopascals, :inches_of_mercury]
-
-    # Conversions
-    PASCAL          = 0.00001
-    HECTOPASCAL     = 100.0 * PASCAL
-    KILOPASCAL      = 1000.0 * PASCAL
-    INCH_OF_MERCURY = 3386.389 * PASCAL
+    CONVERSIONS          = {
+      :bar               => 1.0,
+      :pascals           => 0.00001,
+      :hectopascals      => 0.001,
+      :kilopascals       => 0.01,
+      :inches_of_mercury => 3386.389 * 0.00001
+    }
 
     include M9t::Base
 
-    def Pressure.hectopascals(hectopascals)
-      new(hectopascals * HECTOPASCAL)
-    end
-
-    def Pressure.inches_of_mercury(inches_of_mercury)
-      new(inches_of_mercury * INCH_OF_MERCURY)
-    end
-
-    def Pressure.to_inches_of_mercury(bar)
-      bar / INCH_OF_MERCURY
-    end
-
-    def Pressure.to_bar(bar)
-      bar.to_f
-    end
-
-    def to_inches_of_mercury
-      Pressure.to_inches_of_mercury(@value)
-    end
-
-    def to_bar
-      Pressure.to_bar(@value)
-    end
-
   end
 
 end

data/lib/m9t/speed.rb

@@ -8,88 +8,22 @@ module M9t
   # Represents a speed
   class Speed
     DEFAULT_OPTIONS = {:units => :meters_per_second, :abbreviated => false, :precision => 5}
-    KNOWN_UNITS     = [:meters_per_second, :kilometers_per_hour, :miles_per_hour, :knots]
-
-    # Conversions
     SECONDS_PER_HOUR  = 60.0 * 60
-    MS_TO_KMH         = SECONDS_PER_HOUR / M9t::Distance::KILOMETER
-    MS_TO_MPH         = SECONDS_PER_HOUR / M9t::Distance::MILE
+    KMH               = M9t::Distance::CONVERSIONS[:kilometers] / SECONDS_PER_HOUR
+    MPH               = M9t::Distance::CONVERSIONS[:miles] / SECONDS_PER_HOUR
     KNOTS_TO_KMH      = 1.852
-    MS_TO_KNOTS       = 1.0 / (KNOTS_TO_KMH / SECONDS_PER_HOUR * M9t::Distance::KILOMETER)
+    KNOTS             = KNOTS_TO_KMH / SECONDS_PER_HOUR * M9t::Distance::CONVERSIONS[:kilometers]
+    CONVERSIONS = {
+      :meters_per_second   => 1.0,
+      :kilometers_per_hour => KMH,
+      :miles_per_hour      => MPH,
+      :knots               => KNOTS
+    }
 
     include M9t::Base
 
-    class << self
-
-      # Accepts kilometers per hour and returns a M9t::Speed instance
-      def kilometers_per_hour(kmh, options = {})
-        new(kmh.to_f / MS_TO_KMH, options)
-      end
-
-      # Accepts miles per hour and returns a M9t::Speed instance
-      def miles_per_hour(mph, options = {})
-        new(mph.to_f / MS_TO_MPH, options)
-      end
-
-      # Accepts knots and returns a M9t::Speed instance
-      def knots(knots, options = {})
-        new(knots.to_f / MS_TO_KNOTS, options)
-      end
-
-      # Alias for new
-      def meters_per_second(*args)
-        new(*args)
-      end
-
-      # Identity conversion. Simply returns the supplied number
-      def to_meters_per_second(mps)
-        mps.to_f
-      end
-
-      # Converts meters per second to kilometers per hour
-      def to_kilometers_per_hour(mps)
-        mps.to_f * MS_TO_KMH
-      end
-
-      # Converts meters per second to miles per hour
-      def to_miles_per_hour(mps)
-        mps.to_f * MS_TO_MPH
-      end
-
-      # Converts meters per second to knots
-      def to_knots(mps)
-        mps.to_f * MS_TO_KNOTS
-      end
-
-      # Converts knots to kilometers hour
-      def knots_to_kilometers_per_hour(knots)
-        to_kilometers_per_hour(knots.to_f / MS_TO_KNOTS)
-      end
-
-      # Converts knots to kilometers hour
-      def kilometers_per_hour_to_knots(knh)
-        to_knots(kmh.to_f / MS_TO_KMH)
-      end
-
-    end
-
     alias :to_meters_per_second :value
 
-    # Returns the value converted to kilometers per hour
-    def to_kilometers_per_hour
-      self.class.to_kilometers_per_hour(@value)
-    end
-
-    # Returns the value converted to miles per hour
-    def to_miles_per_hour
-      self.class.to_miles_per_hour(@value)
-    end
-
-    # Returns the value converted to miles per hour
-    def to_knots
-      self.class.to_knots(@value)
-    end
-
   end
 
 end

data/lib/m9t/temperature.rb

@@ -9,7 +9,11 @@ module M9t
   # Using degrees (celcius), not kelvin, as default unit
   class Temperature
     DEFAULT_OPTIONS      = {:units => :degrees, :abbreviated => false, :precision => 5}
-    KNOWN_UNITS          = [:degrees, :kelvin, :fahrenheit]
+    CONVERSIONS          = {
+      :degrees   => 1.0,
+      :kelvin    => nil,
+      :fahrenheit => nil
+    }
 
     # Conversions
     ABSOLUTE_ZERO = -273.15
@@ -18,23 +22,13 @@ module M9t
 
     class << self
 
-      # Alias for new
-      def degrees(*args)
-        new(*args)
-      end
-
       # Accepts a value in kelvin and returns the equivalent M9t::Temperature
-      def kelvin(kelvin, options = {})
-        new(kelvin.to_f + ABSOLUTE_ZERO, options)
-      end
-
-      def fahrenheit(fahrenheit, options = {})
-        new(fahrenheit_to_degrees(fahrenheit), options)
+      def kelvin( kelvin )
+        new( kelvin.to_f + ABSOLUTE_ZERO )
       end
 
-      # Identity conversion. Simply returns the supplied number
-      def to_degrees(degrees)
-        degrees.to_f
+      def fahrenheit( fahrenheit )
+        new( fahrenheit_to_degrees( fahrenheit ) )
       end
 
       # Converts degrees to kelvin

data/lib/m9t/version.rb

@@ -0,0 +1,11 @@
+module M9t
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 1
+ 
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+end

data/test/direction_test.rb

@@ -43,16 +43,16 @@ class TestM9tDirection < Test::Unit::TestCase
   end
 
   def test_to_degrees_identity
-    assert_equal(45, M9t::Direction.to_degrees(45))
+    assert_equal(45, M9t::Direction.degrees_to_degrees(45))
   end
 
-  def test_to_compass
-    assert_equal('N', M9t::Direction.to_compass(0))
-    assert_equal('NE', M9t::Direction.to_compass(42)) # Quantizing up
-    assert_equal('E', M9t::Direction.to_compass(93)) # Quantizing down
-    assert_equal('ESE', M9t::Direction.to_compass(113)) # 16ths
+  def test_degrees_to_compass
+    assert_equal('N', M9t::Direction.degrees_to_compass(0))
+    assert_equal('NE', M9t::Direction.degrees_to_compass(42)) # Quantizing up
+    assert_equal('E', M9t::Direction.degrees_to_compass(93)) # Quantizing down
+    assert_equal('ESE', M9t::Direction.degrees_to_compass(113)) # 16ths
     I18n.locale = :it
-    assert_equal('O', M9t::Direction.to_compass(270))
+    assert_equal('O', M9t::Direction.degrees_to_compass(270))
   end
 
   def test_compass
@@ -60,32 +60,40 @@ class TestM9tDirection < Test::Unit::TestCase
     assert_equal(247.5, M9t::Direction.compass('WSW').value)
   end
 
-  # Instance methods
-
-  def test_unknown_units
-    assert_raises(M9t::UnitError) { M9t::Direction.new(10, {:units => :foos}) }
+  def test_compass_to_degrees
+    assert_equal(247.5, M9t::Direction.compass_to_degrees('WSW'))
   end
 
+  # Instance methods
+
   def test_to_s_not_abbreviated_singular
-    assert_equal '1 degree', M9t::Direction.new(1).to_s
+    direction = M9t::Direction.new( 1 )
+
+    assert_equal '1 degree', direction.to_s
     I18n.locale = :it
-    assert_equal '1 grado', M9t::Direction.new(1).to_s
+    assert_equal '1 grado', direction.to_s
   end
 
   def test_to_s_not_abbreviated_plural
-    assert_equal '135 degrees', M9t::Direction.new(135).to_s
+    direction = M9t::Direction.new( 135 )
+
+    assert_equal '135 degrees', direction.to_s
     I18n.locale = :it
-    assert_equal '135 gradi', M9t::Direction.new(135).to_s
+    assert_equal '135 gradi', direction.to_s
   end
 
   def test_to_s_abbreviated
-    assert_equal '135°', M9t::Direction.new(135, {:abbreviated => true}).to_s
+    direction = M9t::Direction.new( 135 )
+
+    assert_equal '135°', direction.to_s( :abbreviated => true )
   end
 
   def test_compass_units
-    assert_equal 'SW', M9t::Direction.new(225, {:units => :compass}).to_s
+    direction = M9t::Direction.new( 225 )
+
+    assert_equal 'SW', direction.to_s( :units => :compass )
     I18n.locale = :it
-    assert_equal 'SO', M9t::Direction.new(225, {:units => :compass}).to_s
+    assert_equal 'SO', direction.to_s( :units => :compass )
   end
 
   def test_handles_string_leading_zero

data/test/distance_test.rb

@@ -14,17 +14,19 @@ class TestM9tDistance < Test::Unit::TestCase
 
   # Basic use
   def test_singular
-    distance = M9t::Distance.new(1, :precision => 0)
+    distance = M9t::Distance.new( 1 )
     I18n.locale = :en
-    assert_equal('1 meter', distance.to_s)
+
+    assert_equal('1 meter', distance.to_s( :precision => 0 ) )
   end
 
   def test_plural
-    distance = M9t::Distance.new(10, :precision => 0)
+    distance = M9t::Distance.new( 10 )
+
     I18n.locale = :en
-    assert_equal('10 meters', distance.to_s)
+    assert_equal( '10 meters', distance.to_s( :precision => 0 ) )
     I18n.locale = :it
-    assert_equal('10 metri', distance.to_s)
+    assert_equal( '10 metri', distance.to_s( :precision => 0 ) )
   end
 
   # Class methods
@@ -35,24 +37,38 @@ class TestM9tDistance < Test::Unit::TestCase
     assert_equal('distance', M9t::Distance.measurement_name)
   end
 
-  # Conversion from non-SI units
-  def test_kilometers
-    assert_equal(300.0, M9t::Distance.kilometers(0.3).value)
+  # Construction
+  # ...from meters
+  def test_new
+    assert_equal(0.3, M9t::Distance.new(0.3).to_f)
+  end
+
+  def test_class_meters
+    assert_equal(0.3, M9t::Distance.meters(0.3).to_f)
   end
 
-  def test_miles
-    assert_equal(0.3 * 1609.344, M9t::Distance.miles(0.3).value)
+  # ...from other units
+  def test_class_kilometers
+    assert_in_delta(300.0, M9t::Distance.kilometers(0.3).to_f, 0.00001)
   end
 
-  # Conversion to non-SI units
-  def test_class_to_meters
-    assert_equal(0.3, M9t::Distance.to_meters(0.3))
+  def test_class_miles
+    assert_in_delta(1609.344, M9t::Distance.miles(1).to_f, 0.00001)
+    assert_in_delta(42194.988, M9t::Distance.miles(26.21875).to_f, 0.00001)
   end
 
-  def test_class_to_kilometers
-    assert_equal(0.0003, M9t::Distance.to_kilometers(0.3))
+  # Conversion class methods
+  # ...to other units
+  def test_class_meters_to_kilometers
+    assert_equal(0.0003, M9t::Distance.meters_to_kilometers(0.3))
   end
 
+  def test_class_miles_to_kilometers
+    assert_in_delta(42.194988, M9t::Distance.miles_to_kilometers(26.21875), 0.00001)
+  end
+
+  # Default options
+
   def test_default_options_set
     assert_not_nil(M9t::Distance.options)
   end
@@ -71,30 +87,20 @@ class TestM9tDistance < Test::Unit::TestCase
 
   # Instance methods
 
-  def test_new
-    assert_equal(0.3, M9t::Distance.new(0.3).value)
-  end
-
-  def test_default_options_merged
-    distance = M9t::Distance.new(10, {:abbreviated => true})
-    assert_equal(:meters, distance.options[:units])
-    assert_equal(5, distance.options[:precision])
-  end
-
-  def test_set_default_options_get_inherited
-    M9t::Distance.options[:precision] = 0
-    distance = M9t::Distance.new(10)
-    assert_equal(0, distance.options[:precision])
-  end
-
-  def test_to_meters
+  # Conversion
+  def test_instance_to_meters
     assert_equal(0.3, M9t::Distance.new(0.3).to_meters)
   end
 
-  def test_to_kilometers
+  def test_instance_to_kilometers
     assert_equal(0.0003, M9t::Distance.new(0.3).to_kilometers)
   end
 
+  def test_instance_to_kilometers
+    assert_in_delta(0.98425, M9t::Distance.new(0.3).to_feet, 0.00001)
+  end
+
+  # to_s
   def test_to_s_singular
     assert_equal('1.00000 meter', M9t::Distance.new(1).to_s)
   end
@@ -103,40 +109,56 @@ class TestM9tDistance < Test::Unit::TestCase
     assert_equal('0.30000 meters', M9t::Distance.new(0.3).to_s)
   end
 
+  # i18n
   def test_to_s_plural_abbreviated
-    distance = M9t::Distance.new(10, {:abbreviated => true, :precision => 0})
+    distance = M9t::Distance.new( 10 )
     I18n.locale = :en
-    assert_equal('10m', distance.to_s)
+    assert_equal( '10m', distance.to_s( :abbreviated => true,
+                                        :precision   => 0 ) )
     I18n.locale = :it
-    assert_equal('10m', distance.to_s)
+    assert_equal( '10m', distance.to_s( :abbreviated => true,
+                                        :precision   => 0 ) )
   end
 
   def test_to_s_abbreviated
-    assert_equal('0.30000m', M9t::Distance.new(0.3, {:abbreviated => true}).to_s)
+    distance = M9t::Distance.new( 0.3 )
+
+    assert_equal( '0.30000m', distance.to_s( :abbreviated => true ) )
   end
 
   def test_to_s_precision
-    assert_equal('0.3m', M9t::Distance.new(0.3, {:precision => 1, :abbreviated => true}).to_s)
+    distance = M9t::Distance.new( 0.3 )
+
+    assert_equal( '0.3m', distance.to_s( :precision   => 1,
+                                         :abbreviated => true ) )
   end
 
   def test_to_s_kilometers
-    assert_equal('156.0 kilometers', M9t::Distance.new(156003, {:precision => 1, :units => :kilometers}).to_s)
+    distance = M9t::Distance.new( 156003 )
+
+    assert_equal( '156.0 kilometers', distance.to_s( :precision => 1,
+                                                     :units     => :kilometers ) )
   end
 
   def test_miles_singular
-    distance = M9t::Distance.miles(1, {:units => :miles, :precision => 0})
+    marathon = M9t::Distance.miles( 26.21875 )
     I18n.locale = :en
-    assert_equal(distance.to_s, '1 mile')
+    assert_equal( '26 miles', marathon.to_s( :units     => :miles,
+                                             :precision => 0 ) )
     I18n.locale = :it
-    assert_equal(distance.to_s, '1 miglio')
+    assert_equal( '26 miglia', marathon.to_s( :units     => :miles,
+                                              :precision => 0 ) )
   end
 
   def test_to_s_miles_plural
-    distance = M9t::Distance.new(10000, {:units => :miles, :precision => 1})
+    ten_km = M9t::Distance.new( 10000 )
+
     I18n.locale = :en
-    assert_equal('6.2 miles', distance.to_s)
+    assert_equal( '6.2 miles', ten_km.to_s( :units     => :miles,
+                                            :precision => 1 ) )
     I18n.locale = :it
-    assert_equal('6,2 miglia', distance.to_s)
+    assert_equal( '6,2 miglia', ten_km.to_s( :units     => :miles,
+                                             :precision => 1 ) )
   end
 
 end

data/test/speed_test.rb

@@ -28,7 +28,7 @@ class TestM9tSpeed < Test::Unit::TestCase
   # conversion constants
 
   def test_knot_conversion
-    assert_in_delta(1.9438, M9t::Speed::MS_TO_KNOTS, 0.0001)
+    assert_in_delta(0.51444, M9t::Speed::KNOTS, 0.0001)
   end
 
   # input conversions
@@ -48,7 +48,7 @@ class TestM9tSpeed < Test::Unit::TestCase
   # output conversions
 
   def test_class_to_miles_per_hour
-    assert_in_delta(100.6621, M9t::Speed.to_miles_per_hour(45), 0.0001)
+    assert_in_delta(100.6621, M9t::Speed.meters_per_second_to_miles_per_hour(45), 0.0001)
   end
 
   # Instance methods
@@ -56,7 +56,11 @@ class TestM9tSpeed < Test::Unit::TestCase
   # new
 
   def test_unknown_units
-    assert_raises(M9t::UnitError) { M9t::Speed.new('010', {:units => :foos}) }
+    speed = M9t::Speed.new( '010' )
+
+    assert_raises( M9t::UnitError ) do
+      speed.to_s( :units => :foos )
+    end
   end
 
   # output conversions
@@ -78,17 +82,26 @@ class TestM9tSpeed < Test::Unit::TestCase
   end
 
   def test_to_s_precision
-    assert_equal '135 meters per second', M9t::Speed.new(135, :precision => 0).to_s
+    speed = M9t::Speed.new( 135 )
+
+    assert_equal '135 meters per second', speed.to_s( :precision => 0 )
   end
 
   def test_to_s_abbreviated
-    assert_equal '135m/s', M9t::Speed.new(135, :abbreviated => true, :precision => 0).to_s
+    speed = M9t::Speed.new( 135 )
+
+    assert_equal '135m/s', speed.to_s( :abbreviated => true,
+                                       :precision   => 0 )
   end
 
   def test_to_s_knots
-    assert_equal '262 knots', M9t::Speed.new(135, {:units => :knots, :precision => 0}).to_s
+    speed = M9t::Speed.new( 135 )
+
+    assert_equal '262 knots', speed.to_s( :units     => :knots,
+                                          :precision => 0 )
     I18n.locale = :it
-    assert_equal '262 nodi', M9t::Speed.new(135, {:units => :knots, :precision => 0}).to_s
+    assert_equal '262 nodi',  speed.to_s( :units     => :knots,
+                                          :precision => 0 )
   end
 
 end

data/test/temperature_test.rb

@@ -56,7 +56,11 @@ class TestM9tTemperature < Test::Unit::TestCase
   # new
 
   def test_unknown_units
-    assert_raises(M9t::UnitError) { M9t::Temperature.new(1, {:units => :foos}) }
+    temperature = M9t::Temperature.new( 1 )
+
+    assert_raises( M9t::UnitError ) do 
+      temperature.to_s( :units => :foos )
+    end
   end
 
   # output conversions
@@ -78,18 +82,29 @@ class TestM9tTemperature < Test::Unit::TestCase
   end
 
   def test_to_s_precision
-    assert_equal '135 degrees', M9t::Temperature.new(135, :precision => 0).to_s
+    temperature = M9t::Temperature.new( 135 )
+
+    assert_equal '135 degrees', temperature.to_s( :precision => 0 )
   end
 
   def test_to_s_abbreviated
-    assert_equal '135°C', M9t::Temperature.new(135, :abbreviated => true, :precision => 0).to_s
-    assert_equal '408.15K', M9t::Temperature.new(135, :units => :kelvin, :abbreviated => true, :precision => 2).to_s
+    temperature = M9t::Temperature.new( 135 )
+
+    assert_equal '135°C',   temperature.to_s( :abbreviated => true,
+                                              :precision   => 0 )
+    assert_equal '408.15K', temperature.to_s( :units       => :kelvin,
+                                              :abbreviated => true,
+                                              :precision   => 2 )
   end
 
   def test_to_s_kelvin
-    assert_equal '373.15 kelvin', M9t::Temperature.new(100, :units => :kelvin, :precision => 2).to_s
+    temperature = M9t::Temperature.new( 100 )
+
+    assert_equal '373.15 kelvin', temperature.to_s( :units     => :kelvin,
+                                                    :precision => 2 )
     I18n.locale = :it
-    assert_equal '373,15 kelvin', M9t::Temperature.new(100, :units => :kelvin, :precision => 2).to_s
+    assert_equal '373,15 kelvin', temperature.to_s( :units     => :kelvin,
+                                                    :precision => 2 )
   end
 
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: m9t
 version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 12
-  version: 0.1.12
+  version: 0.2.1
 platform: ruby
 authors: 
 - Joe Yates
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 +01:00
+date: 2011-04-04 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: i18n
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 25
         segments: 
         - 0
         - 3
@@ -37,62 +40,61 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
-- COPYING
+extra_rdoc_files: []
+
 files: 
 - README.rdoc
 - COPYING
 - Rakefile
-- lib/m9t.rb
-- lib/m9t/pressure.rb
-- lib/m9t/speed.rb
 - lib/m9t/base.rb
 - lib/m9t/direction.rb
 - lib/m9t/distance.rb
 - lib/m9t/i18n.rb
+- lib/m9t/pressure.rb
+- lib/m9t/speed.rb
 - lib/m9t/temperature.rb
-- test/pressure_test.rb
+- lib/m9t/version.rb
+- lib/m9t.rb
 - test/direction_test.rb
-- test/i18n_test.rb
 - test/distance_test.rb
+- test/i18n_test.rb
+- test/pressure_test.rb
+- test/speed_test.rb
 - test/temperature_test.rb
 - test/test_all.rb
-- test/speed_test.rb
-- locales/it.yml
 - locales/en.yml
+- locales/it.yml
 has_rdoc: true
 homepage: http://github.com/joeyates/m9t
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --quiet
-- --title
-- "m9t: Measurement units"
-- --main
-- README.rdoc
-- --inline-source
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.6
+rubyforge_project: nowarning
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Classes for handling measurement units