quantify 1.0.5 → 1.1.0

data/lib/quantify/unit/compound_base_unit.rb

@@ -32,19 +32,19 @@ module Quantify
 
       # Absolute index as names always contain 'per' before denominator units
       def name
-        @unit.name.to_power(@index.abs)
+        name_to_power(@unit.name, @index.abs)
       end
 
       def pluralized_name
-        @unit.pluralized_name.to_power(@index.abs)
+        name_to_power(@unit.pluralized_name, @index.abs)
       end
 
       def symbol
-        @unit.symbol.to_s + ( @index.nil? or @index == 1 ? "" : "^#{@index}" )
+        @unit.symbol.to_s + ( @index.nil? || @index == 1 ? "" : formatted_index )
       end
 
       def label
-        @unit.label + (@index == 1 ? "" : "^#{@index}")
+        @unit.label + (@index == 1 ? "" : formatted_index)
       end
 
       # Reciprocalized version of label, i.e. sign changed. This is used to make
@@ -52,7 +52,7 @@ module Quantify
       # i.e. where no '/' appears in the label
       #
       def reciprocalized_label
-        @unit.label + (@index == -1 ? "" : "^#{@index * -1}")
+        @unit.label + (@index == -1 ? "" : formatted_index(@index * -1))
       end
 
       def factor
@@ -70,22 +70,62 @@ module Quantify
       # The following methods refer only to the unit of the CompoundBaseUnit
       # object, rather than the unit *together with its index*
 
-      Unit_Methods = [ :base_quantity_si_unit, :base_unit, :benchmark_unit, :si_unit,
-                       :non_si_unit, :prefixed_unit, :derived_unit ]
-  
-      Unit_Methods.each do |method|
-        method = "is_#{method.to_s}?"
-        define_method(method) do
-          @unit.send method.to_sym
-        end
+      def is_base_quantity_si_unit?
+        @unit.is_base_quantity_si_unit?
+      end
+
+      def is_base_unit?
+        @unit.is_base_unit?
+      end
+      
+      def is_benchmark_unit?
+        @unit.is_benchmark_unit?
+      end
+
+      def is_si_unit?
+        @unit.is_si_unit?
+      end
+      
+      def is_non_si_unit?
+        @unit.is_non_si_unit?
+      end
+
+      def is_prefixed_unit?
+        @unit.is_prefixed_unit?
       end
 
+      def is_derived_unit?
+        @unit.is_derived_unit?
+      end
+  
       def measures
         @unit.measures
       end
 
       def initialize_copy(source)
-        instance_variable_set("@unit", unit.clone)
+        instance_variable_set("@unit", @unit.clone)
+      end
+
+      private
+
+      # Returns a string representation of the unit index, formatted according to
+      # the global superscript configuration
+      #
+      def formatted_index(index=nil)
+        index = "^#{index.nil? ? @index : index}"
+        Quantify.use_superscript_characters? ? index.with_superscript_characters : index
+      end
+
+      def name_to_power(string,index)
+        name = string.clone
+        case index
+        when 1 then name
+        when 2 then "square #{name}"
+        when 3 then "cubic #{name}"
+        else
+          ordinal = ActiveSupport::Inflector.ordinalize index
+          name << " to the #{ordinal} power"
+        end
       end
     end
   end

data/lib/quantify/unit/compound_unit.rb

@@ -41,7 +41,7 @@ module Quantify
           next if new_base.unit.is_dimensionless?
 
           new_base.index = base_units.select do |other_base|
-            new_base.unit == other_base.unit
+            new_base.unit.is_equivalent_to? other_base.unit
           end.inject(new_base.index) do |index,other_base|
             base_units.delete other_base
             index += other_base.index
@@ -57,8 +57,8 @@ module Quantify
       #
       # This is a class method which takes an arbitrary array of base units as an
       # argument. This means that consolidation can be performed on either all
-      # base units or just a subset - the numerator or denominator units.
-      #''
+      # base units or just a subset - e.g. the numerator or denominator units.
+      #
       # The units to use for particular physical dimension can be specified
       # following the inital argument. If no unit is specified for a physical
       # quantity which is represented in the array of base units, then the first
@@ -93,8 +93,8 @@ module Quantify
             @base_units << unit
           elsif unit.is_a? Unit::Base
             @base_units << CompoundBaseUnit.new(unit)
-          elsif unit.is_a? Array and unit.first.is_a? Unit::Base and
-              not unit.first.is_a? Compound and unit.size == 2
+          elsif unit.is_a?(Array) && unit.first.is_a?(Unit::Base) &&
+              !unit.first.is_a?(Compound) && unit.size == 2
             @base_units << CompoundBaseUnit.new(unit.first,unit.last)
           else
             raise Exceptions::InvalidArgumentError, "#{unit} does not represent a valid base unit"
@@ -165,10 +165,10 @@ module Quantify
           raise Exceptions::InvalidArgumentError, "Cannot cancel by a compound unit" if unit.is_a? Unit::Compound
           unit = Unit.for unit unless unit.is_a? Unit::Base
 
-          numerator_unit = numerator_units.find { |base| unit == base.unit }
-          denominator_unit = denominator_units.find { |base| unit == base.unit }
+          numerator_unit = numerator_units.find { |base| unit.is_equivalent_to? base.unit }
+          denominator_unit = denominator_units.find { |base| unit.is_equivalent_to? base.unit }
 
-          if numerator_unit and denominator_unit
+          if numerator_unit && denominator_unit
             cancel_value = [numerator_unit.index,denominator_unit.index].min.abs
             numerator_unit.index -= cancel_value
             denominator_unit.index += cancel_value
@@ -177,6 +177,20 @@ module Quantify
         consolidate_numerator_and_denominator_units!
       end
 
+      # Make the base units of self use consistent units for each physical quantity
+      # represented. For example, lb/kg => kg/kg.
+      #
+      # By default, units are rationalized within the the numerator and denominator
+      # respectively. That is, different units representing the same physical
+      # quantity may appear across the numerator and denominator, but not within
+      # each. To fully rationalize the base units of self, pass in the symbol
+      # :full as a first argument. Otherwise :partial is passed as the default.
+      #
+      # The units to use for particular physical dimension can be specified
+      # following the inital argument. If no unit is specified for a physical
+      # quantity which is represented in the array of base units, then the first
+      # unit found for that physical quantity is used as the canonical one.
+      #
       def rationalize_base_units!(scope=:partial,*units)
         if scope == :full
           Compound.rationalize_base_units(@base_units,*units)
@@ -187,16 +201,26 @@ module Quantify
         consolidate_numerator_and_denominator_units!
       end
 
+      # Return a known unit which is equivalent to self in terms of its physical
+      # quantity (dimensions), factor and scaling attributes (i.e. representing the
+      # precise same physical unit but perhaps with different identifiers), e.g.
+      #
+      #   ((Unit.kg*(Unit.m**"))/(Unit.s**2)).equivalent_known_unit.name
+      #
+      #                                #=> "joule"
+      #
       def equivalent_known_unit
         Unit.units.find do |unit|
-          self == unit and
-          not unit.is_compound_unit?
+          self.is_equivalent_to?(unit) && !unit.is_compound_unit?
         end
       end
 
-      def or_equivalent &block
+      # Returns an equivalent known unit (via #equivalent_known_unit) if it exists.
+      # Otherwise, returns false.
+      #
+      def or_equivalent
         equivalent_unit = equivalent_known_unit
-        if equivalent_unit and equivalent_unit.acts_as_equivalent_unit
+        if equivalent_unit && equivalent_unit.acts_as_equivalent_unit
           return equivalent_unit
         else
           return self
@@ -206,11 +230,11 @@ module Quantify
       protected
 
       def initialize_attributes
-        @dimensions = derive_dimensions
-        @name = derive_name
-        @symbol = derive_symbol
-        @factor = derive_factor
-        @label = derive_label
+        self.dimensions = derive_dimensions
+        self.name = derive_name
+        self.symbol = derive_symbol
+        self.factor = derive_factor
+        self.label = derive_label
       end
 
       # Partially consolidate base units, i.e. numerator and denomiator are
@@ -304,7 +328,7 @@ module Quantify
           format = ( unit_label.empty? ? :label : :reciprocalized_label )
           unit_label << "/" unless unit_label.empty?
           denominator_units.inject(unit_label) do |label,base|
-            label << "·" unless unit_label.empty? or unit_label =~ /\/\z/
+            label << "·" unless unit_label.empty? || unit_label =~ /\/\z/
             label << base.send(format)
           end
         end

