dimensional 0.0.4 → 0.0.5

data/Rakefile

@@ -16,7 +16,7 @@ Rake::Task['test'].comment = "Run all tests in test/*_test.rb"
 spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.name = %q{dimensional}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
   s.required_ruby_version = '>= 1.6.8'
   s.date = %q{2009-10-09}
   s.authors = ["Chris Hapgood"]

data/lib/dimensional.rb

@@ -4,5 +4,5 @@ require 'dimensional/unit'
 require 'dimensional/measure'
 
 module Dimensional
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/dimensional/configuration.rb

@@ -0,0 +1,48 @@
+require 'dimensional/dimension'
+require 'dimensional/system'
+require 'dimensional/unit'
+require 'dimensional/metric'
+
+# Encapsulates the application-specific configuration of Dimensional elements, including
+#   * Dimensions, including which are considered fundamental.
+#   * Systems, including a prioritized array of Systems to be consulted during parsing.
+#   * Metrics, including Unit formatting and parsing options per Metric
+#   * Units
+# Configurations can be constructed with a Configurator.  They can also be copied and extended.
+#
+# Metric == context
+#
+# Configuration#options(unit, context) => options_hash
+
+# Configuration#format(unit, context) => format_string
+#   #strfmeasure-compatible format string for given unit and given context
+
+# Configuration#detectors(context) => detector_hash
+#   #parse-compatible detector->unit pairs suitable for given context
+
+# Measure.parse(str, detectors) => instance of measure with unit matched by detectors
+# Measure#strfmeasure(format)
+# Measure#change_system(system)
+
+class Configuration
+  class Systems < Array
+  end
+
+  class Dimensions < Set
+  end
+
+  class Metrics < Set
+  end
+
+  class Units < Set
+  end
+
+  attr_reader :dimensions, :systems, :units, :metrics
+
+  def initialize
+    @dimensions = Dimensions.new
+    @systems = Systems.new
+    @metrics = Metrics.new
+    @units = Units.new
+  end
+end

data/lib/dimensional/configurator.rb

@@ -56,35 +56,35 @@ module Dimensional
     end
 
     # Register a new base unit
-    def base(name, options = {}, &block)
-      u = register_unit(name, options)
+    def base(name, abbreviation = nil, options = {}, &block)
+      u = unit(name, {:abbreviation => abbreviation})
+      dimension_metric.prefer(u, default_preferences(u).merge(options))
       change_context({:unit => u}, block)
     end
 
     # Register a new derived unit
-    def derive(name, factor, options = {}, &block)
-      options[:reference_factor] = factor
-      options[:reference_unit] = context.unit
-      u = register_unit(name, options)
+    def derive(name, abbreviation, factor, options = {}, &block)
+      u = unit(name, {:abbreviation => abbreviation, :reference_unit => context.unit, :reference_factor => factor})
+      dimension_metric.prefer(u, default_preferences(u).merge(options))
       change_context({:unit => u}, block)
     end
 
     # Register an alias for the unit in context
-    def alias(name, options = {}, &block)
-      derive(name, 1, options, &block)
+    def alias(name, abbreviation = nil, options = {}, &block)
+      derive(name, abbreviation, 1, options, &block)
     end
 
     # Register a new unit in the current context that references an arbitrary unit
-    def reference(name, reference, factor, options = {}, &block)
-      options.merge!(:reference_factor => factor, :reference_unit =>  reference)
-      u = register_unit(name, options)
+    def reference(name, abbreviation, u, f, options = {}, &block)
+      u = unit(name, :abbreviation => abbreviation, :reference_unit => u, :reference_factor => f)
+      dimension_metric.prefer(u, default_preferences(u).merge(options))
       change_context({:unit => u}, block)
     end
 
     # Register a new unit in the current context that is composed of multiple units
