dimensional 1.1.1 → 2.0.0

data/CHANGELOG

@@ -3,4 +3,5 @@
 0.1.2	Cleanup tests to work with gem check -t.
 1.0.0	Production Release 1.
 1.0.1	Use Rationals for default values and avoid the dreaded integer division = 0 problem.
-1.1.1	Add Metric.load constructor, improve docs and enhance scanner.
+1.1.1	Add Metric.load constructor, improve docs and enhance scanner.
+2.0.0	Introduce Dimensional::Locale

data/TODO

@@ -1 +1,4 @@
-1. Fix parsing units like "6m3" for six cubic meters.
+1. Fix parsing units like "6m3" for six cubic meters.
+2. Allow locale-specific formatters and detectors.
+3. Default format per dimension/system/metric.
+4. Auto generation of metric prefix units.

data/lib/dimensional.rb

@@ -1,5 +1,6 @@
 require 'dimensional/dimension'
 require 'dimensional/system'
+require 'dimensional/locale'
 require 'dimensional/unit'
 require 'dimensional/metric'
 require 'dimensional/version'

data/lib/dimensional/locale.rb

@@ -0,0 +1,42 @@
+module Dimensional
+  # A Locale is a prioritized list of Systems per Metric.
+  # Locales solve the problem of parsing ambiguous units such as US gallons and Imperial gallons. They also allow
+  # unit systems to be prioritized for specific metrics.  For example, in the domain of aeronautics, the "international
+  # nautical mile" is used universally for distances and "knots" are used for speed.  For these metrics, an "International"
+  # system should have the highest priority when parsing ambiguous units and when formatting output.
+  class Locale
+    class << self
+      # The default locale, which is used when auto-creating locales.
+      def default
+        @default ||= self.new(:DEFAULT)
+      end
+
+      # Create a new locale and define a constant for it
+      def register(name, ss = Array.new)
+        l = new(name, ss)
+        const_set(l.to_s.to_sym, l)
+      end
+
+      # Create a new locale (using systems from the default locale) and define a constant for it
+      def const_missing(symbol)
+        register(symbol, default.systems.dup) # Copy default's systems for independence
+      end
+
+      def reset!
+        @default = nil
+        constants.each {|d| remove_const(d)}
+      end
+    end
+
+    attr_accessor :systems
+    # Locales have a prioritized list of systems and a name.
+    def initialize(name, ss = Array.new)
+      @name = name
+      @systems = ss
+    end
+
+    def to_s
+      @name.to_s
+    end
+  end
+end

data/lib/dimensional/metric.rb

@@ -8,21 +8,25 @@ module Dimensional
     # A Measure string is composed of a number followed by a unit separated by optional whitespace.
     # A unit (optional) is composed of a non-digit character followed by zero or more word characters and terminated by some stuff.
     # Scientific notation is not currently supported.
+    # TODO: Move this to a locale
     NUMERIC_REGEXP = /((?=\d|\.\d)\d*(?:\.\d*)?)\s*(\D.*?)?\s*(?=\d|$)/
 
     class << self
-      attr_accessor :dimension, :base, :default
+      attr_accessor :dimension, :base, :default, :universal_systems
 
-      # The units applicable to this metric in priority order (highest priority first)
+      # The units of this metric, grouped by system.
       def units
-        @units ||= Unit.select{|u| u.dimension == dimension}.sort_by{|u| configuration[u][:preference]}.reverse
+        @units ||= Hash.new([]).merge(Unit.select{|u| u.dimension == dimension}.group_by{|u| u.system})
       end
 
-      # Find the unit matching the given string, preferring units in the given system
-      def find_unit(str, system = nil)
-        system = System[system] unless system.kind_of?(System)
-        us = self.units.select{|u| configuration[u][:detector].match(str.to_s)}
-        us.detect{|u| u.system == system} || us.first
+      def systems(locale)
+        locale.systems.dup.unshift(*(universal_systems || [])).uniq
+      end
+
+      # Find the unit matching the given string, preferring units in the given locale
+      def find_unit(str, locale = Locale.default)
+        us = systems(locale).inject([]){|us, system| us + units[system].sort_by{|u| configuration[u][:preference]}.reverse}
+        us.detect{|u| configuration[u][:detector].match(str.to_s)}
       end
 
       def configuration
@@ -35,19 +39,16 @@ module Dimensional
         @dimension ||= unit.dimension
         @base ||= unit
         @default ||= unit
-        @units = nil
         raise "Unit #{unit} is not compatible with dimension #{dimension || '<nil>'}." unless unit.dimension == dimension
         configuration[unit] = {:detector => unit.detector, :format => unit.format, :preference => unit.preference * 1.01}.merge(options)
       end
 
-      # Parse a string into a Metric instance. Providing a unit system (or associated symbol) will prefer the units from that system.
+      # Parse a string into a Metric instance. Providing a locale will help resolve ambiguities.
       # Unrecognized strings return nil.
-      def parse(str, system = nil)
-        system = System[system] unless system.kind_of?(System)
+      def parse(str, locale = Locale.default)
         elements = str.to_s.scan(NUMERIC_REGEXP).map do |(v, us)|
-          unit = us.nil? ? default : find_unit(us, system)
+          unit = us.nil? ? default : find_unit(us, locale)
           raise ArgumentError, "Unit cannot be determined (#{us})" unless unit
-          system = unit.system # Set the system to restrict subsequent filtering
           value = Integer(v) rescue Float(v)
           new(value, unit)
         end
@@ -60,12 +61,16 @@ module Dimensional
         end
       end
 
-      # Sort units by "best" fit for the desired order of magnitude.  Preference values offset OOM differences.
-      def best_fit(target_oom)
-        units.sort_by do |u|
-          oom_delta = (Math.log10(u.factor) - target_oom).abs
-          configuration[u][:preference] - oom_delta
+      # Sort units by "best" fit for the desired order of magnitude.  Preference values offset OOM differences.  There is
+      # a bias in favor of negative OOM differences (humans like 6" more than 0.5ft).
+      def best_fit(target_oom, system)
+        us = units[system]
+        us = us.sort_by do |u|
+          oom_delta = Math.log10(u.factor) - target_oom
+          avoid_fraction_bonus = (oom_delta > 0.0 ? 0 : 1.5)
+          (configuration[u][:preference] - oom_delta.abs) + avoid_fraction_bonus 
         end
+        us.last
       end
 
       # Create a new instance with the given value (assumed to be in the base unit) and convert it to the preferred unit.
@@ -75,7 +80,7 @@ module Dimensional
     end
 
     attr_reader :unit
-    def initialize(value, unit = self.class.default)
+    def initialize(value, unit = self.class.default || self.class.base)
       raise ArgumentError, "No default unit set" unless unit
       @unit = unit
       super(value)
@@ -87,20 +92,23 @@ module Dimensional
       self.class.new(new_value, new_unit)
     end
 
-    # Convert this metric to the "most appropriate" unit in the given system.  A similar order-of-magnitude for the result is preferred.
+    # Convert into the "most appropriate" unit in the given system.  A similar order-of-magnitude for the result is preferred.
     def change_system(system)
       system = System[system] unless system.kind_of?(System)
       target_oom = Math.log10(self.unit.factor)
-      bu = self.class.best_fit(target_oom).select{|u| u.system == system}.last
+      bu = self.class.best_fit(target_oom, system)
       convert(bu)
     end
 
-    # Convert this metric to the "most appropriate" unit in the current system.  A resulting order of magnitude close to zero is preferred.
-    def preferred
+    # Convert into the best unit for the given Locale.  The first system of the given locale with units is elected the preferred system,
+    # and within the preferred system, preference is given to units yielding a metric whose order of magnitude is close to zero.
+    def localize(locale = Locale.default)
       target_oom = Math.log10(self) + Math.log10(self.unit.factor)
-      bu = self.class.best_fit(target_oom).select{|u| u.system == unit.system}.last
+      preferred_system = self.class.systems(locale).detect{ |s| self.class.units[s].any? }
+      bu = self.class.best_fit(target_oom, preferred_system)
       convert(bu)
     end
+    alias preferred localize
 
     # Return a new metric expressed in the base unit
     def base

data/lib/dimensional/system.rb

@@ -15,13 +15,15 @@ module Dimensional
       const_set(s.abbreviation, s) rescue nil # Not all symbols strings are valid constant names
       s
     end
-    
+
     # Lookup the system by name or abbreviation
     def self.[](sym)
-      return nil unless sym = sym && sym.to_sym
-      @abbreviation_registry[sym] || @registry[sym]
+      sym = sym && sym.to_sym
+      s = @abbreviation_registry[sym] || @registry[sym]
+      raise "Unknown system #{sym.to_s}" unless s
+      s
     end
-    
+
     # Purge all systems from storage.
     def self.reset!
       constants.each {|d| remove_const(d)}

data/lib/dimensional/unit.rb

@@ -52,7 +52,7 @@ module Dimensional
       @reference_units = options[:reference_units] || {}
       @abbreviation = options[:abbreviation]
       @detector = options[:detector] || /\A#{[name, abbreviation].compact.join('|')}\Z/
-      @format = options[:format] || dimension.nil? ? "%s %U" : "%s%U"
+      @format = options[:format] || "%s %U"
       @preference = options[:preference] || 0
       validate
     end

data/lib/dimensional/version.rb

@@ -1,3 +1,3 @@
 module Dimensional
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

data/test/demo.rb

@@ -17,6 +17,7 @@ Dimension.register('Volume', 'V', {Dimension::L => 3})
 Dimension.register('Velocity', 'Vel', {Dimension::L => 1, Dimension::T => -1})
 Dimension.register('Acceleration', 'Acc', {Dimension::L => 1, Dimension::T => -2})
 Dimension.register('Force', 'F', {Dimension::M => 1, Dimension::L => 1, Dimension::T => -2})
+Dimension.register('Pressure', 'Press', {Dimension::M => 1, Dimension::L => -1, Dimension::T => -2})
 Dimension.register('Torque', 'τ', {Dimension::M => 1, Dimension::L => 2, Dimension::T => -2}) # equivalent to Energy
 Dimension.register('Energy', 'E', {Dimension::M => 1, Dimension::L => 2, Dimension::T => -2}) # a.k.a. work
 Dimension.register('Power', 'P', {Dimension::M => 1, Dimension::L => 2, Dimension::T => -3})
@@ -24,23 +25,27 @@ Dimension.register('Voltage', 'emf', {Dimension::M => 1, Dimension::L => 2, Dime
 
 # Define common Systems of Measurement
 System.register('SI - International System (kg, tonne, m)', 'SI')
+System.register('Universal', 'U') # International standards not included in SI
 System.register('US Customary (lbs, ton, ft)', 'US')  # http://en.wikipedia.org/wiki/United_States_customary_units
 System.register('US Customary Troy (oz)', 'USt')  # http://en.wikipedia.org/wiki/United_States_customary_units
 System.register('British Imperial (lbs, ton, ft)', 'Imp')  # http://en.wikipedia.org/wiki/Imperial_units
 System.register('British Admiralty', 'BA')
 System.register('Foot-Pound-Second', 'FPS') #http://en.wikipedia.org/wiki/Foot-pound-second_system
+System.register('Furlong/Firkin/Fortnight', 'FFF') # http://en.wikipedia.org/wiki/FFF_System
 
 Configurator.start do
   dimension(:L) do
     system(:SI) do
       base('meter', 'm', :detector => /\A(met(er|re)s?|m)\Z/) do
-        derive('decimeter', 'dm', Rational(1, 10), :detector => /\A(decimet(er|re)s?|dm)\Z/, :preference => 0.5)
+        derive('decimeter', 'dm', Rational(1, 10), :detector => /\A(decimet(er|re)s?|dm)\Z/, :preference => -3)
         derive('centimeter', 'cm', Rational(1, 100), :detector => /\A(centimet(er|re)s?|cm)\Z/)
-        derive('decameter', 'dam', 10, :detector => /\A(de(c|k)amet(er|re)s?|dam)\Z/)
+        derive('decameter', 'dam', 10, :detector => /\A(de(c|k)amet(er|re)s?|dam)\Z/, :preference => -3)
         derive('kilometer', 'km', 1000, :detector => /\A(kilomet(er|re)s?|km)\Z/)
-        derive('nautical mile', 'M', 1852, :detector => /\A(nautical miles?|NMs?|nmis?)\Z/)
       end
     end
+    system(:U) do
+      reference('nautical mile', 'M', Dimensional::Unit[:L, :SI, 'meter'], 1852, :detector => /\A(nautical miles?|nm|nmi|M)\Z/)
+    end
     system(:US) do # As of 1 July 1959 (http://en.wikipedia.org/wiki/United_States_customary_units#Units_of_length)
       reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/) do
         derive('foot', 'ft', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/, :format => "%p'") do
@@ -84,16 +89,14 @@ Configurator.start do
   dimension(:M) do
     system(:SI) do
       base('kilogram', 'kg', :detector => /\A(kilograms?|kg)\Z/) do
-        derive('tonne', 't', 1000, :detector => /\A(tonnes?)\Z/) do # metric ton
-        end
+        derive('tonne', 't', 1000, :detector => /\A(tonnes?)\Z/) # metric ton
         derive('gram', 'g', Rational(1, 1000), :detector => /\A(grams?|g)\Z/)
       end
     end
     system(:US) do # Common units for mass and, occasionally, force/weight (http://en.wikipedia.org/wiki/United_States_customary_units#Units_of_mass)
       reference('pound', 'lb', Unit[:M, :SI, 'gram'], 453.59237, :detector => /\A(pounds?|lbs?|#)\Z/) do # avoirdupois
         derive('hundredweight', 'cwt', 100, :detector => /\A(hundredweights?|cwt)\Z/) do
-          derive('ton', 't', 20, :detector => /\A(tons?|t)\Z/) do # short ton
-          end
+          derive('ton', 't', 20, :detector => /\A(tons?|t)\Z/) # short ton
         end
         derive('ounce', 'oz', Rational(1, 16), :detector => /\A(ounces?|ozs?)\Z/)
         derive('grain', 'gr', Rational(1, 7000), :detector => /\A(grains?|gr)\Z/) do
@@ -138,13 +141,14 @@ Configurator.start do
         end
       end
       combine('square foot', 'ft2', {Unit[:L, :US, :ft] => 2}, :detector => /ft2/)
+      combine('square inch', 'in2', {Unit[:L, :US, :in] => 2}, :detector => /in2/)
     end
   end
 
   dimension(:V) do
     system(:SI) do
-      combine('cubic meter', 'm3', {Unit[:L, :SI, :meter] => 3}, :detector => /\A(cubic met(er|re)s?|m3)\Z/, :preference => 0.75) do
-        derive('cubic decimeter', 'dm3', Rational(1, 1000), :detector => /\A(cubic decimet(er|re)s?|dm3)\Z/, :preference => 0.5) do
+      combine('cubic meter', 'm3', {Unit[:L, :SI, :meter] => 3}, :detector => /\A(cubic met(er|re)s?|m3)\Z/, :preference => -2) do
+        derive('cubic decimeter', 'dm3', Rational(1, 1000), :detector => /\A(cubic decimet(er|re)s?|dm3)\Z/, :preference => -3) do
           self.alias('liter', 'l', :detector => /\A(lit(er|re)s?|l|L)\Z/) do
             derive('milliliter', 'ml', Rational(1, 1000), :detector => /\A(millilit(er|re)s?|ml|mL)\Z/)
           end
@@ -157,7 +161,7 @@ Configurator.start do
           derive('cup', 'cp', 2, :detector => /\A(cups?|cps?)\Z/) do
             derive('pint', 'pt', 2, :detector => /\A(pints?|pts?)\Z/) do
               derive('quart', 'qt', 2, :detector => /\A(quarts?|qts?)\Z/) do
-                derive('gallon', 'gal', 4, :detector => /\A(gallons?|gal)\Z/)
+                derive('gallon', 'gal', 4, :detector => /\A(gallons?|gals?)\Z/)
               end
             end
           end
@@ -166,7 +170,7 @@ Configurator.start do
     end
     system(:US) do
       combine('cubic inch', 'in3', {Unit[:L, :US, :inch] => 3}, :detector => /\A(cubic inch(es)?|in3)\Z/ ) do
-        derive('gallon', 'g', 231, :detector => /\A(gallons?|gal)\Z/) do
+        derive('gallon', 'gal', 231, :detector => /\A(gallons?|gals?)\Z/) do
           derive('quart', 'qt', Rational(1,4), :detector => /\A(quarts?|qts?)\Z/) do
             derive('pint', 'pt', Rational(1,2), :detector => /\A(pints?|pts?)\Z/) do
               derive('cup', nil, Rational(1,2), :detector => /\Acups?\Z/) do
@@ -191,7 +195,9 @@ Configurator.start do
         derive('minute', 'm', 60, :detector => /\A(minutes?|m)\Z/) do
           derive('hour', 'h', 60, :detector => /\A(hours?|h)\Z/) do
             derive('day', 'd', 24, :detector => /\A(days?)\Z/) do
-              derive('week', 'w', 7, :detector => /\A(weeks?|wks?)\Z/)
+              derive('week', 'w', 7, :detector => /\A(weeks?|wks?)\Z/) do
+                derive('fortnight', nil, 2, :detector => /\A(fortnights?)\Z/)
+              end
               derive('year', 'yr', 365 + Rational(1, 4), :detector => /\A(years?|yrs?)\Z/)
             end
           end
@@ -218,8 +224,8 @@ Configurator.start do
     system(:US) do
       combine('mile per hour', 'mph', {Unit[:L, :US, :mile] => 1, Unit[:T, :SI, :hour] => -1}, :detector => /\A(mile per hour|mph)\Z/)
     end
-    system(:BA) do
-      combine('knot', 'kt', {Unit[:L, :BA, :nm] => 1, Unit[:T, :SI, :hour] => -1}, :detector => /\A(knots?|kts?)\Z/)
+    system(:U) do
+      combine('knot', 'kt', {Unit[:L, :U, :M] => 1, Unit[:T, :SI, :hour] => -1}, :detector => /\A(knots?|kn|kts?)\Z/)
     end
   end
 
@@ -278,12 +284,20 @@ Configurator.start do
 
   dimension(:Voltage) do
     system(:SI) do
-      combine('Volt', 'V',{Unit[:P, :SI, :W] => 1, Unit[:I, :SI, :A] => -1}, :detector => /\A(volts?|V)\Z/) do
+      combine('Volt', 'V', {Unit[:P, :SI, :W] => 1, Unit[:I, :SI, :A] => -1}, :detector => /\A(volts?|V)\Z/) do
         derive('millivolt', 'mV', Rational(1, 1000))
         derive('kilovolt', 'kV', 1000)
       end
     end
   end
+  dimension(:Pressure) do
+    system(:SI) do
+      combine('pascal', 'Pa', {Unit[:F, :SI, :N] => 1, Unit[:A, :SI, :m2] => -1}, :detector => /\A(pascals?|Pa)\Z/)
+    end
+    system(:US) do
+      combine('pound per square inch', 'psi', {Unit[:F, :US, :lbf] => 1, Unit[:A, :US, :in2] => -1}, :detector => /\A(psi)\Z/)
+    end
+  end
 
   dimension(nil) do
     system(:SI) do
@@ -301,6 +315,10 @@ Configurator.start do
   end
 end
 
+Locale.default.systems = [System::SI, System::U, System::US, System::Imp]
+Locale::US.systems = [System::US, System::USt, System::U, System::SI, System::Imp]
+Locale::GB.systems = [System::Imp, System::SI, System::U, System::US]
+
 class Length < Dimensional::Metric
   self.dimension = Dimensional::Dimension::L
   self.base = Unit[:L, :SI, :m]
@@ -310,17 +328,15 @@ end
 class Autonomy < Dimensional::Metric
   self.dimension = Dimension::L
   self.base = Unit[:L, :SI, :m]
-  self.default = Unit[:L, :BA, :nm]
-  configure(Unit[:L, :SI, :km], {:preference => 2})
-  configure(Unit[:L, :US, :mi], {:preference => 3.5})
-  configure(Unit[:L, :Imp, :mi], {:preference => 3.5})
+  self.default = Unit[:L, :U, :M]
+  self.universal_systems = [System::U]
 end
 
 class EngineDisplacement < Dimensional::Metric
   self.dimension = Dimensional::Dimension::V
   self.base = Unit[:V, :SI, :l]
   self.default = base
-  configure(Unit[:V, :US, :in3], {:preference => 2})
+  configure(Unit[:V, :US, :in3], {:preference => 3})
 end
 
 class MechanicalPower < Dimensional::Metric

data/test/dimensional_test.rb

@@ -16,6 +16,7 @@ class DimensionalTest < Test::Unit::TestCase
     Dimension.reset!
     System.reset!
     Unit.reset!
+    Locale.reset!
   end
 
   def test_a_lot
@@ -29,10 +30,10 @@ class DimensionalTest < Test::Unit::TestCase
   end
 
   def test_engine_displacement
-    assert m = EngineDisplacement.parse('5.7l')
+    assert m = EngineDisplacement.load(5.7)
     assert_equal 5.7, m
     assert_same Unit[:V, :SI, 'liter'], m.unit
-    m = m.change_system(:US)
+    m = m.localize(Locale::US)
     assert_in_delta 347, m, 1
     assert_same Unit[:V, :US, 'in3'], m.unit
   end
@@ -41,7 +42,7 @@ class DimensionalTest < Test::Unit::TestCase
     assert m = MechanicalPower.parse('430hp')
     assert_equal 430, m
     assert_same Unit[:P, :US, :hp], m.unit
-    m = m.change_system(:SI)
+    m = m.localize(Locale::FI)
     assert_in_delta 320, m, 1
     assert_same Unit[:P, :SI, :kW], m.unit
   end
@@ -53,19 +54,20 @@ class DimensionalTest < Test::Unit::TestCase
       self.default = Unit[:Vel, :SI, :"km/h"]
       self.base = default
     end
-    assert m = speed.parse('20 knots')
+    assert m = speed.parse('20 knots', Locale::DK)
     assert_equal 20, m
-    assert_same Unit[:Vel, :BA, 'knot'], m.unit
-    m = m.change_system(:US)
+    assert_same Unit[:Vel, :U, 'knot'], m.unit
+    m = m.localize(Locale::US)
     assert_in_delta 23, m, 0.1
     assert_same Unit[:Vel, :US, 'mph'], m.unit
   end
 
+  # All Locale's should have an explicit system ordering for the Autonomy metric that places the Universal system first
   def test_autonomy
-    assert m = Autonomy.new(200000, Unit[:L, :SI, :meter])
-    assert_same Unit[:L, :SI, :meter], m.unit
-    m = m.change_system(:US)
-    assert_in_delta 124.3, m, 0.1
-    assert_same Unit[:L, :US, :mi], m.unit
+    assert m = Autonomy.load(200000)
+    assert_same Unit[:L, :U, :M], m.unit
+    assert_in_delta 108, m, 0.1
+    m = m.localize(Locale::US)
+    assert_same Unit[:L, :U, :M], m.unit
   end
 end

data/test/locale_test.rb

@@ -0,0 +1,64 @@
+require "helper"
+
+class LocaleTest < Test::Unit::TestCase
+  include Dimensional
+
+  def setup
+    System.register('British Imperial', 'Imp')
+    System.register('United States Customary', 'US')
+    System.register('International System of Units', 'SI')
+    System.register('International Standards', 'Std')
+  end
+
+  def teardown
+    System.reset!
+    Locale.reset!
+  end
+
+  def test_default_locale
+    assert_kind_of Locale, d = Locale.default
+    assert_kind_of Array, d.systems
+    assert d.systems.empty?
+  end
+
+  def test_create
+    default_systems = [System::US, System::SI, System::Std]
+    assert us = Locale.new(:US, default_systems)
+    assert_equal default_systems, us.systems
+    assert_equal 'US', us.to_s
+  end
+
+  def test_register
+    assert_kind_of Locale, us = Locale.register(:US)
+    assert_same us, Locale::US
+    assert_equal 'US', us.to_s
+  end
+
+  def test_auto_constant_defaults
+    default_default_systems = [System::SI, System::Std, System::US, System::Imp]
+    Locale.default.systems = default_default_systems
+    assert_kind_of Locale, ca = Locale::CA
+    assert_equal default_default_systems, ca.systems
+  end
+
+  def test_auto_constant_defaults_for_all_metrics
+    default_default_systems = [System::SI, System::Std, System::US, System::Imp]
+    us_default_systems = [System::Std, System::US, System::SI, System::Imp]
+    Locale.default.systems = default_default_systems
+    assert_kind_of Locale, us = Locale::US
+    us.systems = us_default_systems
+    assert_equal us_default_systems, us.systems
+  end
+
+  def test_auto_constant_defaults_are_independent
+    default_default_systems = [System::SI, System::Std, System::US, System::Imp]
+    default_ca_systems = [System::SI, System::Std, System::Imp, System::US]
+    default_us_systems = [System::US, System::Std, System::SI, System::Imp]
+    Locale.default.systems = default_default_systems
+    Locale::CA.systems = default_ca_systems
+    Locale::US.systems.replace(default_us_systems)
+    assert_equal default_default_systems, Locale::BE.systems
+    assert_equal default_us_systems, Locale::US.systems
+    assert_equal default_ca_systems, Locale::CA.systems
+  end
+end

data/test/metric_test.rb

@@ -35,19 +35,16 @@ class MetricTest < Test::Unit::TestCase
     # Dimensionless Units
     @each = Unit.register('each', System::US, nil, {:abbreviation => 'ea'})
     @dozen = Unit.register('dozen', System::US, nil, {:reference_units => {@each => 0}, :reference_factor => 12, :abbreviation => 'dz'})
+    Locale.default.systems = [System::SI, System::US, System::BA]
+    Locale::US.systems = [System::US, System::SI, System::BA]
+    Locale::BA.systems = [System::BA]
   end
 
   def teardown
     Dimension.reset!
     System.reset!
     Unit.reset!
-  end
-
-  def test_associated_units
-    beam = Class.new(Metric)
-    beam.dimension = Dimension::L
-    assert beam.units.include?(@cable)
-    assert !beam.units.include?(@pound_force)
+    Locale.reset!
   end
 
   def test_register_conflicting_unit
@@ -90,8 +87,8 @@ class MetricTest < Test::Unit::TestCase
   def test_find_unit
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    assert_same @foot_ba, depth.find_unit('foot', :BA)
-    assert_same @foot_us, depth.find_unit('foot', :US)
+    assert_same @foot_ba, depth.find_unit('foot', Locale::BA)
+    assert_same @foot_us, depth.find_unit('foot', Locale::US)
   end
 
   def test_scanner
@@ -109,7 +106,7 @@ class MetricTest < Test::Unit::TestCase
   def test_parse
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    assert m = depth.parse("15ft", :BA)
+    assert m = depth.parse("15ft", Locale::BA)
     assert_same @foot_ba, m.unit
     assert_equal 15, m
   end
@@ -117,7 +114,7 @@ class MetricTest < Test::Unit::TestCase
   def test_parse_with_whitespace
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    m = depth.parse("15 ft", :BA)
+    m = depth.parse("15 ft", Locale::BA)
     assert_same @foot_ba, m.unit
     assert_equal 15, m
   end
@@ -125,7 +122,7 @@ class MetricTest < Test::Unit::TestCase
   def test_parse_with_multiword_unit
     range = Class.new(Metric)
     range.dimension = Dimension::L
-    m = range.parse("15 nautical miles", :SI)
+    m = range.parse("15 nautical miles")
     assert_same @international_nautical_mile, m.unit
     assert_equal 15, m
   end
@@ -133,7 +130,7 @@ class MetricTest < Test::Unit::TestCase
   def test_parse_compound
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    d = depth.parse("15ft11in", :US)
+    d = depth.parse("15ft11in", Locale::US)
     assert_in_delta(15 + Rational(11, 12), d, 0.000001)
     assert_same @foot_us, d.unit
   end
@@ -141,7 +138,7 @@ class MetricTest < Test::Unit::TestCase
   def test_parse_compound_with_whitespace
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    d = depth.parse("1 ft 11 in", :US)
+    d = depth.parse("1 ft 11 in", Locale::US)
     assert_same d.unit, @foot_us
     assert_in_delta(1 + Rational(11, 12).to_f, d, 0.000001)
     assert_same @foot_us, d.unit
@@ -151,7 +148,7 @@ class MetricTest < Test::Unit::TestCase
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
     assert_raises ArgumentError do
-      depth.parse("1 foot 11cm", :L)
+      depth.parse("1 foot 11cm", Locale::US)
     end
   end
 
@@ -159,7 +156,7 @@ class MetricTest < Test::Unit::TestCase
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
     depth.default = @meter
-    assert_instance_of depth, m = depth.parse("10", :US)
+    assert_instance_of depth, m = depth.parse("10", Locale::US)
     assert_equal @meter, m.unit
   end
 
@@ -176,7 +173,7 @@ class MetricTest < Test::Unit::TestCase
   def test_to_f
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    d = depth.parse("1.85m", :SI)
+    d = depth.parse("1.85m", Locale::SI)
     assert_instance_of Float, d.to_f
   end
 
@@ -232,7 +229,7 @@ class MetricTest < Test::Unit::TestCase
     range.dimension = Dimension::L
     m0 = range.new(1, @foot_us)
     assert m1 = m0.change_system(:SI)
-    assert_same @meter, m1.unit
+    assert_same @centimeter, m1.unit
   end
 
   def test_change_system_mile
@@ -250,7 +247,7 @@ class MetricTest < Test::Unit::TestCase
       self.dimension = Dimension::L
     end
     m0 = range.new(100000, @meter)
-    assert m1 = m0.preferred
+    assert m1 = m0.preferred(Locale::FR)
     assert_same @kilometer, m1.unit
   end
 
@@ -278,26 +275,26 @@ class MetricTest < Test::Unit::TestCase
   def test_stringify_with_abbreviation
     range = Class.new(Metric)
     range.dimension = Dimension::L
-    assert_equal "1.85nm", range.parse('1.85 miles', :BA).to_s
+    assert_equal "1.85 nm", range.parse('1.85 miles', Locale::BA).to_s
   end
 
   def test_parse_gibberish_as_nil
     beam = Class.new(Metric)
     beam.dimension = Dimension::L
-    assert_nil beam.parse("gibberish", :L)
+    assert_nil beam.parse("gibberish", Locale::US)
   end
 
   def test_format_output
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    m = depth.parse("15ft3in", :BA)
+    m = depth.parse("15ft3in", Locale::BA)
     assert_equal "15.25 (ft)", m.strfmeasure("%4.2f (%U)")
   end
 
   def test_format_output_with_multiple_substitutions
     depth = Class.new(Metric)
     depth.dimension = Dimension::L
-    m = depth.parse("15ft4in", :BA)
+    m = depth.parse("15ft4in", Locale::BA)
     assert_equal "15.33 (ft)\t%\t<15.3333333ft>", m.strfmeasure("%4.2f (%U)\t%%\t<%10.7f%U>")
   end
 
@@ -305,7 +302,7 @@ class MetricTest < Test::Unit::TestCase
     distance = Class.new(Metric)
     distance.dimension = Dimension::L
     distance.configure(@nautical_mile, :precision => -2)
-    assert_equal "1.8600nm", distance.parse('1.8565454 nm', :BA).strfmeasure("%.4f%U")
-    assert_equal "1.86", distance.parse('1.8565454 nm', :BA).strfmeasure("%s")
+    assert_equal "1.8600nm", distance.parse('1.8565454 nm', Locale::BA).strfmeasure("%.4f%U")
+    assert_equal "1.86", distance.parse('1.8565454 nm', Locale::BA).strfmeasure("%s")
   end
 end

data/test/system_test.rb

@@ -31,8 +31,8 @@ class SystemTest < Test::Unit::TestCase
     assert_same s, System::BA
   end
 
-  def test_not_raise_exception_when_system_not_found
-    assert_nothing_raised do
+  def test_raise_exception_when_system_not_found
+    assert_raises RuntimeError do
       System['British Admiralty']
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dimensional
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors: 
 - Chris Hapgood
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-08 00:00:00 -05:00
+date: 2010-02-10 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,7 @@ files:
 - lib/dimensional.rb
 - lib/dimensional/configurator.rb
 - lib/dimensional/dimension.rb
+- lib/dimensional/locale.rb
 - lib/dimensional/metric.rb
 - lib/dimensional/system.rb
 - lib/dimensional/unit.rb
@@ -40,6 +41,7 @@ files:
 - test/dimension_test.rb
 - test/dimensional_test.rb
 - test/helper.rb
+- test/locale_test.rb
 - test/metric_test.rb
 - test/system_test.rb
 - test/unit_test.rb
@@ -77,6 +79,7 @@ test_files:
 - test/configurator_test.rb
 - test/dimension_test.rb
 - test/dimensional_test.rb
+- test/locale_test.rb
 - test/metric_test.rb
 - test/system_test.rb
 - test/unit_test.rb