m9t 0.1.0

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Joe Yates
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,21 @@
+== m9t - Various units of measurement
+
+This package aims to handle the basic units of measure:
+* Distance
+* Temperature
+* Direction
+* Speed
+
+The emphasis is on:
+* coherent interface
+* ease of translation
+
+== Other Software
+
+* ruby-units
+  * doesn't handle i18n - very difficult to integrate
+  * monkey patches a lot of core classes
+
+== License
+
+MIT License. See the included COPYING file.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/clean'
+
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'm9t'
+
+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']
+  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.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.options  += RDOC_OPTS
+  rdoc.main     = 'README.rdoc'
+  rdoc.rdoc_files.add ['README.rdoc', 'COPYING', 'lib/**/*.rb']
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end

data/lib/m9t.rb

@@ -0,0 +1,51 @@
+#--
+# Copyright (c) 2010 Joe Yates
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+
+locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'locales'))
+I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
+
+Dir[File.dirname(__FILE__) + '/m9t/*.rb'].each do |file|
+  require file
+end
+
+module M9t
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY = 0
+ 
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+  class M9tError < StandardError
+  end
+
+  class UnitError < M9tError
+  end
+
+end

data/lib/m9t/base.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+
+module M9t
+
+  module Base
+
+    def self.included(base)
+
+      base.instance_eval do
+        # Returns the classes current options - see the specific class for defaults
+        def options
+          @options
+        end
+
+        # Reloads the class' default options
+        def reset_options!
+          @options = self::DEFAULT_OPTIONS.clone # 'self::' is necessary with ruby 1.8
+        end
+
+        # The name used for i18n translations
+        # E.g. M9t::Distance => 'distance'
+        def measurement_name
+          name.downcase.split('::')[1]
+        end
+
+        reset_options!
+      end
+
+    end
+
+    attr_reader :value, :options
+
+    def initialize(value, options = self.class.options.clone)
+      @value, @options = value.to_f, self.class.options.merge(options)
+      raise M9t::UnitError.new("Unknown units '#{ @options[:units] }'. Known: #{ self.class::KNOWN_UNITS.collect{|unit| unit.to_s}.join(', ') }") \
+        if not self.class::KNOWN_UNITS.find_index(@options[:units])
+    end
+
+    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'
+      unit = I18n.t(key, {:count => value_in_units})
+
+      "#{ localized_value }%s#{ unit }" % (@options[:abbreviated] ? '' : ' ')
+    end
+
+  end
+
+end

data/lib/m9t/direction.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+
+module M9t
+
+  class Direction
+    DEFAULT_OPTIONS = {:units => :degrees, :abbreviated => false, :decimals => 5}
+    KNOWN_UNITS     = [:degrees, :compass]
+
+    # Conversions
+    CIRCLE                 = 360.0
+    COMPASS_SECTOR_DEGREES = CIRCLE / 16.0
+
+    include M9t::Base
+
+    class << self
+
+      def to_degrees(d)
+        d
+      end
+
+      def to_compass(d)
+        sector = (normalize(d) / COMPASS_SECTOR_DEGREES).round
+        I18n.t(self.measurement_name + '.sectors')[sector]
+      end
+
+      def compass(s)
+        sector = I18n.t(self.measurement_name + '.sectors').find_index(s)
+        raise "Compass direction '#{ s }' not recognised" if sector.nil?
+        new(sector.to_f * COMPASS_SECTOR_DEGREES)
+      end
+
+      def normalize(d)
+        case
+        when d < 0
+          normalize(d + CIRCLE)
+        when d >= CIRCLE
+          normalize(d - CIRCLE)
+        else
+          d
+        end
+      end
+
+    end
+
+    def to_s
+      if @options[:units] == :compass
+        Direction.to_compass(@value)
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/m9t/distance.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'base')
+
+module M9t
+
+  class Distance
+    DEFAULT_OPTIONS      = {:units => :meters, :abbreviated => false, :precision => 5}
+    KNOWN_UNITS          = [:meters, :miles, :kilometers]
+
+    # Conversions
+    METERS_PER_MILE      = 1609.344
+    METERS_PER_KILOMETER = 1000.0
+
+    include M9t::Base
+
+    class << self
+
+      # Unit convertors: convert to meters
+      def miles(m)
+        m.to_f * METERS_PER_MILE
+      end
+
+      def kilometers(km)
+        km.to_f * METERS_PER_KILOMETER
+      end
+
+      def to_meters(m)
+        m.to_f
+      end
+
+      def to_kilometers(m)
+        m.to_f / METERS_PER_KILOMETER
+      end
+
+      def to_miles(m)
+        m.to_f / METERS_PER_MILE
+      end
+
+    end
+
+    alias :to_meters :value
+
+    def to_kilometers
+      self.class.to_kilometers(@value)
+    end
+
+    def to_miles
+      self.class.to_miles(@value)
+    end
+
+  end
+
+end

data/lib/m9t/i18n.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+
+# Monkey patch I18n, adding:
+# - handling for non-English numerical separators
+module I18n
+
+  def I18n.localize_float(f, options = {})
+    format = options[:format] || '%f'
+    s = format % f
+    integers, decimal = s.split('.')
+    integers ||= ''
+
+    thousands_separator = I18n.t('numbers.thousands_separator')
+    integers.gsub(',', thousands_separator)
+
+    return integers if decimal.nil?
+
+    decimal_separator = I18n.t('numbers.decimal_separator')
+    integers + decimal_separator + decimal
+  end
+end

data/lib/m9t/speed.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'distance')
+
+module M9t
+
+  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::METERS_PER_KILOMETER
+    MS_TO_MPH         = SECONDS_PER_HOUR / M9t::Distance::METERS_PER_MILE
+
+    include M9t::Base
+
+    class << self
+
+      # Unit convertors: convert to meters per second
+      def kilometers_per_hour(kmh)
+        kmh.to_f * MS_TO_KMH
+      end
+
+      def miles_per_hour(mph)
+        mph.to_f * MS_TO_MPH
+      end
+
+      def to_meters_per_second(mps)
+        mps.to_f
+      end
+
+      def to_kilometers_per_hour(mps)
+        mps.to_f / MS_TO_KMH
+      end
+
+      def to_miles_per_hour(mps)
+        mps.to_f / MS_TO_MPH
+      end
+
+    end
+
+    alias :to_meters_per_second :value
+
+    def to_kilometers_per_hour
+      self.class.to_kilometers_per_hour(@value)
+    end
+
+    def to_miles_per_hour
+      self.class.to_miles_per_hour(@value)
+    end
+
+  end
+
+end

data/test/direction_test.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'test/unit'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'm9t')
+
+class TestM9tDirection < Test::Unit::TestCase
+  
+  def setup
+    I18n.locale = :en
+    M9t::Direction.reset_options!
+  end
+
+  # Basic use
+  def test_degrees
+    assert_equal(45, M9t::Direction.new(45).value)
+  end
+
+  # Class methods
+
+  # Base class
+
+  def test_measurement_name
+    assert_equal('direction', M9t::Direction.measurement_name)
+  end
+
+  def test_normalize
+    assert_equal(5, M9t::Direction.normalize(725))
+    assert_equal(5, M9t::Direction.normalize(-355))
+  end
+
+  def test_default_options_set
+    assert_not_nil(M9t::Direction.options)
+  end
+
+  def test_default_option_abbreviated
+    assert(! M9t::Direction.options[:abbreviated])
+  end
+
+  def test_default_option_units
+    assert_equal(:degrees, M9t::Direction.options[:units])
+  end
+
+  def test_to_degrees_identity
+    assert_equal(45, M9t::Direction.to_degrees(45))
+  end
+
+  def test_to_compass
+    assert_equal('N', M9t::Direction.to_compass(0))
+    assert_equal('N', M9t::Direction.to_compass(7)) # Quantizing
+    assert_equal('E', M9t::Direction.to_compass(93)) # Quantizing
+    assert_equal('ESE', M9t::Direction.to_compass(113)) # 16ths
+    I18n.locale = :it
+    assert_equal('O', M9t::Direction.to_compass(270))
+  end
+
+  def test_compass
+    assert_equal(0, M9t::Direction.compass('N').value)
+    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}) }
+  end
+
+  def test_to_s_not_abbreviated_singular
+    assert_equal '1 degree', M9t::Direction.new(1).to_s
+    I18n.locale = :it
+    assert_equal '1 grado', M9t::Direction.new(1).to_s
+  end
+
+  def test_to_s_not_abbreviated_plural
+    assert_equal '135 degrees', M9t::Direction.new(135).to_s
+    I18n.locale = :it
+    assert_equal '135 gradi', M9t::Direction.new(135).to_s
+  end
+
+  def test_to_s_abbreviated
+    assert_equal '135°', M9t::Direction.new(135, {:abbreviated => true}).to_s
+  end
+
+  def test_compass_units
+    assert_equal 'SW', M9t::Direction.new(225, {:units => :compass}).to_s
+    I18n.locale = :it
+    assert_equal 'SO', M9t::Direction.new(225, {:units => :compass}).to_s
+  end
+
+  def test_handles_string_leading_zero
+    assert_equal(10, M9t::Direction.new('010').value)
+  end
+
+end

data/test/distance_test.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'test/unit'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'm9t')
+
+class TestM9tDistance < Test::Unit::TestCase
+
+  def setup
+    I18n.locale = :en
+    M9t::Distance.reset_options!
+  end
+
+  # Basic use
+  def test_singular
+    distance = M9t::Distance.new(1, :precision => 0)
+    I18n.locale = :en
+    assert_equal('1 meter', distance.to_s)
+  end
+
+  def test_plural
+    distance = M9t::Distance.new(10, :precision => 0)
+    I18n.locale = :en
+    assert_equal('10 meters', distance.to_s)
+    I18n.locale = :it
+    assert_equal('10 metri', distance.to_s)
+  end
+
+  # Class methods
+
+  # Base class
+
+  def test_unit_name
+    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))
+  end
+
+  def test_miles
+    assert_equal(0.3 * 1609.344, M9t::Distance.miles(0.3))
+  end
+
+  # Conversion to non-SI units
+  def test_class_to_meters
+    assert_equal(0.3, M9t::Distance.to_meters(0.3))
+  end
+
+  def test_class_to_kilometers
+    assert_equal(0.0003, M9t::Distance.to_kilometers(0.3))
+  end
+
+  def test_default_options_set
+    assert_not_nil(M9t::Distance.options)
+  end
+
+  def test_default_option_abbreviated
+    assert(! M9t::Distance.options[:abbreviated])
+  end
+
+  def test_default_option_units
+    assert_equal(:meters, M9t::Distance.options[:units])
+  end
+
+  def test_default_option_decimals
+    assert_equal(5, M9t::Distance.options[:precision])
+  end
+
+  # 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
+    assert_equal(0.3, M9t::Distance.new(0.3).to_meters)
+  end
+
+  def test_to_kilometers
+    assert_equal(0.0003, M9t::Distance.new(0.3).to_kilometers)
+  end
+
+  def test_to_s_singular
+    assert_equal('1.00000 meter', M9t::Distance.new(1).to_s)
+  end
+
+  def test_to_s_plural
+    assert_equal('0.30000 meters', M9t::Distance.new(0.3).to_s)
+  end
+
+  def test_to_s_plural_abbreviated
+    distance = M9t::Distance.new(10, {:abbreviated => true, :precision => 0})
+    I18n.locale = :en
+    assert_equal('10m', distance.to_s)
+    I18n.locale = :it
+    assert_equal('10m', distance.to_s)
+  end
+
+  def test_to_s_abbreviated
+    assert_equal('0.30000m', M9t::Distance.new(0.3, {:abbreviated => true}).to_s)
+  end
+
+  def test_to_s_precision
+    assert_equal('0.3m', M9t::Distance.new(0.3, {:precision => 1, :abbreviated => true}).to_s)
+  end
+
+  def test_to_s_kilometers
+    assert_equal('156.0 kilometers', M9t::Distance.new(156003, {:precision => 1, :units => :kilometers}).to_s)
+  end
+
+  def test_miles_singular
+    distance = M9t::Distance.new(M9t::Distance.miles(1), {:units => :miles, :precision => 0})
+    I18n.locale = :en
+    assert_equal(distance.to_s, '1 mile')
+    I18n.locale = :it
+    assert_equal(distance.to_s, '1 miglio')
+  end
+
+  def test_to_s_miles_plural
+    distance = M9t::Distance.new(10000, {:units => :miles, :precision => 1})
+    I18n.locale = :en
+    assert_equal('6.2 miles', distance.to_s)
+    I18n.locale = :it
+    assert_equal('6,2 miglia', distance.to_s)
+  end
+
+end

