dimensional 0.0.2

data/test/measure_test.rb

@@ -0,0 +1,185 @@
+require 'test/unit'
+require 'dimensional/measure'
+require 'dimensional/configurator'
+require 'rational'
+
+class MeasureTest < Test::Unit::TestCase
+  include Dimensional
+
+  def setup
+    System.register('International System of Units', 'SI')
+    System.register('United States Customary Units', 'US')
+    System.register('British Admiralty', 'BA')
+    
+    Dimension.register('Length')
+    Dimension.register('Mass')
+    
+    Metric.register('length', :L)
+
+    Configurator.start do
+      dimension(:L) do
+        system(:SI) do
+          base('meter', :detector => /\A(meters?|m)\Z/, :abbreviation => 'm') 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')
+          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
+              prefer(:length_over_all, :precision => Rational(1, 12))
+              derive('inch', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :abbreviation =>"in", :format => "%p\"")          
+            end
+            derive('furlong', 220, :detector => /\A(furlongs?)\Z/) do
+              derive('mile', 8, :detector => /\Amiles?\Z/, :abbreviation => 'mi')
+            end
+          end
+        end
+        system(:BA) do
+          base('mile', :detector => /\A(miles?|nm|nmi)\Z/, :abbreviation => 'nm') 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
+                    prefer(:length_over_all, :precision => Rational(1, 12))
+                    derive('inch', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :abbreviation => "in")
+                  end
+                end
+              end
+            end
+          end           
+        end
+      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')
+          end
+        end
+      end
+      # Dimensionless Units
+      base('each', :abbreviation => 'ea') do
+        derive('dozen', 12, :abbreviation => 'dz')
+      end
+    end
+  end
+
+  def teardown
+    Dimension.reset!
+    System.reset!
+    Unit.reset!
+    Metric.reset!
+  end
+
+  def test_create_new_measure
+    u = Unit[:L, :BA, 'mile']
+    assert m = Measure.new(3000, u, :length)
+    assert_equal 3000, m
+    assert_equal u, m.unit
+    assert_same Metric[:length], m.metric
+  end
+
+  def test_to_f
+    d = Measure.parse("1.85m", :L, :SI)
+    assert_instance_of Float, d.to_f
+  end
+
+  def test_to_i
+    d = Measure.parse("1 each", Metric[nil])
+    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']
+    new = Measure.new(1, old_unit).convert(new_unit)
+    assert_in_delta(10, new, 0.000001)
+    assert_same new_unit, new.unit
+  end
+
+  def test_do_identity_conversion
+    old_unit = Unit[:L, :BA, 'cable']
+    new_unit = old_unit
+    old_value = Measure.new(12, old_unit)
+    new_value = old_value.convert(new_unit)
+    assert_equal old_value, new_value
+  end
+
+  def test_return_base
+    u = Unit[:L, :BA, 'fathom']
+    b = Measure.new(1, u).base
+    assert_in_delta(1e-2, b, 0.000001)
+    assert_same u.base, b.unit
+  end
+
+  def test_parse
+    assert m = Measure.parse("15'", :L, :BA)
+    assert_same Unit[:L, :BA, 'foot'], m.unit
+    assert_equal 15, m
+  end
+  
+  def test_parse_with_whitespace
+    m = Measure.parse("15 feet", :L, :BA)
+    assert_same Unit[:L, :BA, 'foot'], m.unit
+    assert_equal 15, m
+  end
+
+  def test_parse_compound
+    d = Measure.parse("15'11\"", :L, :US)
+    assert_in_delta(15 + Rational(11, 12), d, 0.000001)
+  end
+
+  def test_parse_compound_with_whitespace
+    d = Measure.parse("1 foot 11 inches", :L, :US)
+    assert_same d.unit, Unit[:L, :US, 'foot']
+    assert_in_delta(1 + Rational(11, 12).to_f, d, 0.000001)
+  end
+
+  def test_raise_on_parse_of_mixed_compound
+    assert_raises ArgumentError do
+      Measure.parse("1 foot 11cm", :L)
+    end
+  end
+
+  def test_parse_with_default_unit
+    metric = Metric[:L]
+    du = metric.units.first
+    assert_instance_of Measure, m = Measure.parse("10", :L) 
+    assert_equal du, m.unit
+  end
+
+  def test_parse_dimensionless_units
+    assert m = Measure.parse('2 dozen', nil)
+    assert_instance_of Measure, m
+    assert_equal 2, m
+    assert_equal Unit[nil, nil, 'dozen'], m.unit
+    assert_equal 12, m.unit.factor
+    assert_nil m.unit.dimension
+  end
+  
+  def test_stringify_with_abbreviation
+    assert_equal "1.85nm", Measure.parse('1.85 miles', :L, :BA).to_s
+  end
+
+  def test_parse_gibberish_as_nil
+    assert_nil Measure.parse("gibberish", :L)
+  end
+  
+  def test_format_output
+    m = Measure.parse("15'3\"", :L, :BA)
+    assert_equal "15.25 (ft)", m.strfmeasure("%4.2f (%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")
+  end
+end

data/test/metric_test.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'dimensional/metric'
+require 'dimensional/unit'
+require 'rational'
+
+class MetricTest < Test::Unit::TestCase
+  include Dimensional
+
+  def setup
+    Dimension.register('Length')
+    Dimension.register('Mass')
+    Dimension.register('Force')
+    System.register('British Admiralty', 'BA')
+    System.register('United States Customary', 'US')
+    cable = Unit.register('cable', System::BA, Dimension::L, {})
+    fathom = Unit.register('fathom', System::BA, Dimension::L, {:reference_unit => cable, :reference_factor => Rational(1,10)})
+    yard = Unit.register('yard', System::BA, Dimension::L, {:reference_unit => fathom, :reference_factor => Rational(1,6)})
+    Unit.register('foot', System::BA, Dimension::L, {:reference_unit => yard, :reference_factor => Rational(1,3)})
+    Unit.register('foot', System::US, Dimension::L, {:reference_unit => yard, :reference_factor => Rational(1,3)})
+    Unit.register('pound', System::US, Dimension::M)
+    Unit.register('pound', System::US, Dimension::F)
+  end
+
+  def teardown
+    Dimension.reset!
+    System.reset!
+    Unit.reset!
+    Metric.reset!
+  end
+
+  def test_create
+    assert_instance_of Metric, m = Metric.new('draft', Dimension::L)
+    assert_same Dimension::L, m.dimension
+    assert_equal 'draft', m.name
+  end
+  
+  def test_register
+    assert_instance_of Metric, m = Metric.register('draft', Dimension::L)
+    assert_same m, Metric[:draft]
+  end
+  
+  def test_register_metric_with_parent
+    parent = Metric.register('L', Dimension::L)
+    child = Metric.register('depth', nil, parent)
+    assert_same parent, child.parent
+  end
+  
+  def test_register_dimensionless_metric
+    assert_instance_of Metric, m = Metric.register('population', nil)
+    assert_same m, Metric[:population]
+  end
+  
+  def test_register_default_dimensionless_metric
+    assert_instance_of Metric, m = Metric.register(nil, nil)
+    assert_same m, Metric[nil]
+  end
+  
+  def test_unit_preferences
+    length = Metric.register('L', Dimension::L)
+    draft = Metric.register('draft', Dimension::L, length)
+    foot = Unit[Dimension::L, System::BA, 'foot']
+    length.prefer(foot, {:detector => /(foot|ft)?s/})
+    draft.prefer(foot, {:precision => Rational(1, 12)})
+    assert_instance_of Hash, draft.preferences(foot)
+    assert_equal Rational(1,12), draft.preferences(foot)[:precision]
+    assert_equal /(foot|ft)?s/, draft.preferences(foot)[:detector]
+  end
+  
+  def test_unit_membership
+    length = Metric.register('L', Dimension::L)
+    mass = Metric.register('M', Dimension::M)
+    depth = Metric.register('depth', Dimension::L, length)
+    foot = Unit[:L, :BA, 'foot']
+    fathom = Unit[:L, :BA, 'fathom']
+    pound = Unit[:M, :US, 'pound']
+    length.prefer(foot)
+    length.prefer(fathom)
+    depth.prefer(fathom)
+    mass.prefer(pound)
+    assert_same fathom, depth.units.first # Units should be ordered with preferred units first...
+    assert_same foot, depth.units.last  # ...followed by remaining units from parent.
+    assert_equal 2, depth.units.size # Units should be de-duped with parent
+  end
+
+  def test_enumerate
+    length = Metric.register('L', Dimension::L)
+    assert length.to_enum.kind_of?(Enumerable::Enumerator)
+    assert_respond_to length, :map
+  end
+end

data/test/system_test.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'dimensional/system'
+
+class SystemTest < Test::Unit::TestCase
+  include Dimensional
+
+  def teardown
+    System.reset!
+  end
+
+  def test_create_new_measurement_system
+    assert_instance_of System, s = System.new('British Admiralty')
+    assert_equal 'British Admiralty', s.name
+    assert_nil s.abbreviation
+  end
+  
+  def test_create_new_measurement_system_with_abbreviation
+    assert_instance_of System, s = System.new('British Admiralty', 'BA')
+    assert_equal 'British Admiralty', s.name
+    assert_equal 'BA', s.abbreviation
+  end
+  
+  def test_register_new_measurement_system
+    assert_instance_of System, s = System.register('British Admiralty')
+    assert_same s, System['British Admiralty']
+  end
+  
+  def test_register_new_measurement_system_with_abbreviation
+    assert_instance_of System, s = System.register('British Admiralty', 'BA')
+    assert_same s, System['BA']
+    assert defined?(System::BA)
+    assert_same s, System::BA
+  end
+
+  def test_not_raise_exception_when_system_not_found
+    assert_nothing_raised do
+      System['British Admiralty']
+    end
+  end
+end

