stick 1.3.1 → 1.3.2

data/CHANGES

@@ -1,6 +1,12 @@
 = Stick Change History
 
-== 1.3.0 / 2007-12-21
+== 1.3.2 / 2007-12-21
+
+* Removed top-level Stick namespace. Stick isn't big enough to warrent it at this point.
+* This means Units and Constants are at the toplevel instead.
+* This can be reconsidered later if Stick grows large enough to  necessary.
+
+== 1.3.0 / 2007-12-20
 
 * Removed times.rb. WE can reconsider this type of functionaility later.
 * Decided to distribute under the MIT License.

data/lib/stick/constants/cgs.rb

@@ -16,8 +16,7 @@
 
 require 'stick/units'
 
-module Stick
-  module Constants
+module Constants
 
     # = Constants in the CGS system (cm, g, s)
     #
@@ -131,5 +130,6 @@ module Stick
       JOULE                    = 1e7.g*cm**2/s**2                       # g cm^2 / s^2
       ERG                      = 1e0.g*cm**2/s**2                       # g cm^2 / s^2
     end
-  end
+
 end
+

data/lib/stick/constants/mks.rb

@@ -15,8 +15,7 @@
 #   - Brian Gough
 
 #
-module Stick
-  module Constants
+module Constants
 
     # = Constants in the MKS system (meters, kg, sec)
     #
@@ -133,10 +132,10 @@ module Stick
       JOULE                    = 1e0.kg*m**2/s**2                       # kg m^2 / s^2
       ERG                      = 1e-7.kg*m**2/s**2                      # kg m^2 / s^2
     end
-  end
+
 end
 
 
 module Math
-  include Stick::Constants::MKS
+  include ::Constants::MKS
 end

data/lib/stick/constants/number.rb

@@ -1,5 +1,5 @@
-module Stick
-  module Constants
+module Constants
+
     # = Unit-less constants
     #
     # Stick::Contants::Number::FINE_STRUCTURE  #=> 7.297352533e-3
@@ -24,10 +24,12 @@ module Stick
       ZEPTO           = 1e-21 # 1
       YOCTO           = 1e-24 # 1
     end
+
     include Number
-  end
+
 end
 
+
 module Math
-  include Stick::Contants::Number
+  include ::Contants::Number
 end

data/lib/stick/constants/typeless_cgs.rb

@@ -15,9 +15,10 @@
 #   - Thomas Sawyer
 
 #
-module Stick
-  module Constants
+module Constants
+
     module Typeless
+
       # Unitless Constants in the CGS system (cm, kg, s)
 
       module CGS
@@ -120,6 +121,7 @@ module Stick
         JOULE                    = 1e7     # g cm^2 / s^2
         ERG                      = 1e0     # g cm^2 / s^2
       end
+
     end
-  end
+
 end

data/lib/stick/constants/typeless_mks.rb

@@ -15,9 +15,10 @@
 #   - Brian Gough
 
 #
-module Stick
-  module Constants
+module Constants
+
     module Typeless
+
       # Unitless constants in the MKS system (meters, kg, sec)
 
       module MKS
@@ -121,6 +122,7 @@ module Stick
         JOULE                    = 1e0     # kg m^2 / s^2
         ERG                      = 1e-7    # kg m^2 / s^2
       end
+
     end
-  end
+
 end

data/lib/stick/currency.rb

@@ -1,10 +1,10 @@
 require 'stick/units/currency'
 
-module Stick
 module Units
+
   # Load conversion units.
   class Converter
     require("currency-standard")
   end
-end
+
 end

data/lib/stick/units.rb

@@ -1,6 +1,5 @@
 require 'stick/units/units'
 
-module Stick
 module Units
 
   # Load conversion units.
@@ -9,7 +8,6 @@ module Units
   end
 
 end
-end
 
 
 # Checkrun

data/lib/stick/units/base.rb

@@ -69,16 +69,15 @@ end
 #   http://en.wikipedia.org/wiki/Conversion_of_units
 #++
 
-module Stick
 module Units
 
   def method_missing(m, *args, &blk)
     if args.length == 1