-    def combine(name, components, options = {}, &block)
-      options.merge!(:reference_factor => 1, :reference_unit => components)
-      u = register_unit(name, options)
+    def combine(name, abbreviation, components, options = {}, &block)
+      u = unit(name, :abbreviation => abbreviation, :reference_factor => 1, :reference_unit => components)
+      dimension_metric.prefer(u, default_preferences(u).merge(options))
       change_context({:unit => u}, block)
     end
 
@@ -99,15 +99,21 @@ module Dimensional
     end
     
     private
-    def register_unit(name, options)
-      u = Unit.register(name, context.system, context.dimension, options)
-      dimension_metric.prefer(u, options)
-      u
+    def unit(name, options = {})
+      Unit.register(name, context.system, context.dimension, options)
     end
 
     def dimension_metric
       find_or_register_metric(self.class.dimension_default_metric_name(context.dimension), nil)
     end
+    
+    # Basic preferences for formatting and parsing the given unit
+    def default_preferences(u)
+      o = {}
+      o[:format] = u.dimension.nil? ? "%s %U" : "%s%U"
+      o[:detector] = /\A#{[u.name, u.abbreviation].compact.join('|')}\Z/
+      o
+    end
 
     # Register the metric defined by the given key and the current context if it does not already exist.
     def find_or_register_metric(name, parent = nil)

data/lib/dimensional/measure.rb

@@ -22,7 +22,7 @@ module Dimensional
       units = metric.units
       elements = str.to_s.scan(NUMERIC_REGEXP).map do |(v, us)|
         units = units.select{|u| system == u.system} if system
-        unit = us.nil? ? units.first : units.detect{|u| u.match(us)}
+        unit = us.nil? ? units.first : units.detect{|u| metric.preferences(u)[:detector].match(us)}
         raise ArgumentError, "Unit cannot be determined (#{us})" unless unit
         system = unit.system
         value = unit.dimension.nil? ? v.to_i : v.to_f
@@ -82,12 +82,8 @@ module Dimensional
       convert(unit.base)
     end
 
-    def native
-      metric.dimension ? to_f : to_i
-    end
-
     def to_s
-      strfmeasure(metric.preferences(unit)[:format]) rescue super
+      strfmeasure(metric.preferences(unit)[:format] || "%s%U")
     end
 
     # Like Date, Time and DateTime, Measure represents both a value and a context.  Like those built-in classes,
@@ -97,25 +93,30 @@ module Dimensional
     #       In addition, this specifier supports the same width and precision modfiers as the '%s' specifier.  
     #       For example: %#10.10U
     # All other specifiers are applied to the numeric value of the measure.
-    # TODO: Support positional arguments (n$).
     # TODO: Support modulo subordinate units with format hash -> {1 => "'", 12 => :inch} or {1 => "%d#", 16 => "%doz."}
-    def strfmeasure(format = nil, *args)
+    def strfmeasure(format)
+      # We need the native value to prevent infinite recursion if the user specifies the %s specifier.
       v = if precision = metric.preferences(unit)[:precision]
         pfactor = 10**(-precision)
         ((self * pfactor).round / pfactor.to_f).to_s
       else
         native
       end
-      format = format || unit.format
-      format.gsub!(/%(#)?([\d.\-\*]*)U/) do |s|
-        arg = ($1) ? unit.name : unit.abbreviation
-        Kernel.sprintf("%#{$2}s", arg)
+      format = format.gsub(/%(#)?([\d.\-\*]*)U/) do |s|
+        us = ($1) ? unit.name : (unit.abbreviation || unit.name)
+        Kernel.sprintf("%#{$2}s", us)
       end
-      Kernel.sprintf(format, v, *args)
+      count = format.scan(/(?:\A|[^%])(%[^% ]*[A-Za-z])/).size
+      Kernel.sprintf(format, *Array.new(count, v)) 
     end
 
     def inspect
-      "#{super} : #{unit.inspect}"
+      strfmeasure("<%p <%#U>>")
+    end
+
+    private
+    def native
+      metric.dimension ? to_f : to_i
     end
   end
 end

data/lib/dimensional/system.rb

@@ -3,6 +3,8 @@ require 'delegate'
 module Dimensional
   # Represents a set of units for comprehensive measurement of physical quantities.
   class System < DelegateClass(String)
+    PRIORITY = []
+
     @registry = Hash.new
     @abbreviation_registry = Hash.new
 
@@ -12,6 +14,7 @@ module Dimensional
       raise "System #{s}'s abbreviation already exists" if @abbreviation_registry[s.abbreviation]
       @registry[s.to_sym] = s
       @abbreviation_registry[s.abbreviation.to_sym] = s if s.abbreviation
+      PRIORITY << s
       const_set(s.abbreviation, s) rescue nil # Not all symbols strings are valid constant names
       s
     end
@@ -24,7 +27,8 @@ module Dimensional
     
     # Purge all systems from storage.
     def self.reset!
-      constants.each {|d| remove_const(d)}
+      constants.each {|d| remove_const(d) unless d == 'PRIORITY'}
+      PRIORITY.clear
       @registry.clear
       @abbreviation_registry.clear
     end

data/lib/dimensional/unit.rb

@@ -1,7 +1,6 @@
 require 'dimensional/dimension'
 require 'dimensional/system'
 require 'set'
-require 'enumerator'
 
 module Dimensional
   # A standard scale unit for measuring physical quantities.  In addition to the Dimension and System attribute
@@ -15,7 +14,7 @@ module Dimensional
     def self.register(*args)
       u = new(*args)
       raise "Namespace collision: #{u.dimension}:#{u.system}:#{u.name}" if self[u.dimension, u.system, u.name.to_sym]
-      raise "Namespace collision: #{u.dimension}:#{u.system}:#{u.abbreviation}" if self[u.dimension, u.system, u.abbreviation.to_sym]
+      raise "Namespace collision: #{u.dimension}:#{u.system}:#{u.abbreviation}" if self[u.dimension, u.system, u.abbreviation.to_sym] if u.abbreviation
       @store << u
       u
     end
@@ -25,14 +24,15 @@ module Dimensional
       dim = Dimension[dim] unless dim.kind_of?(Dimension)
       sys = System[sys] unless sys.kind_of?(System)
       sym = sym.to_sym
-      @store.select{|u| u.dimension == dim}.select{|u| u.system == sys}.detect{|u| sym == u.abbreviation.to_sym || sym == u.name.to_sym}
+      us = @store.select{|u| u.dimension == dim}.select{|u| u.system == sys}
+      us.detect{|u| sym == u.name.to_sym || (u.abbreviation && sym == u.abbreviation.to_sym)}
     end
 
     def self.reset!
       @store.clear
     end
 
-    attr_reader :name, :abbreviation, :format
+    attr_reader :name, :abbreviation
     attr_reader :system, :dimension
     attr_reader :reference_factor, :reference_unit
 
@@ -42,13 +42,7 @@ module Dimensional
       @dimension = dimension
       @reference_factor = options[:reference_factor]
       @reference_unit = options[:reference_unit]
-      @detector = options[:detector] || /\A#{self.name}\Z/
-      @abbreviation = (options[:abbreviation] || self.name).to_s
-      @format = options[:format] || dimension.nil? ? "%s %U" : "%s%U"
-    end
-    
-    def match(s)
-      @detector.match(s)
+      @abbreviation = options[:abbreviation]
     end
 
     #  If no reference was provided during initialization, this unit must itself be a base unit.

data/test/configurator_test.rb

@@ -66,7 +66,7 @@ class ConfiguratorTest < Test::Unit::TestCase
         system(:SI) do
           base('meter') do
             test_context.assert uc = context.unit
-            derive('centimeter', 1e-2)
+            derive('centimeter', 'cm', 1e-2)
             test_context.assert_same uc, context.unit
           end
         end
@@ -76,19 +76,21 @@ class ConfiguratorTest < Test::Unit::TestCase
 
   def test_build_base_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm')
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
     end
     assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'meter']
     assert_same System::SI, u.system
     assert_same Dimension::L, u.dimension
     assert u.base?
-    assert_instance_of Metric, Metric[:L]
+    assert_equal 'm', u.abbreviation
+    assert_instance_of Metric, m = Metric[:L]
+    assert m.preferences(u)[:detector]
   end
 
   def test_build_derived_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') do
-        derive('centimeter', 1e-2, :detector => /\A(centimeters?|cm)\Z/, :abbreviation => 'cm')
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
+        derive('centimeter', 'cm', 1e-2, :detector => /\A(centimeters?|cm)\Z/)
       end
     end
     u0 = Unit[Dimension::L, System::SI, 'meter']
@@ -98,12 +100,11 @@ class ConfiguratorTest < Test::Unit::TestCase
     assert_same u0, u.base
     assert_equal 1E-2, u.factor
     assert_equal 'cm', u.abbreviation
-    assert u.match("centimeters")
   end
 
   def test_build_aliased_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') do
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
         self.alias('decadecimeter')
       end
     end
@@ -117,9 +118,9 @@ class ConfiguratorTest < Test::Unit::TestCase
 
   def test_build_referenced_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm')
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
       system(:US) do
-        reference('yard', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/, :abbreviation => 'yd')
+        reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/)
       end
     end
     u0 = Unit[Dimension::L, System::SI, 'meter']
@@ -130,11 +131,11 @@ class ConfiguratorTest < Test::Unit::TestCase
 
   def test_build_combined_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm')
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
       system(:US) do
-        reference('yard', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/, :abbreviation => 'yd')
+        reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/)
         dimension(:A) do
-          combine('square yard', [Unit[:L, :US, 'yard'], Unit[:L, :US, 'yard']], :detector => //, :abbreviation => 'yd2')
+          combine('square yard', 'yd2', [Unit[:L, :US, 'yard'], Unit[:L, :US, 'yard']], :detector => /\A(yd|yard)2\Z/)
         end
       end
     end
@@ -145,9 +146,20 @@ class ConfiguratorTest < Test::Unit::TestCase
     assert_equal [u1.base, u1.base], u.base
   end
   
+  def test_add_default_preferences
+    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+      base('meter', 'm')
+    end
+    u = Unit[Dimension::L, System::SI, 'meter']
+    m = Metric[:L]
+    assert d = m.preferences(u)[:detector]
+    assert_match d, 'meter'
+    assert f = m.preferences(u)[:format]
+  end
+
   def test_register_metric_options
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') do
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
         prefer(:length_over_all, :precision => 0.01)
       end
     end

data/test/demo.rb

@@ -20,75 +20,75 @@ Dimensional::System.register('British Imperial (lbs, ton, ft)', 'Imp')  # http:/
 Dimensional::Configurator.start do
   dimension(:L) do
     system(:SI) do
-      base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') do
-        derive('centimeter', 1e-2, :detector => /\A(centimeters?|cm)\Z/, :abbreviation => 'cm')
-        derive('kilometer', 1e3, :detector => /\A(kilometers?|km)\Z/, :abbreviation => 'km')
+      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
+        derive('centimeter', 'cm', Rational(1, 100), :detector => /\A(centimeters?|cm)\Z/)
+        derive('kilometer', 'km', 1000, :detector => /\A(kilometers?|km)\Z/)
       end
     end
     system(:US) do # As of 1 July 1959 (http://en.wikipedia.org/wiki/United_States_customary_units#Units_of_length)
-      reference('yard', Dimensional::Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/, :abbreviation => 'yd') do
-        derive('foot', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/, :abbreviation => "ft", :format => "%p'") do
+      reference('yard', 'yd', Dimensional::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
           prefer(:hull)
-          derive('inch', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :abbreviation =>"in", :format => "%p\"")          
+          derive('inch', 'in', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :format => "%p\"")          
         end
-        derive('furlong', 220, :detector => /\A(furlongs?)\Z/) do
-          derive('mile', 8, :detector => /\Amiles?\Z/, :abbreviation => 'mi')
+        derive('furlong', nil, 220, :detector => /\A(furlongs?)\Z/) do
+          derive('mile', 'mi', 8, :detector => /\Amiles?\Z/)
         end
       end
     end
   end
   dimension(:M) do
     system(:SI) do
-      base('kilogram', :detector => /\A(kilograms?|kg)\Z/, :abbreviation => 'kg') do
-        derive('tonne', 1e3, :detector => /\A(tonnes?)\Z/, :abbreviation => 't') do # metric ton
+      base('kilogram', 'kg', :detector => /\A(kilograms?|kg)\Z/) do
+        derive('tonne', 't', 1000, :detector => /\A(tonnes?)\Z/) do # metric ton
           prefer(:displacement)
         end
-        derive('gram', 1e-3, :detector => /\A(grams?|g)\Z/, :abbreviation => 'g')
+        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', Dimensional::Unit[:M, :SI, 'gram'], 453.59237, :detector => /\A(pounds?|lbs?|#)\Z/, :abbreviation => 'lb') do # avoirdupois
-        derive('hundredweight', 100, :detector => /\A(hundredweights?|cwt)\Z/, :abbreviation => 'cwt') do
-          derive('ton', 20, :detector => /\A(tons?|t)\Z/, :abbreviation => 't') do # short ton
+      reference('pound', 'lb', Dimensional::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
             prefer(:displacement)
           end
         end
-        derive('grain', 7000**-1, :detector => /\A(grains?|gr)\Z/, :abbreviation => 'gr') do
-          derive('dram', 27 + Rational(11, 32), :detector => /\A(drams?|dr)\Z/, :abbreviation => 'dr') do
-            derive('ounce', :detector => /\A(ounces?|ozs?)\Z/, :conversion => [437.5, :grain], :abbreviation => 'oz') 
-          end
+        derive('ounce', 'oz', Rational(1, 16), :detector => /\A(ounces?|ozs?)\Z/) 
+        derive('grain', 'gr', Rational(1, 7000), :detector => /\A(grains?|gr)\Z/) do
+          derive('dram', 'dr', 27 + Rational(11, 32), :detector => /\A(drams?|dr)\Z/)
         end
       end
     end
     system(:Imp) do
-      reference('pound', Dimensional::Unit[:M, :SI, 'gram'], 453.59237, :detector => /\A(pounds?|lbs?|#)\Z/, :abbreviation => 'lb') do
-        derive('grain', 7000**-1, :detector => /\A(grains?|gr)\Z/, :abbreviation => 'gr')
-        derive('drachm', 256**-1, :detector => /\A(drachms?|dr)\Z/, :abbreviation => 'dr')
-        derive('ounce', 16**-1, :detector => /\A(ounces?|ozs?)\Z/, :abbreviation => 'oz')
-        derive('stone', 14, :detector => /\A(stones?)\Z/)
-        derive('quarter', 28, :detector => /\A(quarters?)\Z/)
-        derive('hundredweight', 112, :detector => /\A(hundredweights?|cwt)\Z/, :abbreviation => 'cwt')
-        derive('ton', 2240, :detector => /\A(tons?|t)\Z/, :abbreviation => 't') do # long ton
+      reference('pound', 'lb', Dimensional::Unit[:M, :SI, 'gram'], 453.59237, :detector => /\A(pounds?|lbs?|#)\Z/) do
+        derive('grain', 'gr', Rational(1, 7000), :detector => /\A(grains?|gr)\Z/)
+        derive('drachm', 'dr', Rational(1, 256), :detector => /\A(drachms?|dr)\Z/)
+        derive('ounce', 'oz', Rational(1, 16), :detector => /\A(ounces?|ozs?)\Z/)
+        derive('stone', nil, 14, :detector => /\A(stones?)\Z/)
+        derive('quarter', nil, 28, :detector => /\A(quarters?)\Z/)
+        derive('hundredweight', 'cwt', 112, :detector => /\A(hundredweights?|cwt)\Z/)
+        derive('ton', 't', 2240, :detector => /\A(tons?|t)\Z/) do # long ton
           prefer(:displacement)
         end
       end
     end
   end
+
   dimension(:A) do
     system(:SI) do
-      combine('square meter', %w(meter meter).map{|name| Dimensional::Unit[:L, :SI, name]}, :detector => /\A(sq\.?\s?meters?|m2)\Z/, :abbreviation => 'm2') do
-        derive('hectare', 10000, :format => "%.4f%U", :abbreviation => 'ha') do
+      combine('square meter', 'm2', %w(meter meter).map{|name| Dimensional::Unit[:L, :SI, name]}, :detector => /\A(sq\.?\s?meters?|m2)\Z/) do
+        derive('hectare', 'ha', 10000, :format => "%.4f%U") do
           prefer(:forestry, :precision => -4, :format => "%s%U")
         end
       end
     end
     system(:US) do # All measures below are approximations due to the difference between a survey foot and an international foot.
-      combine('square yard', %w(yard yard).map{|name| Dimensional::Unit[:L, :US, name]}, :detector => /yd2/, :abbreviation => 'yd2') do
-        derive('acre', 4840.0)
+      combine('square yard', 'yd2', %w(yard yard).map{|name| Dimensional::Unit[:L, :US, name]}, :detector => /yd2/) do
+        derive('acre', nil, 4840)
       end
-      combine('square mile', %w(mile mile).map{|name| Dimensional::Unit[:L, :US, name]}, :detector => /\A(sq(uare|\.)?\s?miles?)\Z/) do
-        self.alias('section', :detector => /\Asections?\Z/) do
-          derive('township', 36, :detector => /\Atownships?\Z/)
+      combine('square mile', nil, %w(mile mile).map{|name| Dimensional::Unit[:L, :US, name]}, :detector => /\A(sq(uare|\.)?\s?miles?)\Z/) do
+        self.alias('section', nil, :detector => /\Asections?\Z/) do
+          derive('township', 'twp', 36, :detector => /\Atownships?\Z/)
         end
       end
     end
@@ -96,16 +96,16 @@ Dimensional::Configurator.start do
 
   dimension(:V) do
     system(:SI) do
-      combine('cubic meter', %w(meter meter meter).map{|name| Dimensional::Unit[:L, :SI, name]}, :detector => /\A(cubic meters?|m3)\Z/, :abbreviation => "m3") do
-        derive('cubic decimeter', 1e-3, :detector => /\A(cubic decimeters?|dm3)\Z/, :abbreviation => "dm3") do
-          self.alias('liter', :detector => /\A(liters?|l|L)\Z/, :abbreviation => "l") do
-            derive('milliliter', 1E-3, :detector => /\A(milliliters?|ml|mL)\Z/, :abbreviation => "ml")
+      combine('cubic meter', 'm3', %w(meter meter meter).map{|name| Dimensional::Unit[:L, :SI, name]}, :detector => /\A(cubic meters?|m3)\Z/) do
+        derive('cubic decimeter', 'dm3', Rational(1, 1000), :detector => /\A(cubic decimeters?|dm3)\Z/) do
+          self.alias('liter', 'l', :detector => /\A(liters?|l|L)\Z/) do
+            derive('milliliter', 'ml', Rational(1, 1000), :detector => /\A(milliliters?|ml|mL)\Z/)
           end
         end
       end
     end
     system(:Imp) do
-      reference('ounce', Dimensional::Unit[:V, :SI, 'milliliter'], 28.4130625, :detector => /\A((fluid )?ounces?|oz)\Z/, :abbreviation => "fl oz")
+      reference('ounce', 'fl oz', Dimensional::Unit[:V, :SI, 'milliliter'], 28.4130625, :detector => /\A((fluid )?ounces?|oz)\Z/)
       #  register :ounce, :conversion => [28.4130625, :milliliter], :detector => /\A(imperial\s(fluid )?imp\.\sounces?|imp\.\soz)\Z/, :abbreviation => "imp. oz"
       #  register :gill, :conversion => [5, :ounce], :detector => /\A(gills?|gi)\Z/, :abbreviation => "gi"
       #  register :cup, :conversion => [2, :gill], :detector => /\A(cups?)\Z/, :abbreviation => "cp"
@@ -128,12 +128,12 @@ Dimensional::Configurator.start do
     
   dimension(nil) do
     system(:US) do
-      base('each', :detector => /\Aea(ch)?\Z/, :abbreviation => 'ea') do
-        derive('pair', 2, :detector => /\A(pr|pair)\Z/, :abbreviation => 'pr')
-        derive('dozen', 12, :detector => /\A(dz|dozen)\Z/, :abbreviation => 'dz') do
-          derive('gross', 12)
+      base('each', 'ea', :detector => /\Aea(ch)?\Z/) do
+        derive('pair', 'pr', 2, :detector => /\A(pr|pair)\Z/)
+        derive('dozen', 'dz', 12, :detector => /\A(dz|dozen)\Z/) do
+          derive('gross', nil, 12)
         end
-        derive('score', 20)
+        derive('score', nil, 20)
       end
     end
   end

data/test/measure_test.rb

@@ -19,32 +19,32 @@ class MeasureTest < Test::Unit::TestCase
     Configurator.start do
       dimension(:L) do
         system(:SI) do
-          base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') do
+          base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
             prefer(:length_over_all, :precision => 0.01)
-            derive('centimeter', 1e-2, :detector => /\A(centimeters?|cm)\Z/, :abbreviation => 'cm')
-            derive('kilometer', 1e3, :detector => /\A(kilometers?|km)\Z/, :abbreviation => 'km')
+            derive('centimeter', 'cm', 1e-2, :detector => /\A(centimeters?|cm)\Z/)
+            derive('kilometer', 'km', 1e3, :detector => /\A(kilometers?|km)\Z/)
           end
         end
         system(:US) do # As of 1 July 1959 (http://en.wikipedia.org/wiki/United_States_customary_units#Units_of_length)
-          reference('yard', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/, :abbreviation => 'yd') do
-            derive('foot', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/, :abbreviation => "ft", :format => "%p'") do
+          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
               prefer(:length_over_all, :precision => Rational(1, 12))
-              derive('inch', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :abbreviation =>"in", :format => "%p\"")          
+              derive('inch', 'in', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :format => "%p\"")          
             end
-            derive('furlong', 220, :detector => /\A(furlongs?)\Z/) do
-              derive('mile', 8, :detector => /\Amiles?\Z/, :abbreviation => 'mi')
+            derive('furlong', nil, 220, :detector => /\A(furlongs?)\Z/) do
+              derive('mile', 'mi', 8, :detector => /\Amiles?\Z/)
             end
           end
         end
         system(:BA) do
-          base('mile', :detector => /\A(miles?|nm|nmi)\Z/, :abbreviation => 'nm') do
+          base('mile', 'nm', :detector => /\A(miles?|nm|nmi)\Z/) do
             prefer(:distance, :precision => -2)
-            derive('cable', Rational(1,10), :detector => /\A(cables?|cbls?)\Z/) do
-              derive('fathom', Rational(1,10), :detector => /\A(fathoms?|fms?)\Z/, :abbreviation => 'fm') do
-                derive('yard', Rational(1,6), :detector => /\A(yards?|yds?)\Z/, :abbreviation => 'yd') do
-                  derive('foot', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/, :abbreviation => "ft") do
+            derive('cable', nil, Rational(1,10), :detector => /\A(cables?|cbls?)\Z/) do
+              derive('fathom', 'fm', Rational(1,10), :detector => /\A(fathoms?|fms?)\Z/) do
+                derive('yard', 'yd', Rational(1,6), :detector => /\A(yards?|yds?)\Z/) do
+                  derive('foot', 'ft', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/) do
                     prefer(:length_over_all, :precision => Rational(1, 12))
-                    derive('inch', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :abbreviation => "in")
+                    derive('inch', 'in', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/)
                   end
                 end
               end
@@ -54,15 +54,15 @@ class MeasureTest < Test::Unit::TestCase
       end
       dimension(:M) do
         system(:SI) do
-          base('kilogram', :detector => /\A(kilograms?|kg)\Z/, :abbreviation => 'kg') do
-            derive('tonne', 1000, :detector => /\A(tonnes?)\Z/, :abbreviation => 't') # metric ton
-            derive('gram', Rational(1, 1000), :detector => /\A(grams?|g)\Z/, :abbreviation => 'g')
+          base('kilogram', 'kg', :detector => /\A(kilograms?|kg)\Z/) do
+            derive('tonne', 't', 1000, :detector => /\A(tonnes?)\Z/) # metric ton
+            derive('gram', 'g', Rational(1, 1000), :detector => /\A(grams?|g)\Z/)
           end
         end
       end
       # Dimensionless Units
-      base('each', :abbreviation => 'ea') do
-        derive('dozen', 12, :abbreviation => 'dz')
+      base('each', 'ea') do
+        derive('dozen', 'dz', 12)
       end
     end
   end
@@ -92,11 +92,6 @@ class MeasureTest < Test::Unit::TestCase
     assert_instance_of Fixnum, d.to_i
   end
 
-  def test_to_native
-    d = Measure.parse("1 each", Metric[nil])
-    assert_instance_of Fixnum, d.native
-  end
-
   def test_convert
     old_unit = Unit[:L, :BA, 'cable']
     new_unit = Unit[:L, :BA, 'fathom']
@@ -219,6 +214,11 @@ class MeasureTest < Test::Unit::TestCase
     assert_equal "15.25 (ft)", m.strfmeasure("%4.2f (%U)")
   end
 
+  def test_format_output_with_multiple_substitutions
+    m = Measure.parse("15'4\"", :L, :BA)
+    assert_equal "15.33 (ft)\t%\t<15.3333333ft>", m.strfmeasure("%4.2f (%U)\t%%\t<%.10s%U>")
+  end
+
   def test_precision_recognition
     assert_equal "1.8600nm", Measure.parse('1.8565454 miles', :distance, :BA).strfmeasure("%.4f%U")
     assert_equal "1.86", Measure.parse('1.8565454 miles', :distance, :BA).strfmeasure("%s")

data/test/unit_test.rb

@@ -77,13 +77,6 @@ class UnitTest < Test::Unit::TestCase
     assert_equal 1, fathom.convert(fathom)
   end
   
-  def test_match_per_unit
-    u = Unit.new('mile', System::BA, Dimension::L, :detector => /\A(nm|nmi)\Z/)
-    md = u.match('nmi')
-    assert_instance_of MatchData, md 
-    assert_equal 'nmi', md[0]
-  end
-
   def test_identify_commensurable_units
     u0 = Unit.new('mile', System::BA, Dimension::L, :detector => /\A(nm|nmi)\Z/, :abbreviation => 'nm') 
     u1 = Unit.new('cable', System::BA, Dimension::L, :detector => /\A(cables?|cbls?)\Z/, :reference_factor => 1E-1, :reference_unit => u0) 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dimensional
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Chris Hapgood
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/dimensional/configuration.rb
 - lib/dimensional/configurator.rb
 - lib/dimensional/dimension.rb
 - lib/dimensional/measure.rb