data/test/unit_test.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+require 'dimensional/unit'
+
+class UnitTest < Test::Unit::TestCase
+  include Dimensional
+
+  def setup
+    System.register('International System of Units', 'SI')
+    System.register('United States Customary', 'US')
+    System.register('British Admiralty', 'BA')
+    Dimension.register('Length')
+    Dimension.register('Mass')
+    Dimension.register('Force')
+  end
+
+  def teardown
+    Dimension.reset!
+    System.reset!
+    Unit.reset!
+  end
+
+  def test_create_new_base_unit
+    assert_instance_of Unit, u = Unit.new('cable', System::BA, Dimension::L, {})
+    assert_same System::BA, u.system
+    assert_same Dimension::L, u.dimension
+    assert u.base?
+    assert_same u, u.base
+    assert_same 1, u.factor
+  end
+  
+  def test_create_new_dimensionless_unit
+    assert_instance_of Unit, u = Unit.new('each', System::BA, nil, {})
+    assert_nil u.dimension
+  end
+  
+  def test_create_new_derived_unit
+    cable = Unit.new('cable', System::BA, Dimension::L, {})
+    assert_instance_of Unit, u = Unit.new('fathom', System['BA'], Dimension['L'], :reference_factor => 1E-1, :reference_unit => cable) 
+    assert !u.base?
+    assert_same cable, u.base
+    assert_equal 1E-1, u.factor
+  end
+
+  def test_create_new_combined_unit
+    meter = Unit.new('meter', System::SI, Dimension::L, {})
+    assert_instance_of Unit, u = Unit.new('square meter', System::SI, Dimension::L, :reference_factor => 1, :reference_unit => [meter, meter]) 
+    assert !u.base?
+    assert_equal [meter, meter], u.base
+    assert_equal 1, u.factor
+  end
+
+  def test_regsiter_new_unit
+    assert_instance_of Unit, u = Unit.register('fathom', System::BA, Dimension::L, {:abbreviation => 'fm'})
+    assert_same u, Unit[Dimension::L, System::BA, 'fathom']
+    assert_same u, Unit[Dimension::L, System::BA, 'fm']
+  end
+  
+  def test_regsiter_new_dimensionless_unit
+    assert_instance_of Unit, u = Unit.register('each', System::BA, nil, {:abbreviation => 'ea'})
+    assert_same u, Unit[nil, System::BA, 'each']
+    assert_same u, Unit[nil, System::BA, 'ea']
+  end
+  
+  def test_lookup_unit_with_symbols
+    u = Unit.register('fathom', System::BA, Dimension::L, {:abbreviation => 'fm'})
+    assert_nil Unit[:L, :SI, 'fathom']
+    assert_nil Unit[:M, :BA, 'fathom']
+    assert_nil Unit[:L, :BA, 'somethingelse']
+    assert_same u, Unit[:L, :BA, 'fathom']
+  end
+  
+  def test_convert
+    cable = Unit.new('cable', System::BA, Dimension::L, {})
+    fathom = Unit.new('fathom', System::BA, Dimension::L, :reference_factor => 1E-1, :reference_unit => cable) 
+    assert_equal 10, cable.convert(fathom)
+    assert_equal 1E-1, fathom.convert(cable)
+    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) 
+    u2 = Unit.new('ton', System::BA, Dimension::M, :abbreviation => 't')
+    assert u0.commensurable?(u1)
+    assert !u0.commensurable?(u2)
+  end
+
+  def test_identify_commensurable_composed_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) 
+    u2 = Unit.new('ton', System::BA, Dimension::M, :abbreviation => 't')
+    assert u0.commensurable?(u1)
+    assert !u0.commensurable?(u2)
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: dimensional
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Chris Hapgood
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "    Dimensional provides handling for dimensional values (numbers with units).  Dimensional values\n    can be parsed, stored, converted and formatted for output.\n"
+email: cch1@hapgoods.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dimensional/configurator.rb
+- lib/dimensional/dimension.rb
+- lib/dimensional/measure.rb
+- lib/dimensional/metric.rb
+- lib/dimensional/system.rb
+- lib/dimensional/unit.rb
+- lib/dimensional.rb
+- test/configurator_test.rb
+- test/demo.rb
+- test/dimension_test.rb
+- test/dimensional_test.rb
+- test/measure_test.rb
+- test/metric_test.rb
+- test/system_test.rb
+- test/unit_test.rb
+- README
+- CHANGELOG
+- LICENSE
+- Rakefile
+has_rdoc: true
+homepage: http://cho.hapgoods.com/dimensional
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.6.8
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Dimensional provides handling for numbers with units.
+test_files: 
+- test/configurator_test.rb
+- test/demo.rb
+- test/dimension_test.rb
+- test/dimensional_test.rb
+- test/measure_test.rb
+- test/metric_test.rb
+- test/system_test.rb
+- test/unit_test.rb