-      args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
-      return ::Stick::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
-    elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
+      args[0] = (::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Units::Converter
+      return ::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
+    elsif (::Units::Converter.current.registered?(m) rescue false)
       raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-      return ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current)
+      return ::Units::Unit.new({m => 1}, ::Units::Converter.current)
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -86,8 +85,8 @@ module Units
   end
 
   def const_missing(c)
-    if (::Stick::Units::Converter.current.registered?(c) rescue false)
-      return ::Stick::Units::Unit.new({c => 1}, ::Stick::Units::Converter.current)
+    if (::Units::Converter.current.registered?(c) rescue false)
+      return ::Units::Unit.new({c => 1}, ::Units::Converter.current)
     else
       ::Exception.with_clean_backtrace("const_missing") {
         super
@@ -96,7 +95,7 @@ module Units
   end
 
   def self.append_features(m)
-    m.send(:extend, ::Stick::Units)
+    m.send(:extend, ::Units)
     super
   end
 
@@ -117,7 +116,7 @@ module Units
   #
   # See also Converter.current.
   def with_unit_converter(name, &blk) # :yields:
-    ::Stick::Units::Converter.with_converter(name, &blk)
+    ::Units::Converter.with_converter(name, &blk)
   end
 
   module_function :with_unit_converter
@@ -138,7 +137,7 @@ module Units
 
     attr_reader :name, :converter
 
-    def initialize(name, converter = ::Stick::Units::Converter.current)
+    def initialize(name, converter = ::Units::Converter.current)
       name = name.to_sym
       raise ::ArgumentError, "unit #{name.to_s.dump} not registered with #{converter}" if not converter.registered? name
       @name = name
@@ -150,7 +149,7 @@ module Units
     end
 
     def ==(other)
-      other.is_a?(::Stick::Units::BaseUnit) && other.name == @name && other.converter == @converter
+      other.is_a?(::Units::BaseUnit) && other.name == @name && other.converter == @converter
     end
 
     alias eql? ==
@@ -160,7 +159,7 @@ module Units
     end
 
     def to_s
-      if ::Stick::Units::Converter.current.includes?(converter)
+      if ::Units::Converter.current.includes?(converter)
         @name.to_s
       else
         "#{@converter}:#{@name}"
@@ -172,13 +171,13 @@ module Units
   end
 
   # This class represents a Unit. A Unit uses a given Converter with
-  # a number of registered Stick in which it can be expressed.
-  # A Unit is the product of the powers of other Stick. In principle, these
+  # a number of registered units in which it can be expressed.
+  # A Unit is the product of the powers of other units. In principle, these
   # need not be integer powers, but this may cause problems with rounding.
   # The following code for example returns +false+:
   #   Unit.new(:m => 0.1) * Unit.new(:m => 0.2) == Unit.new(:m => 0.3)
   #
-  # Stick can be multiplied, divided, and raised to a given power.
+  # Units can be multiplied, divided, and raised to a given power.
   # As an extra, 1 can be divided by a Unit.
   #
   # Examples:
@@ -203,13 +202,13 @@ module Units
     #
     # See also Converter, Converter.converter
     def initialize(units = {}, converter = nil)
-      conv = proc { converter ||= ::Stick::Units::Converter.current }
+      conv = proc { converter ||= ::Units::Converter.current }
       if units.is_a? ::String
         @units = decode_string(units, conv)
       else
         @units = {}
         units.each_pair do |k, v|
-          k = conv[].base_unit(k.to_sym) if not k.is_a? ::Stick::Units::BaseUnit
+          k = conv[].base_unit(k.to_sym) if not k.is_a? ::Units::BaseUnit
           @units[k] = v
         end
       end
@@ -222,7 +221,7 @@ module Units
       @units.each_pair do |u, e|
         result[u] = e * p
       end
-      ::Stick::Units::Unit.new(result)
+      ::Units::Unit.new(result)
     end
 
     # Multiplies with the given Unit.
@@ -241,18 +240,18 @@ module Units
     end
 
     def coerce(other) # :nodoc:
-      return [::Stick::Units::Unit.new({}), self] if other == 1
-      ::Stick::Units::Converter.coerce_units(self, other)
+      return [::Units::Unit.new({}), self] if other == 1
+      ::Units::Converter.coerce_units(self, other)
     end
 
     def simplify
-      ::Stick::Units::Converter.simplify_unit(self)
+      ::Units::Converter.simplify_unit(self)
     end
 
     # Returns +true+ iff the two units are equals, <i>i.e.,</i> iff they have
     # the same exponent for all units, and they both use the same Converter.
     def ==(other)
-      other.is_a?(::Stick::Units::Unit) && other.units == units
+      other.is_a?(::Units::Unit) && other.units == units
     end
 
     alias eql? ==
@@ -265,7 +264,7 @@ module Units
     # Unit. This is less strict than equality because for example hours are
     # compatible with seconds ("we can add them"), but hours are not seconds.
     def compatible_with?(other)
-      conv1, conv2 = ::Stick::Units::Converter.coerce_units(self, other)
+      conv1, conv2 = ::Units::Converter.coerce_units(self, other)
       conv1.units == conv2.units
     end
 
@@ -289,11 +288,11 @@ module Units
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
-        return self * ::Stick::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
-      elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
+        args[0] = (::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Units::Converter
+        return self * ::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
+      elsif (::Units::Converter.current.registered?(m) rescue false)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return self * ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current)
+        return self * ::Units::Unit.new({m => 1}, ::Units::Converter.current)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -303,7 +302,7 @@ module Units
     private
 
     def decode_string(s, converter)
-      if ::Stick::Units::Regexps::TOTAL_UNIT_REGEXP =~ s
+      if ::Units::Regexps::TOTAL_UNIT_REGEXP =~ s
         numerator, denominator = $1, $2
         units = {}
         decode_multiplicative_string(numerator, 1, converter, units) if numerator
@@ -317,9 +316,9 @@ module Units
     end
 
     def decode_multiplicative_string(s, multiplier, converter, result)
-      s.scan(::Stick::Units::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
+      s.scan(::Units::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
         if unit
-          conv = ::Stick::Units::Converter.converter(conv)
+          conv = ::Units::Converter.converter(conv)
         else
           conv, unit = converter[], conv
         end
@@ -337,13 +336,13 @@ module Units
 
     def do_op(op, dual_op, other)
       other = other.to_unit
-      raise TypeError, "cannot convert to Unit" unless ::Stick::Units::Unit === other
+      raise TypeError, "cannot convert to Unit" unless ::Units::Unit === other
       result = @units.dup
       other.units.each_pair do |u, e|
         result[u] = 0 if not result[u]
         result[u] = result[u].send(dual_op, e)
       end
-      ::Stick::Units::Unit.new(result)
+      ::Units::Unit.new(result)
     end
 
   end
@@ -414,7 +413,7 @@ module Units
     %w{ * / }.each do |op|
       eval %{
         def #{op}(other)
-          ::Stick::Units::Value.new(*do_multiplicative_op(:#{op}, other))
+          ::Units::Value.new(*do_multiplicative_op(:#{op}, other))
         end
       }
     end
@@ -422,14 +421,14 @@ module Units
     %w{ + - modulo remainder % }.each do |op|
       eval %{
         def #{op}(other)
-          ::Stick::Units::Value.new(*do_additive_op(:#{op}, other))
+          ::Units::Value.new(*do_additive_op(:#{op}, other))
         end
       }
     end
 
     def divmod(other)
       (q, r), unit = *do_additive_op(:divmod, other)
-      [q, ::Stick::Units::Value.new(r, unit)]
+      [q, ::Units::Value.new(r, unit)]
     end
 
     def div(other)
@@ -445,7 +444,7 @@ module Units
     end
 
     def **(other) # :nodoc:
-      ::Stick::Units::Value.new(@value ** other, @unit ** other)
+      ::Units::Value.new(@value ** other, @unit ** other)
     end
 
     def <=>(other) # :nodoc:
@@ -467,7 +466,7 @@ module Units
     %w{ abs ceil floor next round succ truncate }.each do |op|
       eval %{
         def #{op}
-          ::Stick::Units::Value.new(@value.#{op}, @unit)
+          ::Units::Value.new(@value.#{op}, @unit)
         end
       }
     end
@@ -487,16 +486,16 @@ module Units
     def to(to_unit, converter = nil)
       raise ArgumentError, "Wrong number of arguments" if converter && !(::String === to_unit)
       to_unit = to_unit.to_unit(converter)
-      raise TypeError, "cannot convert to Unit" unless ::Stick::Units::Unit === to_unit
+      raise TypeError, "cannot convert to Unit" unless ::Units::Unit === to_unit
       conv1, conv2 = unit.coerce(to_unit)
       raise TypeError, "incompatible units for operation" if conv1.units != conv2.units
       mult = conv1.multiplier / conv2.multiplier
-      ::Stick::Units::Value.new(value * mult, to_unit)
+      ::Units::Value.new(value * mult, to_unit)
     end
 
     def coerce(other) # :nodoc:
       if ::Numeric === other
-        [::Stick::Units::Value.new!(other, ::Stick::Units::Unit.new), self]
+        [::Units::Value.new!(other, ::Units::Unit.new), self]
       else
         super
       end
@@ -511,7 +510,7 @@ module Units
     # exception otherwise.
     def to_f
       val = simplify
-      if ::Stick::Units::Value === val
+      if ::Units::Value === val
         raise TypeError, "Cannot convert to float"
       else
         val.to_f
@@ -522,7 +521,7 @@ module Units
     # exception otherwise.
     def to_i
       val = simplify
-      if ::Stick::Units::Value === val
+      if ::Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_i
@@ -533,7 +532,7 @@ module Units
     # exception otherwise.
     def to_int
       val = simplify
-      if ::Stick::Units::Value === val
+      if ::Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_int
@@ -547,7 +546,7 @@ module Units
       if new_unit.unitless?
         @value * mul
       else
-        ::Stick::Units::Value.new(@value * mul, new_unit)
+        ::Units::Value.new(@value * mul, new_unit)
       end
     end
 
@@ -560,11 +559,11 @@ module Units
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
-        return self * ::Stick::Units::Value.new(1, ::Stick::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
-      elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
+        args[0] = (::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Units::Converter
+        return self * ::Units::Value.new(1, ::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
+      elsif (::Units::Converter.current.registered?(m) rescue false)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return self * ::Stick::Units::Value.new(1, ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current))
+        return self * ::Units::Value.new(1, ::Units::Unit.new({m => 1}, ::Units::Converter.current))
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -574,9 +573,9 @@ module Units
   private
 
     def self.decode_string(s, converter)
-      if m = ::Stick::Units::Regexps::VALUE_REGEXP.match(s)
+      if m = ::Units::Regexps::VALUE_REGEXP.match(s)
         value = m[2].empty? ? Integer(m[1]) : Float(m[1])
-        unit = ::Stick::Units::Unit.new(m[3], converter)
+        unit = ::Units::Unit.new(m[3], converter)
         [value, unit]
       else
         raise ::ArgumentError, "Illegal value string #{s.dump}"
@@ -585,8 +584,8 @@ module Units
 
     def do_additive_op(op, other)
       other = other.to_value
-      raise TypeError, "cannot convert to Value" unless ::Stick::Units::Value === other
-      if other.is_a? ::Stick::Units::Value
+      raise TypeError, "cannot convert to Value" unless ::Units::Value === other
+      if other.is_a? ::Units::Value
         conv1, conv2 = unit.coerce(other.unit)
         raise TypeError, "incompatible units for #{op}" if conv1.units != conv2.units
         mult = conv2.multiplier / conv1.multiplier
@@ -603,18 +602,18 @@ module Units
 
     def do_multiplicative_op(op, other)
       case other
-      when ::Stick::Units::Value
+      when ::Units::Value
         [value.send(op, other.value), unit.send(op, other.unit)]
-      when ::Stick::Units::Unit
+      when ::Units::Unit
         [value, unit.send(op, other)]
       when ::Numeric
         [value.send(op, other), unit]
       else
-        # TODO: How to make this work for Stick as well?
+        # TODO: How to make this work for Units as well?
         #       Problem : how check whether to_value failed without
         #                 masking all exceptions?
         other = other.to_value
-        raise TypeError, "cannot convert to Value" unless ::Stick::Units::Value === other
+        raise TypeError, "cannot convert to Value" unless ::Units::Value === other
         do_multiplicative_op(op, other)
       end
     end
@@ -673,7 +672,7 @@ module Units
     # Included the given converter in the receiver, unless it
     # was already included.
     def include(conv)
-      conv = ::Stick::Units::Converter.converter(conv) if not conv.is_a?(::Stick::Units::Converter)
+      conv = ::Units::Converter.converter(conv) if not conv.is_a?(::Units::Converter)
       raise "Circular include" if conv.includes?(self)
       @included << conv if not includes? conv
       self
@@ -682,7 +681,7 @@ module Units
     # Returns whether the given converter was included in the
     # receiver.
     def includes?(conv)
-      conv = ::Stick::Units::Converter.converter(conv) if not conv.is_a?(::Stick::Units::Converter)
+      conv = ::Units::Converter.converter(conv) if not conv.is_a?(::Units::Converter)
       return true if conv == self
       @included.each do |c|
         return true if conv == c || c.includes?(conv)
@@ -714,7 +713,7 @@ module Units
     # Returns the base unit with this name
     def base_unit(name)
       if conv = registered?(name)
-        return ::Stick::Units::BaseUnit.new(name, conv)
+        return ::Units::BaseUnit.new(name, conv)
       end
       raise "unit #{name.to_s.dump} not registered with #{self}"
     end
@@ -728,7 +727,7 @@ module Units
     def method_missing(m, *args, &blk)
       if registered?(m)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return ::Stick::Units::Unit.new({m => 1}, self)
+        return ::Units::Unit.new({m => 1}, self)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -794,12 +793,12 @@ module Units
         abbrev = info[:abbrev]
         multiplier = info[:multiplier] || 1
         power = info[:power] || 1
-        register_unit(pre + unit, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+        register_unit(pre + unit, :equals => {:unit => ::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         aliases.each do |a|
-          register_unit(pre + a, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+          register_unit(pre + a, :equals => {:unit => ::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         end
         abbrevs.each do |a|
-          register_unit(abbrev + a, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+          register_unit(abbrev + a, :equals => {:unit => ::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         end
       end
     end
@@ -820,9 +819,9 @@ module Units
                 :multiplier => data[:multiplier] || data['multiplier']}
       end
       if /^\s*1\s*\// =~ data
-        {:unit => ::Stick::Units::Unit.new(data, self)}
-      elsif m = /^\s*#{::Stick::Units::Regexps::NUMBER_REGEXP}(?:\s+(\S.*)$|\s*$)/.match(data)
-        unit = m[3] ? ::Stick::Units::Unit.new(m[3], self) : ::Stick::Units::Unit.new({}, self)
+        {:unit => ::Units::Unit.new(data, self)}
+      elsif m = /^\s*#{::Units::Regexps::NUMBER_REGEXP}(?:\s+(\S.*)$|\s*$)/.match(data)
+        unit = m[3] ? ::Units::Unit.new(m[3], self) : ::Units::Unit.new({}, self)
         if m[1]
           multiplier = m[2].empty? ? Integer(m[1]) : Float(m[1])
           {:unit => unit, :multiplier => multiplier}
@@ -830,7 +829,7 @@ module Units
           {:unit => unit}
         end
       else
-        {:unit => ::Stick::Units::Unit.new(data, self)}
+        {:unit => ::Units::Unit.new(data, self)}
       end
     end
 
@@ -847,20 +846,22 @@ module Units
 
     class << self
 
+      THREAD_REFERENCE = 'Units::converter'.to_sym
+
       private :new
 
       # Returns the current Converter in the current Thread.
       # The default converter is the one returned by <code>converter(:default)</code>.
-      # See also Stick::Units#with_converter and Converter.converter.
+      # See also Units#with_converter and Converter.converter.
       def current
-        Thread.current[:'Stick::Units::converter'] ||= converter(:default)
+        Thread.current[THREAD_REFERENCE] ||= converter(:default)
       end
 
       def with_converter(conv) # :nodoc:
-        conv = converter(conv) if not conv.is_a? ::Stick::Units::Converter
-        raise ::ArgumentError, "Converter expected" if not conv.is_a? ::Stick::Units::Converter
+        conv = converter(conv) if not conv.is_a? ::Units::Converter
+        raise ::ArgumentError, "Converter expected" if not conv.is_a? ::Units::Converter
         begin
-          old_conv = Thread.current[:'Stick::Units::converter']
+          old_conv = Thread.current[THREAD_REFERENCE]
           if old_conv
             new_conv = Converter.send(:new, nil)
             new_conv.include(old_conv)
@@ -868,10 +869,10 @@ module Units
           else
             new_conv = conv
           end
-          Thread.current[:'Stick::Units::converter'] = new_conv
+          Thread.current[THREAD_REFERENCE] = new_conv
           yield
         ensure
-          Thread.current[:'Stick::Units::converter'] = old_conv
+          Thread.current[THREAD_REFERENCE] = old_conv
         end
       end
 
@@ -919,7 +920,7 @@ module Units
         units.each_pair do |u, e|
           (u.conversion != :none ? other_units : base_units)[u] = e
         end
-        result = Conversion.new(::Stick::Units::Unit.new(base_units, self), multiplier)
+        result = Conversion.new(::Units::Unit.new(base_units, self), multiplier)
         other_units.each_pair do |u, e|
           result *= (u.conversion ** e)
         end
@@ -944,17 +945,16 @@ module Units
   end
 
 end
-end
 
 class Numeric
   #
   def method_missing(m, *args, &blk)
     if args.length == 1
-      args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
-      return ::Stick::Units::Value.new(self, ::Stick::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
-    elsif ::Stick::Units::Converter.current.registered?(m)
+      args[0] = (::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Units::Converter
+      return ::Units::Value.new(self, ::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
+    elsif ::Units::Converter.current.registered?(m)
       raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-      return ::Stick::Units::Value.new(self, ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current))
+      return ::Units::Value.new(self, ::Units::Unit.new({m => 1}, ::Units::Converter.current))
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -963,7 +963,7 @@ class Numeric
 
   #
   def to_value(unit)
-    ::Stick::Units::Value.new(self, unit)
+    ::Units::Value.new(self, unit)
   end
 end
 
@@ -971,11 +971,11 @@ end
 class String
   #
   def to_unit(converter = nil)
-    ::Stick::Units::Unit.new(self, converter)
+    ::Units::Unit.new(self, converter)
   end
 
   #
   def to_value(converter = nil)
-    ::Stick::Units::Value.new(self, converter)
+    ::Units::Value.new(self, converter)
   end
 end

data/lib/stick/units/currency.rb

@@ -1,23 +1,23 @@
 require 'stick/units/base'
 require 'soap/wsdlDriver'
 
-module Stick
 module Units
 
   class CurrencyLoader < Loader
+    THREAD_REFERENCE = 'Units::ce_service'.to_sym
 
     handles 'ce_service', 'currency_unit'
 
     def ce_service(converter, name, &blk)
-      old_service = Thread.current[:'Stick::ce_service']
-      Thread.current[:'Stick::Units::ce_service'] = ::Stick::Units::Converter::ExchangeRate.const_get(name)
+      old_service = Thread.current[THREAD_REFERENCE]
+      Thread.current[THREAD_REFERENCE] = ::Units::Converter::ExchangeRate.const_get(name)
       yield
     ensure
-      Thread.current[:'Stick::Units::ce_service'] = old_service
+      Thread.current[THREAD_REFERENCE] = old_service
     end
 
     def currency_unit(converter, name)
-      service = Thread.current[:'Stick::Units::ce_service'] || ::Stick::Units::Config::DEFAULT_CURRENCY_SERVICE
+      service = Thread.current[THREAD_REFERENCE] || ::Units::Config::DEFAULT_CURRENCY_SERVICE
       converter.send(:register_unit, name, :equals => service.create_conversion(name, converter))
     end
 
@@ -36,11 +36,11 @@ module Units
     # The only subclasses provided are currently XMethods and CachedXMethods.
     #
     # To be found automatically from YAML files, exchange services should
-    # be located under Stick::Units::Converter::ExchangeRate.
+    # be located under Units::Converter::ExchangeRate.
     class ExchangeRate
 
       def self.create_conversion(curr, converter) # :nodoc:
-        {:unit => ::Stick::Units::Unit.new({:'--base-currency--' => 1}, converter), :multiplier => self.new(curr)}
+        {:unit => ::Units::Unit.new({'--base-currency--'.to_sym => 1}, converter), :multiplier => self.new(curr)}
       end
 
       def initialize(curr) # :nodoc:
@@ -104,7 +104,7 @@ module Units
         private
 
         def data
-          @@data ||= eval(File.read(File.join(::Stick::Units::Config::CONFIGDIR, 'xmethods', 'mapping.rb')))
+          @@data ||= eval(File.read(File.join(::Units::Config::CONFIGDIR, 'xmethods', 'mapping.rb')))
         end
 
         def country_mapping
@@ -133,7 +133,7 @@ module Units
         private
 
         def data
-          @@data ||= eval(File.read(File.join(::Stick::Units::Config::CONFIGDIR, 'xmethods', 'cached.rb')))
+          @@data ||= eval(File.read(File.join(::Units::Config::CONFIGDIR, 'xmethods', 'cached.rb')))
         end
 
       end #class CachedXMethods
@@ -145,7 +145,7 @@ module Units
     # Trans: What is --base-currency-- all about?
     #++
     def conversions(unit)
-      @conversions[unit] || (unit == :'--base-currency--' ? :none : nil)
+      @conversions[unit] || (unit == '--base-currency--'.to_sym ? :none : nil)
     end
 
   end
@@ -153,8 +153,8 @@ module Units
   # Contains some configuration related constants
   module Config
     # The standard service used for looking up currency exchange rates
-    DEFAULT_CURRENCY_SERVICE = ::Stick::Units::Converter::ExchangeRate::XMethods
+    DEFAULT_CURRENCY_SERVICE = ::Units::Converter::ExchangeRate::XMethods
   end
 
 end
-end
+

data/lib/stick/units/loaders.rb

@@ -1,4 +1,3 @@
-module Stick
 module Units
 
   class Loader
@@ -74,7 +73,7 @@ module Units
       end
 
       def load_config(file, context)
-        data = File.read(File.join(::Stick::Units::Config::CONFIGDIR, file)) rescue File.read(file)
+        data = File.read(File.join(::Units::Config::CONFIGDIR, file)) rescue File.read(file)
         context.instance_eval { eval data, nil, file }
       end
 
@@ -97,4 +96,4 @@ module Units
   end
 
 end
-end
+

data/lib/stick/units/units.rb

@@ -1,6 +1,5 @@
 require 'stick/units/base'
 
-module Stick
 module Units
 
   class SILoader < Loader
@@ -108,4 +107,3 @@ module Units
   end
 
 end
-end

data/meta/stick.roll

@@ -1,2 +1,2 @@
-stick 1.3.1 stable 2007-12-21
+stick 1.3.2 stable 2007-12-21
 lib/stick

data/test/test_currency.rb

@@ -5,7 +5,7 @@ require 'stick/currency'
 
 class TestUnits < Test::Unit::TestCase
 
-  include ::Stick::Units
+  include ::Units
 
   def test_typerror
     assert_raises(TypeError) do

data/test/test_units.rb

@@ -9,7 +9,7 @@ class TestUnits < Test::Unit::TestCase
     assert( v2 * (1 - d) <= v1 && v1 <= v2 * (1 + d), "<#{v1}> expected but was\n<#{v2}>" )
   end
 
-  include ::Stick::Units
+  include ::Units
 
   def test_bit_and_bytes
     assert_equal( 65.bit/s,  1.bit/s + 8.bytes/s )

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.4.6
 specification_version: 2
 name: stick
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
+  version: 1.3.2
 date: 2007-12-21 00:00:00 -05:00
 summary: Stick is an comprehensive science library including a units system providing bot
 require_paths: