quantify 3.0.0 → 3.1.0

data/VERSION

@@ -1 +1 @@
-3.0.0
+3.1.0

data/lib/quantify/core_extensions/string.rb

@@ -22,7 +22,17 @@ class String
   end
 
   def starts_with_number?
-    (/\A([\d\s.,]+)/i).match(self) ? true : false
+    (/\A#{Unit::NUMBER_REGEX}/i).match(self) ? true : false
+  end
+  
+  def starts_with_valid_unit_term?
+    return false unless 
+    term = /\A#{Unit.unit_label_regex}#{Unit::INDEX_REGEX}?/.match(self) || 
+           /\A#{Unit.unit_symbol_regex}#{Unit::INDEX_REGEX}?/.match(self) || 
+           /\A#{Unit.unit_name_regex}#{Unit::INDEX_REGEX}?/.match(self)  || 
+           /\A#{Unit::UNIT_DENOMINATOR_REGEX}/.match(self) || 
+           /\A(#{Unit::UNIT_PREFIX_TERMS_REGEX}|#{Unit::UNIT_SUFFIX_TERMS_REGEX})/i.match(self) 
+    return term[0]
   end
 
   def to_quantity

data/lib/quantify/inflections.rb

@@ -1,8 +1,6 @@
 
 ActiveSupport::Inflector.inflections do |inflect|
 
-  inflect.uncountable %w( clo hertz lux siemens )
-
   inflect.plural /(metre)/i, '\1s'
   inflect.singular /(metre)s?/i, '\1'
 
@@ -27,9 +25,11 @@ ActiveSupport::Inflector.inflections do |inflect|
   inflect.plural /(gallon)/i, '\1s'
   inflect.singular /(gallon)s?/i, '\1'
 
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
   inflect.plural /(horsepower)/i, '\1'
   inflect.singular /(horsepower)/i, '\1'
 
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
   inflect.plural /(hundredweight)/i, '\1'
   inflect.singular /(hundredweight)/i, '\1'
 
@@ -48,6 +48,10 @@ ActiveSupport::Inflector.inflections do |inflect|
   inflect.plural /(pound)/i, '\1s'
   inflect.singular /(pound)s?/i, '\1'
 
+  # This inflection is defined after that of 'pound' so that 'pound mole' is inflected appropriately
+  inflect.plural /(mole)/i, '\1s'
+  inflect.singular /(mole)s?/i, '\1'
+  
   inflect.plural /(ton)/i, '\1s'
   inflect.singular /(ton)s?/i, '\1'
 
@@ -56,7 +60,27 @@ ActiveSupport::Inflector.inflections do |inflect|
 
   inflect.plural /(stone)/i, '\1s'
   inflect.singular /(stone)s?/i, '\1'
-
+  
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
+  inflect.plural /(gauss)/i, '\1'
+  inflect.singular /(gauss)/i, '\1'
+
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
+  inflect.plural /(clo)/i, '\1'
+  inflect.singular /(clo)/i, '\1'
+
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
+  inflect.plural /(hertz)/i, '\1'
+  inflect.singular /(hertz)/i, '\1'
+  
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
+  inflect.plural /(lux)/i, '\1'
+  inflect.singular /(lux)/i, '\1'
+  
+  # 'uncountable' but required regex inflection definition for cases where combined with prefix
+  inflect.plural /(siemens)/i, '\1'
+  inflect.singular /(siemens)/i, '\1'
+  
   inflect.irregular 'footcandle', 'footcandles'
   inflect.irregular 'kilowatt hour', 'kilowatt hours'
 

data/lib/quantify/quantity.rb

@@ -41,8 +41,6 @@ module Quantify
     #
     #       16.Gg                                       #=> Quantity (gigagrams)
 
-
-
     # Parse a string and return a Quantity object based upon the value and
     # subseqent unit name, symbol or JScience label. Returns an array containing
     # quantity objects for each quantity recognised.
@@ -53,7 +51,7 @@ module Quantify
           # Isolate number from subsequent string
           value, string = word, words[index+1..-1].join(" ")
           # Shift any trailing non-numeric characters to start of string.
-          value, string = $1, "#{$2} #{string}" if (/([\d\s.,]+)([^\d\s.,\^]+(\^[\d\.-]*)?)/i).match(word)
+          value, string = $1, "#{$2} #{string}" if (Unit::QUANTITY_REGEX).match(word)
           # Parse string for unit references
           unit = Unit.parse(string, :iterative => true) || Unit.dimensionless
           # Instantiate quantity using value and unit
@@ -77,7 +75,7 @@ module Quantify
         !new_unit.is_compound_unit?
       return false
     end
-
+    
     public
 
     attr_accessor :value, :unit
@@ -150,40 +148,7 @@ module Quantify
         nil # raise? or ...
       end      
     end
-
-    # Conversion where both units (including compound units) are of precisely
-    # equivalent dimensions, i.e. direct alternatives for one another. Where
-    # previous unit is a compound unit, new unit must be cancelled by all original
-    # base units
-    #
-    def convert_to_equivalent_unit!(new_unit)
-      old_unit = @unit
-      self.multiply!(Unit.ratio new_unit, old_unit)
-      old_base_units = old_unit.base_units.map { |base| base.unit } if old_unit.is_compound_unit?
-      self.cancel_base_units!(*old_base_units || old_unit)
-    end
-
-    def conversion_with_scalings!(new_unit)
-      @value = (((@value + @unit.scaling) * @unit.factor) / new_unit.factor) - new_unit.scaling
-      @unit = new_unit
-      return self
-    end
-
-    # Conversion where self is a compound unit, and new unit is not an alternative
-    # to the whole compound but IS an alternative to one or more of the base units,
-    # e.g.,
-    #
-    #   Unit.kilowatt_hour.to :second           #=> 'kilowatt second'
-    #
-    def convert_compound_unit_to_non_equivalent_unit!(new_unit)
-      @unit.base_units.select do |base|
-        base.unit.is_alternative_for? new_unit
-      end.inject(self) do |quantity,base|
-        factor = Unit.ratio(new_unit**base.index, base.unit**base.index)
-        quantity.multiply!(factor).cancel_base_units!(base.unit)
-      end
-    end
-
+    
     # Converts a quantity to the equivalent quantity using only SI units
     def to_si
       if @unit.is_compound_unit?
@@ -192,49 +157,7 @@ module Quantify
         self.to(@unit.si_unit)
       end
     end
-
-    def convert_compound_unit_to_si!
-      until @unit.is_base_quantity_si_unit? do
-        unit = @unit.base_units.find do |base|
-          !base.is_base_quantity_si_unit?
-        end.unit
-        self.convert_compound_unit_to_non_equivalent_unit!(unit.si_unit)
-      end
-      return self
-    end
-
-    # Quantities must be of the same dimension in order to operate. If they are
-    # represented by different units (but represent the same physical quantity)
-    # the second quantity is converted into the unit belonging to the first unit
-    # and the addition is completed
-    #
-    def add_or_subtract!(operator,other)
-      if other.is_a? Quantity
-        other = other.to(@unit) if other.unit.is_alternative_for?(@unit)
-        if @unit.is_equivalent_to? other.unit
-          @value = @value.send operator, other.value
-          return self
-        else
-          raise Quantify::Exceptions::InvalidObjectError "Cannot add or subtract Quantities with different dimensions"
-        end
-      else
-        raise Quantify::Exceptions::InvalidObjectError "Cannot add or subtract non-Quantity objects"
-      end
-    end
-
-    def multiply_or_divide!(operator,other)
-      if other.kind_of? Numeric
-        @value = @value.send(operator,other)
-        return self
-      elsif other.kind_of? Quantity
-        @unit = @unit.send(operator,other.unit).or_equivalent
-        @value = @value.send(operator,other.value)
-        return self
-      else
-        raise Quantify::Exceptions::InvalidArgumentError "Cannot multiply or divide a Quantity by a non-Quantity or non-Numeric object"
-      end
-    end
-
+    
     def pow!(power)
       raise Exceptions::InvalidArgumentError, "Argument must be an integer" unless power.is_a? Integer
       @value = @value ** power
@@ -331,8 +254,82 @@ module Quantify
       range.include? self
     end
 
-    protected :convert_compound_unit_to_si!, :add_or_subtract!, :multiply_or_divide!
+    protected
+    
+    # Quantities must be of the same dimension in order to operate. If they are
+    # represented by different units (but represent the same physical quantity)
+    # the second quantity is converted into the unit belonging to the first unit
+    # and the addition is completed
+    #
+    def add_or_subtract!(operator,other)
+      if other.is_a? Quantity
+        other = other.to(@unit) if other.unit.is_alternative_for?(@unit)
+        if @unit.is_equivalent_to? other.unit
+          @value = @value.send operator, other.value
+          return self
+        else
+          raise Quantify::Exceptions::InvalidObjectError, "Cannot add or subtract Quantities with different dimensions"
+        end
+      else
+        raise Quantify::Exceptions::InvalidObjectError, "Cannot add or subtract non-Quantity objects"
+      end
+    end
+
+    def multiply_or_divide!(operator,other)
+      if other.kind_of? Numeric
+        @value = @value.send(operator,other)
+        return self
+      elsif other.kind_of? Quantity
+        @unit = @unit.send(operator,other.unit).or_equivalent
+        @value = @value.send(operator,other.value)
+        return self
+      else
+        raise Quantify::Exceptions::InvalidArgumentError, "Cannot multiply or divide a Quantity by a non-Quantity or non-Numeric object"
+      end
+    end
+    
+    # Conversion where both units (including compound units) are of precisely
+    # equivalent dimensions, i.e. direct alternatives for one another. Where
+    # previous unit is a compound unit, new unit must be cancelled by all original
+    # base units
+    #
+    def convert_to_equivalent_unit!(new_unit)
+      old_unit = @unit
+      self.multiply!(Unit.ratio new_unit, old_unit)
+      old_base_units = old_unit.base_units.map { |base| base.unit } if old_unit.is_compound_unit?
+      self.cancel_base_units!(*old_base_units || old_unit)
+    end
+
+    def conversion_with_scalings!(new_unit)
+      @value = (((@value + @unit.scaling) * @unit.factor) / new_unit.factor) - new_unit.scaling
+      @unit = new_unit
+      return self
+    end
 
+    # Conversion where self is a compound unit, and new unit is not an alternative
+    # to the whole compound but IS an alternative to one or more of the base units,
+    # e.g.,
+    #
+    #   Unit.kilowatt_hour.to :second           #=> 'kilowatt second'
+    #
+    def convert_compound_unit_to_non_equivalent_unit!(new_unit)
+      @unit.base_units.select do |base|
+        base.unit.is_alternative_for? new_unit
+      end.inject(self) do |quantity,base|
+        factor = Unit.ratio(new_unit**base.index, base.unit**base.index)
+        quantity.multiply!(factor).cancel_base_units!(base.unit)
+      end
+    end
+    
+    def convert_compound_unit_to_si!
+      until @unit.is_base_quantity_si_unit? do
+        unit = @unit.base_units.find do |base|
+          !base.is_base_quantity_si_unit?
+        end.unit
+        self.convert_compound_unit_to_non_equivalent_unit!(unit.si_unit)
+      end
+      return self
+    end
 
     # Enables shorthand for reciprocal of quantity, e.g.
     #

data/lib/quantify/unit/base_unit.rb

@@ -17,6 +17,14 @@ module Quantify
       def self.construct_and_load(unit,&block)
         self.construct(unit, &block).load
       end
+      
+      def self.initialize_prefixed_version(prefix,unit)
+        prefix, unit = Prefix.for(prefix), Unit.for(unit)
+        raise Exceptions::InvalidArgumentError, "Prefix is not known" if prefix.nil?
+        raise Exceptions::InvalidArgumentError, "Unit is not known" if unit.nil?
+        raise Exceptions::InvalidArgumentError, "Cannot add prefix where one already exists: #{unit.prefix.name}" if unit.prefix
+        self.new &self.block_for_prefixed_version(prefix,unit)
+      end
 
       # Mass load prefixed units. First argument is a single or array of units.
       # Second argument is a single or array of prefixes. All specfied units will
@@ -36,9 +44,9 @@ module Quantify
       # unit becomes a representation of the compound - without explicitly holding
       # the base units, e.g.
       #
-      #   Unit::Base.define(Unit.m**2).name              #=> "square metre"
+      #   Unit::Base.construct(Unit.m**2).name           #=> "square metre"
       #
-      #   Unit::Base.define(Unit**3) do |unit|
+      #   Unit::Base.construct(Unit.m**3) do |unit|
       #     unit.name = "metres cubed"
       #   end.name                                       #=> "metres cubed"
       #
@@ -65,6 +73,7 @@ module Quantify
       
       attr_reader :name, :symbol, :label, :factor, :dimensions
       attr_reader :acts_as_alternative_unit, :acts_as_equivalent_unit
+      attr_accessor :base_unit, :prefix
 
       # Create a new Unit::Base instance.
       #
@@ -104,10 +113,13 @@ module Quantify
         self.factor = 1.0
         self.symbol = nil
         self.label = nil
+        self.name = nil
+        self.base_unit = nil
+        self.prefix = nil
         if options.is_a? Hash
-          self.dimensions = options[:dimensions] || options[:physical_quantity]
-          self.name = options[:name]
+          self.dimensions = options[:dimensions] || options[:physical_quantity] if options[:dimensions] || options[:physical_quantity] 
           self.factor = options[:factor] if options[:factor]
+          self.name = options[:name] if options[:name]
           self.symbol = options[:symbol] if options[:symbol]
           self.label = options[:label] if options[:label]
         end
@@ -303,9 +315,7 @@ module Quantify
 
       # Determine if the unit is a prefixed unit
       def is_prefixed_unit?
-        return true if valid_prefixes.size > 0 &&
-          self.name =~ /\A(#{valid_prefixes.map {|p| p.name}.join("|")})/
-        return false
+        self.prefix ? true : false
       end
 
       # Determine if the unit is one of the units against which all other units
@@ -428,31 +438,6 @@ module Quantify
         @dimensions.is_a? Dimensions
       end
 
-      # Returns an array representing the valid prefixes for the unit described 
-      # by self
-      #
-      # If no argument is given, the array holds instances of Prefix::Base (or
-      # subclasses; SI, NonSI...). Alternatively only the names or symbols of each
-      # prefix can be returned by providing the appropriate prefix attribute as a
-      # symbolized argument, e.g.
-      #
-      #   Unit.m.valid_prefixes                 #=> [ #<Quantify::Prefix: .. >,
-      #                                               #<Quantify::Prefix: .. >,
-      #                                               ... ]
-      #
-      #   Unit.m.valid_prefixes :name           #=> [ "deca", "hecto", "kilo", 
-      #                                               "mega", "giga", "tera"
-      #                                               ... ]    
-      #
-      #   Unit.m.valid_prefixes :symbol         #=> [ "da", "h", "k", "M", "G",
-      #                                               "T", "P" ... ]
-      #
-      def valid_prefixes(by=nil)
-        return [] if is_compound_unit? && has_multiple_base_units?
-        return Unit::Prefix.si_prefixes.map(&by).to_a if is_si_unit?
-        return Unit::Prefix.non_si_prefixes.map(&by).to_a if is_non_si_unit?
-      end
-
       # Multiply two units together. This results in the generation of a compound
       # unit.
       #
@@ -513,15 +498,7 @@ module Quantify
       # of self, complete with modified name, symbol, factor, etc..
       #
       def with_prefix(name_or_symbol)
-        raise Exceptions::InvalidArgumentError, "No valid prefixes exist for unit: #{self.name}" if valid_prefixes.empty?
-        raise Exceptions::InvalidArgumentError, "Cannot add prefix where one already exists: #{self.name}" if @name =~ /\A(#{valid_prefixes(:name).join("|")})/
-        
-        prefix = Unit::Prefix.for(name_or_symbol,valid_prefixes)
-        if !prefix.nil?
-          self.class.new(options_for_prefixed_version(prefix))
-        else
-          raise Exceptions::InvalidArgumentError, "Prefix unit is not known: #{prefix}"
-        end
+        self.class.initialize_prefixed_version(name_or_symbol,self)
       end
 
       # Return an array of new unit instances based upon self, together with the
@@ -558,16 +535,6 @@ module Quantify
       end
 
       private
-
-      def options_for_prefixed_version(prefix)
-        options = {}
-        options[:name] = "#{prefix.name}#{@name}"
-        options[:symbol] = "#{prefix.symbol}#{@symbol}"
-        options[:label] = "#{prefix.symbol}#{@label}"
-        options[:factor] = prefix.factor * @factor
-        options[:physical_quantity] = @dimensions
-        return options
-      end
       
       # Clone self and explicitly clone the associated Dimensions object located
       # at @dimensions.
@@ -581,6 +548,18 @@ module Quantify
         super
         instance_variable_set("@dimensions", @dimensions.clone)
       end
+      
+      def self.block_for_prefixed_version(prefix,unit)
+        return Proc.new do |new_unit| 
+          new_unit.base_unit  = unit.clone
+          new_unit.prefix     = prefix
+          new_unit.dimensions = unit.dimensions.clone
+          new_unit.name       = "#{prefix.name}#{unit.name}"
+          new_unit.factor     = prefix.factor * unit.factor
+          new_unit.symbol     = "#{prefix.symbol}#{unit.symbol}"
+          new_unit.label      = "#{prefix.symbol}#{unit.label}"
+        end
+      end
 
       # Provides syntactic sugar for several methods. E.g.
       #
@@ -597,8 +576,6 @@ module Quantify
           return self.with_prefix(prefix)
         elsif method.to_s =~ /(alternatives_by_)(.*)/ && self.respond_to?($2.to_sym)
           return self.alternatives($2.to_sym)
-        elsif method.to_s =~ /(valid_prefixes_by_)(.*)/ && Prefix::Base.instance_methods.include?($2.to_s)
-          return self.valid_prefixes($2.to_sym)
         end
         super
       end

data/lib/quantify/unit/compound_unit.rb

@@ -19,7 +19,14 @@ module Quantify
       #
       # The Compound class provides support for arbitrarily defined compound units
       # which don't have well-established names.
-
+      
+      def self.initialize_prefixed_version(prefix,compound)
+        if compound.has_multiple_base_units? 
+          raise Exceptions::InvalidArgumentError, "Cannot apply prefix to compound unit with multiple base units: #{self.name}" 
+        end
+        super
+      end
+      
       attr_reader :base_units, :acts_as_equivalent_unit
 
       # Initialize a compound unit by providing an array containing a represenation
@@ -34,7 +41,7 @@ module Quantify
       #  3. a sub-array of size 2 containing an instance of Unit::Base and an
       #     explicit index
       #
-      def initialize(*units)
+      def initialize(*units,&block)
         @base_units = CompoundBaseUnitList.new
         units.each do |unit|
           if unit.is_a? CompoundBaseUnit
@@ -50,6 +57,7 @@ module Quantify
         end
         @acts_as_alternative_unit = true
         @acts_as_equivalent_unit = false
+        block.call(self) if block_given?
         consolidate_numerator_and_denominator_units!
       end
 
@@ -180,23 +188,24 @@ module Quantify
         @base_units.rationalize_numerator_and_denominator!(*units)
         initialize_attributes
       end
-
+      
       private
 
       def initialize_attributes
         self.dimensions = @base_units.dimensions
-        self.name = @base_units.name
-        self.symbol = @base_units.symbol
-        self.factor = @base_units.factor
-        self.label = @base_units.label
+        self.name       = @base_units.name
+        self.symbol     = @base_units.symbol
+        self.factor     = @base_units.factor
+        self.label      = @base_units.label
         return self
       end
-
-      def options_for_prefixed_version(prefix)
-        raise Exceptions::InvalidArgumentError, "No valid prefixes exist for unit: #{self.name}" if has_multiple_base_units?
-        base = @base_units.first
+      
+      def self.block_for_prefixed_version(prefix,compound)
+        base = compound.base_units.first
         base.unit = base.unit.with_prefix(prefix)
-        return base
+        return Proc.new do |compound|
+          compound.base_units << base
+        end
       end
 
       def initialize_copy(source)

data/lib/quantify/unit/prefix/prefix.rb

@@ -22,10 +22,10 @@ module Quantify
         @prefixes
       end    
 
-      def self.for(name_or_symbol,collection=nil)
+      def self.for(name_or_symbol)
         return name_or_symbol.clone if name_or_symbol.is_a? Quantify::Unit::Prefix::Base
         if name_or_symbol.is_a?(String) || name_or_symbol.is_a?(Symbol)
-          if prefix = (collection.nil? ? @prefixes : collection).find do |prefix|
+          if prefix = @prefixes.find do |prefix|
              prefix.name == name_or_symbol.remove_underscores.downcase ||
              prefix.symbol == name_or_symbol.remove_underscores
             end
@@ -64,7 +64,7 @@ module Quantify
         elsif prefix = self.for(method)
           return prefix
         else
-          raise NoMethodError, "Undefined method `#{method}` for #{self}:#{self.class}"
+          super
         end
       end
 

data/lib/quantify/unit/unit.rb

@@ -4,7 +4,7 @@ module Quantify
   module Unit
 
     extend ExtendedMethods
-
+    
     # The Unit module contains functionality for defining and handling
     # representations of physical units.
     #
@@ -19,7 +19,24 @@ module Quantify
     # prefixes specified in config.rb. New units can be defined (with or without
     # prefixes) at any time and either used in place or loaded into the known
     # system.
+    
+    NUMBER_REGEX            = /([\d\s.,]+)/i
+      
+    UNIT_DENOMINATOR_REGEX  = /(\/|per)/i
+      
+    ORDINAL_SUFFIXES_REGEX  = /(st|nd|rd|th)\b/i
+        
+    UNIT_PREFIX_TERMS_REGEX = /\A(square|cubic)\b/i
+    
+    INDEX_REGEX             = /\^?([\d\.-]*)/
 
+    WORD_WITH_INDEX_REGEX   = /([^\d\s.,\^]+)#{INDEX_REGEX}?/i
+
+    UNIT_SUFFIX_TERMS_REGEX = /\A(squared|cubed|to the \d+(#{ORDINAL_SUFFIXES_REGEX}) power)\b/i
+    
+    QUANTITY_REGEX          = /#{Unit::NUMBER_REGEX}(#{Quantify::Unit::WORD_WITH_INDEX_REGEX})/i
+    
+    
     class << self
       attr_reader :units
     end
@@ -221,6 +238,13 @@ module Quantify
       return nil
     end
 
+    def self.match(name_symbol_or_label)
+      return name_symbol_or_label.clone if name_symbol_or_label.is_a? Unit::Base
+      Unit.match_known_unit_or_prefixed_variant(:label, name_symbol_or_label) or
+      Unit.match_known_unit_or_prefixed_variant(:name, name_symbol_or_label) or
+      Unit.match_known_unit_or_prefixed_variant(:symbol, name_symbol_or_label)
+    end
+    
     # Parse complex strings into unit.
     #
     def self.parse(string, options={})
@@ -230,21 +254,43 @@ module Quantify
       return units.first.unit if units.size == 1 && units.first.index == 1
       return Unit::Compound.new(*units)
     end
+    
+    # This returns the suite of units which represents THE SI units for each of
+    # the base dimensions, i.e. metre, kilogram, second, etc. but not prefixed
+    # versions of the same unit
+    #
+    def self.base_quantity_si_units
+      @units.select {|unit| unit.is_base_quantity_si_unit? }
+    end
+    
+    # This can be replicated by method missing approach, but explicit method provided
+    # given importance in #match (and #for) methods regexen
+    #
+    def self.non_prefixed_units
+      @units.select {|unit| !unit.is_prefixed_unit? }
+    end
 
-    def self.match(name_symbol_or_label)
-      return name_symbol_or_label.clone if name_symbol_or_label.is_a? Unit::Base
-      Unit.match_known_unit_or_prefixed_variant(:label, name_symbol_or_label) or
-      Unit.match_known_unit_or_prefixed_variant(:name, name_symbol_or_label) or
-      Unit.match_known_unit_or_prefixed_variant(:symbol, name_symbol_or_label)
+    # This can be replicated by method missing approach, but explicit method provided
+    # given importance in #match (and #for) methods regexen
+    #
+    def self.si_non_prefixed_units
+      @units.select {|unit| unit.is_si_unit? && !unit.is_prefixed_unit? }
     end
 
+    # This can be replicated by method missing approach, but explicit method provided
+    # given importance in #match (and #for) methods regexen
+    #
+    def self.non_si_non_prefixed_units
+      @units.select {|unit| unit.is_non_si_unit? && !unit.is_prefixed_unit? }
+    end
+    
     protected
-
+    
     def self.match_known_unit_or_prefixed_variant(attribute, string_or_symbol)
       Unit.match_known_unit(attribute, string_or_symbol) or
       Unit.match_prefixed_variant(attribute, string_or_symbol)
     end
-
+    
     def self.match_known_unit(attribute, string_or_symbol)
       string_or_symbol = Unit.format_unit_attribute(attribute, string_or_symbol)
       @units.find do |unit|
@@ -256,46 +302,52 @@ module Quantify
         end
       end.clone rescue nil
     end
-
+    
     def self.match_prefixed_variant(attribute, string_or_symbol)
       string_or_symbol = Unit.format_unit_attribute(attribute, string_or_symbol)
-      if string_or_symbol =~ /\A(#{units_for_regex(Unit::Prefix,:si_prefixes,attribute)})(#{units_for_regex(Unit,:si_non_prefixed_units,attribute)})\z/ ||
-         string_or_symbol =~ /\A(#{units_for_regex(Unit::Prefix,:non_si_prefixes,attribute)})(#{units_for_regex(Unit,:non_si_non_prefixed_units,attribute)})\z/
+      if string_or_symbol =~ /\A(#{Unit.terms_for_regex(Unit::Prefix,:prefixes,attribute)})(#{Unit.terms_for_regex(Unit,:non_prefixed_units,attribute)})\z/
         return Unit.for($2).with_prefix($1).clone
       end
       return nil
     end
-
+    
     def self.simple_parse(string)
-      if string.scan(/(\/|per)/).size > 1
+      if string.scan(UNIT_DENOMINATOR_REGEX).size > 1
         raise Exceptions::InvalidArgumentError, "Malformed unit: multiple uses of '/' or 'per'"
       end
       units = []
-      numerator, per, denominator = string.split(/(\/|per)/)
+      numerator, per, denominator = string.split(UNIT_DENOMINATOR_REGEX)
       units += Unit.parse_numerator_units(numerator)
       units += Unit.parse_denominator_units(denominator) unless denominator.nil?
       return units
     end
-
+    
     def self.iterative_parse(string)
       units=[]
-      current_set = "numerator_units"
-      while unit = Unit.unit_label_regex.match(string) || unit = Unit.unit_symbol_regex.match(string) ||
-          unit = Unit.unit_name_regex.match(string) || unit = Unit.unit_denominator_regex.match(string) do
-        if unit[0] =~ Unit.unit_denominator_regex
-          current_set = "denominator_units"
+      is_denominator = false
+      current_exponent = nil
+      while term = string.starts_with_valid_unit_term? do  
+        if term =~ /^#{UNIT_PREFIX_TERMS_REGEX}$/
+          current_exponent = Unit.exponent_term_to_number(term)
+        elsif term =~ /^#{UNIT_SUFFIX_TERMS_REGEX}$/
+          units.last.index *= Unit.exponent_term_to_number(term)
+        elsif term =~ /^#{UNIT_DENOMINATOR_REGEX}/
+          is_denominator = true
         else
-          units += Unit.send("parse_#{current_set}".to_sym, unit[0])
+          unit = Unit.send("parse_#{is_denominator ? 'denominator' : 'numerator'}_units".to_sym, term).first
+          unit.index *= current_exponent if current_exponent
+          units << unit
+          current_exponent = nil
         end
         # Remove matched pattern from string for next iteration
-        match_length = unit[0].size
+        match_length = term.size
         string = string[match_length, string.length-match_length].strip
       end
       return units
     end
     
     def self.parse_unit_and_index(string)
-      string.scan(/([^0-9\^]+)\^?([\d\.-]*)?/i)
+      string.scan(WORD_WITH_INDEX_REGEX)
       index = ($2.nil? || $2.empty? ? 1 : $2.to_i)
       unit = Unit.match($1.to_s)
       if unit.is_a? Compound
@@ -304,7 +356,7 @@ module Quantify
         return CompoundBaseUnit.new($1.to_s, index)
       end
     end
-
+    
     def self.parse_numerator_units(string)
       # If no middot then names parsed by whitespace
       if string =~ /·/
@@ -316,14 +368,14 @@ module Quantify
         Unit.parse_unit_and_index(substring)
       end.flatten
     end
-
+    
     def self.parse_denominator_units(string)
       Unit.parse_numerator_units(string).map do |unit|
         unit.index *= -1
         unit
       end
     end
-
+  
     # standardize query strings or symbols into canonical form for unit names,
     # symbols and labels
     #
@@ -334,64 +386,24 @@ module Quantify
         else string_or_symbol.to_s
       end
       Unit.use_superscript_characters? ?
-        string_or_symbol.with_superscript_characters : string_or_symbol.without_superscript_characters
+      string_or_symbol.with_superscript_characters : string_or_symbol.without_superscript_characters
     end
     
-    # This returns the suite of units which represents THE SI units for each of
-    # the base dimensions, i.e. metre, kilogram, second, etc. but not prefixed
-    # versions of the same unit
-    #
-    def self.base_quantity_si_units
-      @units.select {|unit| unit.is_base_quantity_si_unit? }
-    end
-
-    # This can be replicated by method missing approach, but explicit method provided
-    # given importance in #match (and #for) methods regexen
-    #
-    def self.si_non_prefixed_units
-      @units.select {|unit| unit.is_si_unit? && !unit.is_prefixed_unit? }
-    end
-
-    # This can be replicated by method missing approach, but explicit method provided
-    # given importance in #match (and #for) methods regexen
-    #
-    def self.non_si_non_prefixed_units
-      @units.select {|unit| unit.is_non_si_unit? && !unit.is_prefixed_unit? }
-    end
-
     # Return a list of unit names which are multi-word
     def self.multi_word_unit_names
-      @units.map {|unit| unit.name if unit.name.word_count > 1 }.compact
+      Unit.units.map {|unit| unit.name if unit.name.word_count > 1 }.compact
     end
-
+    
     # Return a list of pluralised unit names which are multi-word
     def self.multi_word_unit_pluralized_names
       multi_word_unit_names.map {|name| name.pluralize }
     end
-
+    
     # Return a list of unit symbols which are multi-word
     def self.multi_word_unit_symbols
-      @units.map {|unit| unit.symbol if unit.symbol.word_count > 1 }.compact
-    end
-
-    # might want to try atomic groupings, but must get units in size order perhaps first
-    def self.unit_label_regex
-      /\A((#{Unit.units_for_regex(Unit::Prefix,:non_si_prefixes,:label)})?((#{Unit.units_for_regex(Unit,:non_si_non_prefixed_units,:label)})\b)|(#{Unit.units_for_regex(Unit::Prefix,:si_prefixes,:label)})?((#{Unit.units_for_regex(Unit,:si_non_prefixed_units,:label)})\b))(\^[\d\.-]*)?/
-    end
-
-    def self.unit_symbol_regex
-      /\A((#{Unit.units_for_regex(Unit::Prefix,:si_prefixes,:symbol)})?((#{Unit.units_for_regex(Unit,:si_non_prefixed_units,:symbol)})\b)|(#{Unit.units_for_regex(Unit::Prefix,:non_si_prefixes,:symbol)})?((#{Unit.units_for_regex(Unit,:non_si_non_prefixed_units,:symbol)})\b))(\^[\d\.-]*)?/
+      Unit.units.map {|unit| unit.symbol if unit.symbol.word_count > 1 }.compact
     end
-
-    def self.unit_name_regex
-      # Specifically case insensitive
-      /\A((#{Unit.units_for_regex(Unit::Prefix,:non_si_prefixes,:name)})?((#{Unit.units_for_regex(Unit,:non_si_non_prefixed_units,:pluralized_name)}|#{Unit.units_for_regex(Unit,:non_si_non_prefixed_units,:name)})\b)|(#{Unit.units_for_regex(Unit::Prefix,:si_prefixes,:name)})?((#{Unit.units_for_regex(Unit,:si_non_prefixed_units,:pluralized_name)}|#{Unit.units_for_regex(Unit,:si_non_prefixed_units,:name)})\b))(\^[\d\.-]*)?/i
-    end
-
-    def self.unit_denominator_regex
-      /\A(\/|per)/i
-    end
-
+    
     # Underscore any parts of string which represent multi-word unit identifiers
     # so that units can be parsed on whitespace
     #
@@ -401,14 +413,34 @@ module Quantify
       end
       string
     end
-
+    
+    def self.exponent_term_to_number(term)
+      return 2 if /square(d)?/i.match(term)
+      return 3 if /cub(ic|ed)/i.match(term)
+    end
+    
     # Returns a list of "|" separated unit identifiers for use as regex
     # alternatives. Lists are constructed by calling 
-    def self.units_for_regex(klass,method,attribute)
+    def self.terms_for_regex(klass,method,attribute)
       list = klass.send(method).map { |item| item.send(attribute).gsub("/","\\/").gsub("^","\\^")  }
       list.map! { |item| item.downcase } if attribute == :name
+      list.reject! { |item| item == "" }
       list.sort {|x, y| y.size <=> x.size }.join("|")
     end
-
+    
+    def self.unit_label_regex
+      /(#{Unit.terms_for_regex(Unit::Prefix,:prefixes,:label)})??((#{Unit.terms_for_regex(Unit,:non_prefixed_units,:label)})\b)/
+    end
+    
+    def self.unit_symbol_regex
+      /(#{Unit.terms_for_regex(Unit::Prefix,:prefixes,:symbol)})??((#{Unit.terms_for_regex(Unit,:non_prefixed_units,:symbol)})\b)/
+    end
+    
+    def self.unit_name_regex
+      # Specifically case insensitive
+      # Double '?' (i.e. '??') makes prefix matching lazy, e.g. "centimetres of mercury" is matched fully rather than as 'centimetres'
+      /(#{Unit.terms_for_regex(Unit::Prefix,:prefixes,:name)})??((#{Unit.terms_for_regex(Unit,:non_prefixed_units,:pluralized_name)}|#{Unit.terms_for_regex(Unit,:non_prefixed_units,:name)})\b)/i
+    end
+    
   end
 end

data/quantify.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{quantify}
-  s.version = "3.0.0"
+  s.name = "quantify"
+  s.version = "3.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Berkeley"]
-  s.date = %q{2011-11-08}
-  s.description = %q{A gem to support physical quantities and unit conversions}
-  s.email = %q{andrew.berkeley.is@googlemail.com}
+  s.date = "2011-12-21"
+  s.description = "A gem to support physical quantities and unit conversions"
+  s.email = "andrew.berkeley.is@googlemail.com"
   s.extra_rdoc_files = [
     "README"
   ]
@@ -30,7 +30,6 @@ Gem::Specification.new do |s|
     "lib/quantify/dimensions.rb",
     "lib/quantify/exception.rb",
     "lib/quantify/inflections.rb",
-    "lib/quantify/parser.rb",
     "lib/quantify/quantify.rb",
     "lib/quantify/quantity.rb",
     "lib/quantify/unit/base_unit.rb",
@@ -47,16 +46,15 @@ Gem::Specification.new do |s|
     "quantify.gemspec",
     "spec/compound_unit_spec.rb",
     "spec/dimension_spec.rb",
-    "spec/quantify_spec.rb",
     "spec/quantity_spec.rb",
     "spec/string_spec.rb",
     "spec/unit_spec.rb"
   ]
-  s.homepage = %q{https://github.com/spatchcock/quantify}
+  s.homepage = "https://github.com/spatchcock/quantify"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.3}
-  s.summary = %q{Support for handling physical quantities, unit conversions, etc}
+  s.rubygems_version = "1.8.10"
+  s.summary = "Support for handling physical quantities, unit conversions, etc"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/spec/compound_unit_spec.rb

@@ -285,22 +285,7 @@ describe Unit do
     
   end
 
-  describe "adding prefixes" do
-
-    it "should have no valid prefixes with multiple base units" do
-      (Unit.kg*Unit.m*Unit.m/Unit.s/Unit.s).valid_prefixes.should be_empty
-    end
-
-    it "should return SI prefixes with single SI unit" do
-      prefixes = (Unit.kg**3).valid_prefixes
-      prefixes.should_not be_empty
-      prefixes.first.should be_a Unit::Prefix::SI
-    end
-
-    it "should return SI prefixes with single SI unit" do
-      prefixes = (Unit.lb**3).valid_prefixes
-      prefixes.should be_empty # no NonSI prefixes defined
-    end
+  describe "adding prefixes" do 
 
     it "should refuse to add prefix to multi-unit compound unit" do
       lambda{(Unit.kg*Unit.m*Unit.m/Unit.s/Unit.s).with_prefix(:giga)}.should raise_error

data/spec/quantity_spec.rb

@@ -89,6 +89,16 @@ describe Quantity do
     quantities[1].unit.pluralized_name.should == 'kilograms per tonne kilometre'
     quantities[1].unit.symbol.should == 'kg/t km'
   end
+  
+  it "should create a valid instance from complex string with compound per unit and no spaces" do
+    quantities = Quantity.parse "We sent some freight 6000 nautical miles by ship and the emissions rate was 10 kg/t km"
+    quantities.first.value.should == 6000
+    quantities.first.unit.name.should == 'nautical mile'
+    quantities.first.unit.symbol.should == 'nmi'
+    quantities[1].value.should == 10
+    quantities[1].unit.pluralized_name.should == 'kilograms per tonne kilometre'
+    quantities[1].unit.symbol.should == 'kg/t km'
+  end
 
   it "should create valid instances from complex string" do
     quantities = Quantity.parse "I travelled 220 miles driving my car and using 0.13 UK gallons per mile of diesel"
@@ -153,6 +163,34 @@ describe Quantity do
     quantities[1].unit.pluralized_name.should == 'square metres'
     quantities[1].unit.symbol.should == 'm²'
   end
+  
+  it "should create valid instance from string with 'square' prefix descriptor" do
+    quantities = Quantity.parse "25 square feet"
+    quantities.first.value.should == 25
+    quantities.first.unit.name.should == 'square foot'
+    quantities.first.unit.symbol.should == 'ft²'
+  end
+  
+  it "should create valid instance from string with 'cubic' prefix descriptor" do
+    quantities = Quantity.parse "25 cubic feet"
+    quantities.first.value.should == 25
+    quantities.first.unit.name.should == 'cubic foot'
+    quantities.first.unit.symbol.should == 'ft³'
+  end
+  
+  it "should create valid instance from string with 'squared' suffix descriptor" do
+    quantities = Quantity.parse "25 feet squared"
+    quantities.first.value.should == 25
+    quantities.first.unit.name.should == 'square foot'
+    quantities.first.unit.symbol.should == 'ft²'
+  end
+  
+  it "should create valid instance from string with 'cubed' suffix descriptor" do
+    quantities = Quantity.parse "25 feet cubed"
+    quantities.first.value.should == 25
+    quantities.first.unit.name.should == 'cubic foot'
+    quantities.first.unit.symbol.should == 'ft³'
+  end
 
   it "should create valid instances from complex string with no spaces" do
     quantities = Quantity.parse "I sprayed 500L of fertilizer across 6000m^2 of farmland"

data/spec/unit_spec.rb

@@ -241,7 +241,7 @@ describe Unit do
         lambda{Unit.M}.should raise_error
         
         Unit.Gg.name.should eql 'gigagram'
-        lambda{Unit.GG}.should raise_error
+        Unit.GG.name.should eql 'gigagauss'
       end
 
       it "should NOT ignore case when initialising units by label" do
@@ -319,10 +319,6 @@ describe Unit do
       unit.factor.should == 1000
     end
 
-    it "dynamic unit retrieval with name and invalid prefix should throw error" do
-      lambda{Unit.megafoot}.should raise_error
-    end
-
     it "dynamic unit retrieval with symbol should be successful" do
       Unit.m.name.should == 'metre'
       Unit.ft.symbol.should == 'ft'
@@ -342,7 +338,6 @@ describe Unit do
 
     it "dynamic unit retrieval with symbol and invalid prefix should raise error" do
       lambda{Unit.MMm}.should raise_error
-      lambda{Unit.Gft}.should raise_error
       lambda{Unit.centimetre.with_prefix :kilo}.should raise_error
     end
 
@@ -1060,12 +1055,12 @@ describe Unit do
       lambda{Unit.kilometre.with_prefix :giga}.should raise_error
     end
 
-    it "should add prefix with explcit method" do
+    it "should add prefix with explicit method" do
       Unit.metre.with_prefix(:c).name.should == 'centimetre'
-    end
+    end    
     
-    it "trying to add invalid prefix should raise error" do
-      lambda{Unit.ft.with_prefix(:kilo)}.should raise_error
+    it "should pluralise uncountable unit with prefix correctly" do
+      Unit.siemens.with_prefix(:kilo).name.should == 'kilosiemens'
     end
 
   end
@@ -1075,6 +1070,7 @@ describe Unit do
     it "should represent the pound mole correctly" do
       unit = Unit.lbmol
       unit.name.should eql 'pound mole'
+      unit.pluralized_name.should eql 'pound moles'
       Unit.ratio(Unit.mol,unit).value.should eql 453.59237
       unit.alternatives_by_name.should eql ['mole']
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: quantify
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 3
+  - 1
   - 0
-  - 0
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors: 
 - Andrew Berkeley
@@ -15,12 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-08 00:00:00 +00:00
-default_executable: 
+date: 2011-12-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -30,12 +28,12 @@ dependencies:
         - 3
         - 0
         version: "3.0"
+  version_requirements: *id001
+  name: activesupport
   prerelease: false
   type: :runtime
-  requirement: *id001
 - !ruby/object:Gem::Dependency 
-  name: i18n
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -44,12 +42,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  version_requirements: *id002
+  name: i18n
   prerelease: false
   type: :runtime
-  requirement: *id002
 - !ruby/object:Gem::Dependency 
-  name: bundler
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -60,12 +58,12 @@ dependencies:
         - 0
         - 0
         version: 1.0.0
+  version_requirements: *id003
+  name: bundler
   prerelease: false
   type: :development
-  requirement: *id003
 - !ruby/object:Gem::Dependency 
-  name: jeweler
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -76,12 +74,12 @@ dependencies:
         - 6
         - 4
         version: 1.6.4
+  version_requirements: *id004
+  name: jeweler
   prerelease: false
   type: :development
-  requirement: *id004
 - !ruby/object:Gem::Dependency 
-  name: rspec
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -92,12 +90,12 @@ dependencies:
         - 6
         - 0
         version: 2.6.0
+  version_requirements: *id005
+  name: rspec
   prerelease: false
   type: :development
-  requirement: *id005
 - !ruby/object:Gem::Dependency 
-  name: rcov
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -106,12 +104,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  version_requirements: *id006
+  name: rcov
   prerelease: false
   type: :development
-  requirement: *id006
 - !ruby/object:Gem::Dependency 
-  name: rdoc
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -120,9 +118,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  version_requirements: *id007
+  name: rdoc
   prerelease: false
   type: :development
-  requirement: *id007
 description: A gem to support physical quantities and unit conversions
 email: andrew.berkeley.is@googlemail.com
 executables: []
@@ -146,7 +145,6 @@ files:
 - lib/quantify/dimensions.rb
 - lib/quantify/exception.rb
 - lib/quantify/inflections.rb
-- lib/quantify/parser.rb
 - lib/quantify/quantify.rb
 - lib/quantify/quantity.rb
 - lib/quantify/unit/base_unit.rb
@@ -163,11 +161,9 @@ files:
 - quantify.gemspec
 - spec/compound_unit_spec.rb
 - spec/dimension_spec.rb
-- spec/quantify_spec.rb
 - spec/quantity_spec.rb
 - spec/string_spec.rb
 - spec/unit_spec.rb
-has_rdoc: true
 homepage: https://github.com/spatchcock/quantify
 licenses: 
 - MIT
@@ -197,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Support for handling physical quantities, unit conversions, etc

data/lib/quantify/parser.rb

@@ -1,7 +0,0 @@
-
-module Quantify
-  module Parser
-
-    
-  end
-end

data/spec/quantify_spec.rb

@@ -1,6 +0,0 @@
-require 'quantify'
-include Quantify
-
-describe Quantify do
-
-end