stick 1.3.2 → 1.3.3

data/lib/stick/units.rb

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

data/lib/stick/units/base.rb

@@ -52,6 +52,8 @@ class Exception
 
 end
 
+module Stick
+
 # The namespace for all unit related classes. Mixing this in has the additional effect
 # of making Units.with_unit_converter available without the <code>Units.</code> prefix,
 # as well as the shortcuts for creating Units (see Units#method_missing).
@@ -73,11 +75,11 @@ module Units
 
   def method_missing(m, *args, &blk)
     if args.length == 1
-      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)
+      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 ::Units::Unit.new({m => 1}, ::Units::Converter.current)
+      return Units::Unit.new({m => 1}, Units::Converter.current)
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -85,8 +87,8 @@ module Units
   end
 
   def const_missing(c)
-    if (::Units::Converter.current.registered?(c) rescue false)
-      return ::Units::Unit.new({c => 1}, ::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
@@ -95,7 +97,7 @@ module Units
   end
 
   def self.append_features(m)
-    m.send(:extend, ::Units)
+    m.send(:extend, Units)
     super
   end
 
@@ -116,7 +118,7 @@ module Units
   #
   # See also Converter.current.
   def with_unit_converter(name, &blk) # :yields:
-    ::Units::Converter.with_converter(name, &blk)
+    Units::Converter.with_converter(name, &blk)
   end
 
   module_function :with_unit_converter
@@ -137,7 +139,7 @@ module Units
 
     attr_reader :name, :converter
 
-    def initialize(name, converter = ::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
@@ -149,7 +151,7 @@ module Units
     end
 
     def ==(other)
-      other.is_a?(::Units::BaseUnit) && other.name == @name && other.converter == @converter
+      other.is_a?(Units::BaseUnit) && other.name == @name && other.converter == @converter
     end
 
     alias eql? ==
@@ -159,7 +161,7 @@ module Units
     end
 
     def to_s
-      if ::Units::Converter.current.includes?(converter)
+      if Units::Converter.current.includes?(converter)
         @name.to_s
       else
         "#{@converter}:#{@name}"
@@ -202,13 +204,13 @@ module Units
     #
     # See also Converter, Converter.converter
     def initialize(units = {}, converter = nil)
-      conv = proc { converter ||= ::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? ::Units::BaseUnit
+          k = conv[].base_unit(k.to_sym) if not k.is_a? Units::BaseUnit
           @units[k] = v
         end
       end
@@ -221,7 +223,7 @@ module Units
       @units.each_pair do |u, e|
         result[u] = e * p
       end
-      ::Units::Unit.new(result)
+      Units::Unit.new(result)
     end
 
     # Multiplies with the given Unit.
@@ -240,18 +242,18 @@ module Units
     end
 
     def coerce(other) # :nodoc:
-      return [::Units::Unit.new({}), self] if other == 1
-      ::Units::Converter.coerce_units(self, other)
+      return [Units::Unit.new({}), self] if other == 1
+      Units::Converter.coerce_units(self, other)
     end
 
     def simplify
-      ::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?(::Units::Unit) && other.units == units
+      other.is_a?(Units::Unit) && other.units == units
     end
 
     alias eql? ==
@@ -264,7 +266,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 = ::Units::Converter.coerce_units(self, other)
+      conv1, conv2 = Units::Converter.coerce_units(self, other)
       conv1.units == conv2.units
     end
 
@@ -288,11 +290,11 @@ module Units
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        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)
+        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 * ::Units::Unit.new({m => 1}, ::Units::Converter.current)
+        return self * Units::Unit.new({m => 1}, Units::Converter.current)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -302,7 +304,7 @@ module Units
     private
 
     def decode_string(s, converter)
-      if ::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
@@ -316,9 +318,9 @@ module Units
     end
 
     def decode_multiplicative_string(s, multiplier, converter, result)
-      s.scan(::Units::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
+      s.scan(Units::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
         if unit
-          conv = ::Units::Converter.converter(conv)
+          conv = Units::Converter.converter(conv)
         else
           conv, unit = converter[], conv
         end
@@ -336,13 +338,13 @@ module Units
 
     def do_op(op, dual_op, other)
       other = other.to_unit
-      raise TypeError, "cannot convert to Unit" unless ::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
-      ::Units::Unit.new(result)
+      Units::Unit.new(result)
     end
 
   end
@@ -413,7 +415,7 @@ module Units
     %w{ * / }.each do |op|
       eval %{
         def #{op}(other)
-          ::Units::Value.new(*do_multiplicative_op(:#{op}, other))
+          Units::Value.new(*do_multiplicative_op(:#{op}, other))
         end
       }
     end
@@ -421,14 +423,14 @@ module Units
     %w{ + - modulo remainder % }.each do |op|
       eval %{
         def #{op}(other)
-          ::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, ::Units::Value.new(r, unit)]
+      [q, Units::Value.new(r, unit)]
     end
 
     def div(other)
@@ -444,7 +446,7 @@ module Units
     end
 
     def **(other) # :nodoc:
-      ::Units::Value.new(@value ** other, @unit ** other)
+      Units::Value.new(@value ** other, @unit ** other)
     end
 
     def <=>(other) # :nodoc:
@@ -466,7 +468,7 @@ module Units
     %w{ abs ceil floor next round succ truncate }.each do |op|
       eval %{
         def #{op}
-          ::Units::Value.new(@value.#{op}, @unit)
+          Units::Value.new(@value.#{op}, @unit)
         end
       }
     end
@@ -486,16 +488,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 ::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
-      ::Units::Value.new(value * mult, to_unit)
+      Units::Value.new(value * mult, to_unit)
     end
 
     def coerce(other) # :nodoc:
       if ::Numeric === other
-        [::Units::Value.new!(other, ::Units::Unit.new), self]
+        [Units::Value.new!(other, Units::Unit.new), self]
       else
         super
       end
@@ -510,7 +512,7 @@ module Units
     # exception otherwise.
     def to_f
       val = simplify
-      if ::Units::Value === val
+      if Units::Value === val
         raise TypeError, "Cannot convert to float"
       else
         val.to_f
@@ -521,7 +523,7 @@ module Units
     # exception otherwise.
     def to_i
       val = simplify
-      if ::Units::Value === val
+      if Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_i
@@ -532,7 +534,7 @@ module Units
     # exception otherwise.
     def to_int
       val = simplify
-      if ::Units::Value === val
+      if Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_int
@@ -546,7 +548,7 @@ module Units
       if new_unit.unitless?
         @value * mul
       else
-        ::Units::Value.new(@value * mul, new_unit)
+        Units::Value.new(@value * mul, new_unit)
       end
     end
 
@@ -559,11 +561,11 @@ module Units
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        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)
+        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 * ::Units::Value.new(1, ::Units::Unit.new({m => 1}, ::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
@@ -573,9 +575,9 @@ module Units
   private
 
     def self.decode_string(s, converter)
-      if m = ::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 = ::Units::Unit.new(m[3], converter)
+        unit = Units::Unit.new(m[3], converter)
         [value, unit]
       else
         raise ::ArgumentError, "Illegal value string #{s.dump}"
@@ -584,8 +586,8 @@ module Units
 
     def do_additive_op(op, other)
       other = other.to_value
-      raise TypeError, "cannot convert to Value" unless ::Units::Value === other
-      if other.is_a? ::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
@@ -602,9 +604,9 @@ module Units
 
     def do_multiplicative_op(op, other)
       case other
-      when ::Units::Value
+      when Units::Value
         [value.send(op, other.value), unit.send(op, other.unit)]
-      when ::Units::Unit
+      when Units::Unit
         [value, unit.send(op, other)]
       when ::Numeric
         [value.send(op, other), unit]
@@ -613,7 +615,7 @@ module Units
         #       Problem : how check whether to_value failed without
         #                 masking all exceptions?
         other = other.to_value
-        raise TypeError, "cannot convert to Value" unless ::Units::Value === other
+        raise TypeError, "cannot convert to Value" unless Units::Value === other
         do_multiplicative_op(op, other)
       end
     end
@@ -672,7 +674,7 @@ module Units
     # Included the given converter in the receiver, unless it
     # was already included.
     def include(conv)
-      conv = ::Units::Converter.converter(conv) if not conv.is_a?(::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
@@ -681,7 +683,7 @@ module Units
     # Returns whether the given converter was included in the
     # receiver.
     def includes?(conv)
-      conv = ::Units::Converter.converter(conv) if not conv.is_a?(::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)
@@ -713,7 +715,7 @@ module Units
     # Returns the base unit with this name
     def base_unit(name)
       if conv = registered?(name)
-        return ::Units::BaseUnit.new(name, conv)
+        return Units::BaseUnit.new(name, conv)
       end
       raise "unit #{name.to_s.dump} not registered with #{self}"
     end
@@ -727,7 +729,7 @@ module Units
     def method_missing(m, *args, &blk)
       if registered?(m)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return ::Units::Unit.new({m => 1}, self)
+        return Units::Unit.new({m => 1}, self)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -793,12 +795,12 @@ module Units
         abbrev = info[:abbrev]
         multiplier = info[:multiplier] || 1
         power = info[:power] || 1
-        register_unit(pre + unit, :equals => {:unit => ::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 => ::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 => ::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
@@ -819,9 +821,9 @@ module Units
                 :multiplier => data[:multiplier] || data['multiplier']}
       end
       if /^\s*1\s*\// =~ data
-        {: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)
+        {: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}
@@ -829,7 +831,7 @@ module Units
           {:unit => unit}
         end
       else
-        {:unit => ::Units::Unit.new(data, self)}
+        {:unit => Units::Unit.new(data, self)}
       end
     end
 
@@ -858,8 +860,8 @@ module Units
       end
 
       def with_converter(conv) # :nodoc:
-        conv = converter(conv) if not conv.is_a? ::Units::Converter
-        raise ::ArgumentError, "Converter expected" if not conv.is_a? ::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[THREAD_REFERENCE]
           if old_conv
@@ -920,7 +922,7 @@ module Units
         units.each_pair do |u, e|
           (u.conversion != :none ? other_units : base_units)[u] = e
         end
-        result = Conversion.new(::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
@@ -945,16 +947,17 @@ module Units
   end
 
 end
+end
 
 class Numeric
   #
   def method_missing(m, *args, &blk)
     if args.length == 1
-      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)
+      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)
       raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-      return ::Units::Value.new(self, ::Units::Unit.new({m => 1}, ::Units::Converter.current))
+      return Stick::Units::Value.new(self, Stick::Units::Unit.new({m => 1}, Stick::Units::Converter.current))
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -963,7 +966,7 @@ class Numeric
 
   #
   def to_value(unit)
-    ::Units::Value.new(self, unit)
+    Stick::Units::Value.new(self, unit)
   end
 end
 
@@ -971,11 +974,11 @@ end
 class String
   #
   def to_unit(converter = nil)
-    ::Units::Unit.new(self, converter)
+    Stick::Units::Unit.new(self, converter)
   end
 
   #
   def to_value(converter = nil)
-    ::Units::Value.new(self, converter)
+    Stick::Units::Value.new(self, converter)
   end
 end