data/test/i18n_test.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'test/unit'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'm9t')
+
+class TestI18nMonkeyPatching < Test::Unit::TestCase
+  
+  def setup
+  end
+
+  def test_translations_loaded
+    I18n.locale = :en
+    assert_equal('.', I18n.t('numbers.decimal_separator'))
+    I18n.locale = :it
+    assert_equal(',', I18n.t('numbers.decimal_separator'))
+  end
+
+  def test_localize_float_default
+    assert_equal('1.500000', I18n.localize_float(1.5))
+  end
+
+  def test_localize_float_formatted
+    assert_equal('1.5', I18n.localize_float(1.5, {:format => '%0.1f'}))
+  end
+
+  def test_localize_float_italian
+    I18n.locale = :it
+    assert_equal('1,5', I18n.localize_float(1.5, {:format => '%0.1f'}))
+  end
+
+end

data/test/speed_test.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'test/unit'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'm9t')
+
+class TestM9tSpeed < Test::Unit::TestCase
+  
+  def setup
+    I18n.locale = :en
+    M9t::Speed.reset_options!
+  end
+
+  # Basic use
+  def test_new
+    assert_equal(45, M9t::Speed.new(45).value)
+  end
+
+  # Class methods
+
+  # Base class
+
+  def test_measurement_name
+    assert_equal('speed', M9t::Speed.measurement_name)
+  end
+
+  # input conversions
+
+  def test_class_miles_per_hour
+    assert_equal(45, M9t::Speed.miles_per_hour(20.1168))
+  end
+
+  # output conversions
+
+  def test_class_to_miles_per_hour
+    assert_equal(20.1168, M9t::Speed.to_miles_per_hour(45))
+  end
+
+  # Instance methods
+
+  # new
+
+  def test_unknown_units
+    assert_raises(M9t::UnitError) { M9t::Speed.new('010', {:units => :foos}) }
+  end
+
+  # output conversions
+
+  def test_kmh
+    assert_equal(12.5, M9t::Speed.new(45).to_kilometers_per_hour)
+  end
+
+  def test_mph
+    assert_equal(20.1168, M9t::Speed.new(45).to_miles_per_hour)
+  end
+
+  # to_s
+
+  def test_to_s
+    assert_equal '135.00000 meters per second', M9t::Speed.new(135).to_s
+  end
+
+  def test_to_s_precision
+    assert_equal '135 meters per second', M9t::Speed.new(135, :precision => 0).to_s
+  end
+
+  def test_to_s_abbreviated
+    assert_equal '135m/s', M9t::Speed.new(135, :abbreviated => true, :precision => 0).to_s
+  end
+
+end

data/test/test_all.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__)+'/*_test.rb'].each do |test|
+  require test
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: m9t
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joe Yates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 5
+        version: 0.3.5
+  type: :runtime
+  version_requirements: *id001
+description: Classes for handling measurement units, conversions and translations
+email: joe.g.yates@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- COPYING
+files: 
+- README.rdoc
+- COPYING
+- Rakefile
+- lib/m9t.rb
+- lib/m9t/speed.rb
+- lib/m9t/base.rb
+- lib/m9t/direction.rb
+- lib/m9t/distance.rb
+- lib/m9t/i18n.rb
+- test/direction_test.rb
+- test/i18n_test.rb
+- test/distance_test.rb
+- test/test_all.rb
+- test/speed_test.rb
+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
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Classes for handling measurement units
+test_files: 
+- test/test_all.rb