data/lib/quantify/unit/non_si_unit.rb

@@ -12,7 +12,7 @@ module Quantify
       #
       def initialize(options=nil)
         @scaling = 0.0
-        if options.is_a? Hash and options[:scaling]
+        if options.is_a?(Hash) && options[:scaling]
           @scaling = options.delete(:scaling).to_f
         end
         super(options)

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

@@ -10,16 +10,16 @@ module Quantify
           end
         end
 
-        def self.configure &block
-          self.class_eval &block if block
+        def self.configure(&block)
+          self.class_eval(&block) if block
         end
 
         attr_reader :name, :symbol, :factor
 
         def initialize(options)
-          @symbol = options[:symbol].standardize
+          @symbol = options[:symbol].remove_underscores
           @factor = options[:factor].to_f
-          @name = options[:name].standardize.downcase
+          @name = options[:name].remove_underscores.downcase
         end
 
         def is_si_prefix?
@@ -27,7 +27,7 @@ module Quantify
         end
 
         def is_non_si_prefix?
-          self.is_a? NonSI
+          self.is_a?(NonSI)
         end
 
         def label

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

@@ -14,7 +14,7 @@ module Quantify
       def self.unload(*unloaded_prefixes)
         [unloaded_prefixes].flatten.each do |unloaded_prefix|
           unloaded_prefix = Prefix.for(unloaded_prefix)
-          @prefixes.delete_if { |unit| unit.label == unloaded_prefix.label }
+          @prefixes.delete_if { |prefix| prefix.label == unloaded_prefix.label }
         end
       end
 
@@ -24,10 +24,10 @@ module Quantify
 
       def self.for(name_or_symbol,collection=nil)
         return name_or_symbol.clone if name_or_symbol.is_a? Quantify::Unit::Prefix::Base
-        if name_or_symbol.is_a? String or name_or_symbol.is_a? Symbol
+        if name_or_symbol.is_a?(String) || name_or_symbol.is_a?(Symbol)
           if prefix = (collection.nil? ? @prefixes : collection).find do |prefix|
-             prefix.name == name_or_symbol.standardize.downcase or
-             prefix.symbol == name_or_symbol.standardize
+             prefix.name == name_or_symbol.remove_underscores.downcase ||
+             prefix.symbol == name_or_symbol.remove_underscores
             end
             return prefix.clone
           else

data/lib/quantify/unit/unit.rb

@@ -25,8 +25,8 @@ module Quantify
       attr_reader :units
     end
 
-    def self.configure &block
-      self.class_eval &block if block
+    def self.configure(&block)
+      self.class_eval(&block) if block
     end
 
     # Instance variable containing system of known units
@@ -40,8 +40,7 @@ module Quantify
     # Remove a unit from the system of known units
     def self.unload(*unloaded_units)
       [unloaded_units].flatten.each do |unloaded_unit|
-        unloaded_unit = Unit.for(unloaded_unit)
-        @units.delete_if { |unit| unit.label == unloaded_unit.label }
+        @units.delete(Unit.for(unloaded_unit))
       end
     end
 
@@ -90,10 +89,10 @@ module Quantify
     #
     def self.for(name_symbol_label_or_object)
       return name_symbol_label_or_object.clone if name_symbol_label_or_object.is_a? Unit::Base
-      return nil if name_symbol_label_or_object.nil? or
-        ( name_symbol_label_or_object.is_a?(String) and name_symbol_label_or_object.empty? )
+      return nil if name_symbol_label_or_object.nil? ||
+        ( name_symbol_label_or_object.is_a?(String) && name_symbol_label_or_object.empty? )
       name_symbol_or_label = name_symbol_label_or_object
-      unless name_symbol_or_label.is_a? String or name_symbol_or_label.is_a? Symbol
+      unless name_symbol_or_label.is_a?(String) || name_symbol_or_label.is_a?(Symbol)
         raise Exceptions::InvalidArgumentError, "Argument must be a Symbol or String"
       end
       if unit = Unit.match(name_symbol_or_label)
@@ -109,7 +108,7 @@ module Quantify
     # Parse complex strings into unit.
     #
     def self.parse(string)
-      string = string.standardize
+      string = string.remove_underscores.without_superscript_characters
       if string.scan(/(\/|per)/).size > 1
         raise Exceptions::InvalidArgumentError, "Malformed unit: multiple uses of '/' or 'per'"
       end
@@ -118,7 +117,7 @@ module Quantify
       numerator, per, denominator = string.split(/(\/|per)/)
       units += Unit.parse_numerator_units(numerator)
       units += Unit.parse_denominator_units(denominator) unless denominator.nil?
-      if units.size == 1 and units.first.index == 1
+      if units.size == 1 && units.first.index == 1
         return units.first.unit
       else
         return Unit::Compound.new(*units)
@@ -141,40 +140,51 @@ module Quantify
 
     def self.match_known_unit(attribute, string_or_symbol)
       string_or_symbol = Unit.format_unit_attribute(attribute, string_or_symbol)
-      unit = @units.find { |unit| unit.send(attribute) == string_or_symbol }
-      return unit.clone rescue nil
+      @units.find do |unit|
+        unit_attribute = unit.send(attribute)
+        if attribute == :name
+          unit_attribute.downcase == string_or_symbol
+        else
+          unit_attribute == string_or_symbol
+        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(#{Unit::Prefix.si_prefixes.map(&attribute).join("|")})(#{Unit.si_non_prefixed_units.map(&attribute).join("|")})\z/ or
-         string_or_symbol =~ /\A(#{Unit::Prefix.non_si_prefixes.map(&attribute).join("|")})(#{Unit.non_si_non_prefixed_units.map(&attribute).join("|")})\z/
+      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/
         return Unit.for($2).with_prefix($1).clone
       end
       return nil
     end
 
-    # Standardizes query strings or symbols into canonical form for unit names,
+    # standardize query strings or symbols into canonical form for unit names,
     # symbols and labels
     #
     def self.format_unit_attribute(attribute, string_or_symbol)
       string_or_symbol = case attribute
-        when :symbol then string_or_symbol.standardize
-        when :name then string_or_symbol.standardize.singularize.downcase
+        when :symbol then string_or_symbol.remove_underscores
+        when :name then string_or_symbol.remove_underscores.singularize.downcase
         else string_or_symbol.to_s
       end
+      Quantify.use_superscript_characters? ?
+        string_or_symbol.with_superscript_characters : string_or_symbol.without_superscript_characters
     end
     
     def self.parse_unit_and_index(string)
       string.scan(/([^0-9\^]+)\^?([\d\.-]*)?/i)
-      index = ($2.nil? or $2.empty? ? 1 : $2.to_i)
+      index = ($2.nil? || $2.empty? ? 1 : $2.to_i)
       CompoundBaseUnit.new($1.to_s, index)
     end
 
     def self.parse_numerator_units(string)
       # If no middot then names parsed by whitespace
-      # Need to consider multi word unit names
-      num_units = ( string =~ /·/ ? string.split("·") : string.split(" ") )
+      if string =~ /·/
+        num_units = string.split("·")
+      else
+        num_units = Unit.escape_multi_word_units(string).split(" ")
+      end
       num_units.map! do |substring|
         Unit.parse_unit_and_index(substring)
       end
@@ -199,26 +209,47 @@ module Quantify
     # given importance in #match (and #for) methods regexen
     #
     def self.si_non_prefixed_units
-      @units.select {|unit| unit.is_si_unit? and not unit.is_prefixed_unit? }
+      @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? and not unit.is_prefixed_unit? }
+      @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(&:name).compact.select {|name| name.word_count > 1 }
+      @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(&:pluralize)
+      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(&:symbol).compact.select {|symbol| symbol.word_count > 1 }
+      @units.map {|unit| unit.symbol if unit.symbol.word_count > 1 }.compact
+    end
+
+    # Underscore any parts of string which represent multi-word unit identifiers
+    # so that units can be parsed on whitespace
+    #
+    def self.escape_multi_word_units(string)
+      (multi_word_unit_symbols + multi_word_unit_pluralized_names + multi_word_unit_names).each do |id|
+        string.gsub!(id, id.gsub(" ","_")) if /#{id}/.match(string)
+      end
+      string
+    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)
+      list = klass.send(method).map { |item| item.send(attribute) }
+      list.map! { |item| item.downcase } if attribute == :name
+      list.join("|")
     end
 
   end