quantify 1.0.4 → 1.0.5

data/lib/quantify/core_extensions.rb

@@ -56,7 +56,7 @@ class Numeric
     if unit = Unit.for(method.to_s)
       Quantify::Quantity.new self, unit
     else
-      raise NoMethodError, "Undefined method `#{method}` for #{self}:#{self.class}"
+      super
     end
   end
 

data/lib/quantify/dimensions.rb

@@ -318,7 +318,7 @@ module Quantify
     #
     def si_base_units(by=nil)
       self.to_hash.map do |dimension,index|
-        Unit.si_base_units.select do |unit|
+        Unit.base_quantity_si_units.select do |unit|
           unit.measures == dimension.standardize
         end.first.clone ** index
       end.map(&by)
@@ -383,6 +383,8 @@ module Quantify
     def multiply(other)
       Dimensions.new(self.to_hash).multiply! other
     end
+    alias :times :multiply
+    alias :* :multiply
 
     # Similar to #multiply! but performs a division of self by the specified
     # Dimensions object.
@@ -399,6 +401,7 @@ module Quantify
     def divide(other)
       Dimensions.new(self.to_hash).divide! other
     end
+    alias :/ :divide
 
     # Raises self to the power provided. As with multiply and divide, the
     # #get_description method is invoked to attempt to find a suitable
@@ -422,6 +425,7 @@ module Quantify
     def pow(power)
       Dimensions.new(self.to_hash).pow!(power)
     end
+    alias :** :pow
 
     # Inverts self, returning a representation of 1/self. This is equivalent to
     # raising to the power -1. The #get_description method is invoked to attempt
@@ -443,11 +447,6 @@ module Quantify
       Dimensions.new(self.to_hash).reciprocalize!
     end
 
-    alias :times :multiply
-    alias :* :multiply
-    alias :/ :divide
-    alias :** :pow
-
     protected
 
     # Returns an array containing the names of the instance variables which

data/lib/quantify/quantify.rb

@@ -4,6 +4,8 @@ module Quantify
     self.module_eval &block if block
   end
 
+
+
   module ExtendedMethods
 
     # Provides syntactic sugar for accessing units via the #for method.

data/lib/quantify/quantity.rb

@@ -3,6 +3,8 @@
 module Quantify
   class Quantity
 
+    include Comparable
+
     # The quantity class represents quantities. Quantities are represented by a
     # numeric value - of class Numeric - and a unit - of class Unit::Base.
     #
@@ -174,9 +176,9 @@ module Quantify
     end
 
     def convert_compound_unit_to_si!
-      until self.unit.is_si_unit? do
+      until self.unit.is_base_quantity_si_unit? do
         unit = self.unit.base_units.find do |base|
-          !base.unit.is_si_unit?
+          !base.is_base_quantity_si_unit?
         end.unit
         self.convert_compound_unit_to_non_equivalent_unit!(unit.si_unit)
       end
@@ -241,28 +243,27 @@ module Quantify
     def add(other)
       Quantity.new(value,unit).add!(other)
     end
+    alias :+ :add
 
     def subtract(other)
       Quantity.new(value,unit).subtract!(other)
     end
+    alias :- :subtract
 
     def multiply(other)
       Quantity.new(value,unit).multiply!(other)
     end
+    alias :times :multiply
+    alias :* :multiply
 
     def divide(other)
       Quantity.new(value,unit).divide!(other)
     end
+    alias :/ :divide
 
     def pow(power)
       Quantity.new(value,unit).pow!(power)
     end
-
-    alias :times :multiply
-    alias :* :multiply
-    alias :+ :add
-    alias :- :subtract
-    alias :/ :divide
     alias :** :pow
 
     def rationalize_units
@@ -300,6 +301,18 @@ module Quantify
       rounded_quantity.round! decimal_places
     end
 
+    def <=>(other)
+      raise Exceptions::InvalidArgumentError unless other.is_a? Quantity
+      raise Exceptions::InvalidArgumentError unless other.unit.is_alternative_for?(unit)
+      other = other.to unit
+      value.to_f <=> other.value.to_f
+    end
+
+    def ===(range)
+      raise Exceptions::InvalidArgumentError unless range.is_a? Range
+      range.include? self
+    end
+
     # Enables shorthand for reciprocal of quantity, e.g.
     #
     #   quantity = 2.m

data/lib/quantify/unit/base_unit.rb

@@ -11,9 +11,8 @@ module Quantify
       # Create a new instance of self (i.e. Base or an inherited class) and load
       # into the system of known units. See initialize for details of options
       #
-      def self.load(options)
-        unit = self.new(options)
-        unit.load
+      def self.load(options=nil,&block)
+        self.new(options,&block).load
       end
 
       def self.construct_and_load(unit,&block)
@@ -50,8 +49,8 @@ module Quantify
         return new_unit
       end
 
-      # Syntactic sugar for defining the known units, enabling the required
-      # associated units to be loaded at runtime, e.g.
+      # Syntactic sugar for defining the units known to the system, enabling the
+      # required associated units to be loaded at runtime, e.g.
       #
       #  Unit::[Base|SI|NonSI].configure do |config|
       #
@@ -65,9 +64,9 @@ module Quantify
         class_eval &block if block
       end
       
-      attr_accessor :name, :symbol, :label
-      attr_accessor :dimensions, :factor
-      attr_accessor :acts_as_alternative_unit, :acts_as_equivalent_unit
+      attr_accessor :name, :symbol, :label, :factor
+      attr_reader :dimensions
+      attr_reader :acts_as_alternative_unit, :acts_as_equivalent_unit
 
       # Create a new Unit::Base instance.
       #
@@ -101,52 +100,69 @@ module Quantify
       # representation in the Dimensions class. This dimensions attribute is to
       # provide much of the unit functionality
       #
-      def initialize(options=nil)
+      def initialize(options=nil)    
+        @acts_as_alternative_unit = true
+        @acts_as_equivalent_unit = false
+        @factor = 1.0
+        @symbol = nil
+        @label = nil
         if options.is_a? Hash
+          self.dimensions = options[:dimensions] || options[:physical_quantity]
           @name = options[:name].standardize.singularize.downcase
-          options[:dimensions] = options[:dimensions] || options[:physical_quantity]
-          if options[:dimensions].is_a? Dimensions
-            @dimensions = options[:dimensions]
-          elsif options[:dimensions].is_a? String or options[:dimensions].is_a? Symbol
-            @dimensions = Dimensions.for options[:dimensions]
-          else
-            raise Exceptions::InvalidArgumentError, "Unknown physical_quantity specified"
-          end
-          @factor = options[:factor].nil? ? 1.0 : options[:factor].to_f
-          @symbol = options[:symbol].nil? ? nil : options[:symbol].standardize
-          @label = options[:label].nil? ? nil : options[:label].to_s
-          @acts_as_alternative_unit = true
-          @acts_as_equivalent_unit = false
+          @factor = options[:factor].to_f if options[:factor]
+          @symbol = options[:symbol].standardize if options[:symbol]
+          @label = options[:label].to_s if options[:label]
         end
         yield self if block_given?
         valid?
       end
 
+      def dimensions=(dimensions)
+        if dimensions.is_a? Dimensions
+          @dimensions = dimensions
+        elsif dimensions.is_a? String or dimensions.is_a? Symbol
+          @dimensions = Dimensions.for dimensions
+        else
+          raise Exceptions::InvalidArgumentError, "Unknown physical_quantity specified"
+        end
+      end
+      alias :physical_quantity= :dimensions=
+
       # Permits a block to be used, operating on self. This is useful for modifying
       # the attributes of an already instantiated unit, especially when defining
       # units on the basis of operation on existing units for adding specific
       # (rather than derived) names or symbols, e.g.
       #
-      #   (Unit.pound_force/(Unit.in**2)).operate do |unit|
+      #   (Unit.pound_force/(Unit.in**2)).configure do |unit|
       #     unit.symbol = 'psi'
       #     unit.label = 'psi'
       #     unit.name = 'pound per square inch'
       #   end
       #
-      def operate
+      def configure
         yield self if block_given?
         return self if valid?
       end
 
+      # Similar to #configure but makes the new unit configuration the canonical
+      # unit for self.label
+      #
+      def configure_as_canonical &block
+        unload if loaded?
+        configure &block if block_given?
+        make_canonical
+      end
+
       # Load an initialized Unit into the system of known units.
       #
-      # If a block is given, the unit can be operated on prior to loading, in a
-      # similar to way to the #operate method.
+      # If a block is given, the unit can be configured prior to loading, in a
+      # similar to way to the #configure method.
       #
       def load
         yield self if block_given?
         raise Exceptions::InvalidArgumentError, "A unit with the same label: #{self.name}) already exists" if loaded?
         Quantify::Unit.units << self if valid?
+        return self
       end
 
       # Remove from system of known units.
@@ -159,8 +175,16 @@ module Quantify
         Unit.units.any? { |unit| self.has_same_identity_as? unit }
       end
 
+      # Make self the canonical representation of the unit defined by self#label
       def make_canonical
-        unload
+        unload if loaded?
+        load
+      end
+
+      # Set the canonical unit label - the unique unit identifier - to a new value
+      def canonical_label=(new_label)
+        unload if loaded?
+        self.label = new_label
         load
       end
 
@@ -203,11 +227,21 @@ module Quantify
         self.name.pluralize
       end
       
-       # Determine if the unit represents one of the base quantities
+      # Determine if the unit represents one of the base quantities, length,
+      # mass, time, temperature, etc.
+      #
       def is_base_unit?
         Dimensions::BASE_QUANTITIES.map(&:standardize).include? self.measures
       end
 
+      # Determine if the unit is THE canonical SI unit for a base quantity (length,
+      # mass, time, etc.). This method ignores prefixed versions of SI base units,
+      # returning true only for metre, kilogram, second, Kelvin, etc.
+      #
+      def is_base_quantity_si_unit?
+        is_si_unit? and is_base_unit? and is_benchmark_unit?
+      end
+
       # Determine is the unit is a derived unit - that is, a unit made up of more
       # than one of the base quantities
       #
@@ -225,7 +259,8 @@ module Quantify
       # Determine if the unit is one of the units against which all other units
       # of the same physical quantity are defined. These units are almost entirely
       # equivalent to the non-prefixed, SI units, but the one exception is the
-      # kilogram, making this method necessary.
+      # kilogram, which is an oddity in being THE canonical SI unit for mass, yet
+      # containing a prefix. This oddity makes this method useful/necessary.
       #
       def is_benchmark_unit?
         self.factor == 1.0
@@ -277,7 +312,7 @@ module Quantify
           self.send(attr) == other.send(attr)
         end
       end
-
+      
       alias :== :is_same_as?
 
       # Check if unit has the identity as another, i.e. the same label. This is
@@ -375,6 +410,8 @@ module Quantify
         other.instance_of?(Unit::Compound) ? options += other.base_units : options << other
         Unit::Compound.new(*options)
       end
+      alias :times :multiply
+      alias :* :multiply
 
       # Divide one unit by another. This results in the generation of a compound
       # unit.
@@ -393,6 +430,7 @@ module Quantify
         end
         Unit::Compound.new(*options)
       end
+      alias :/ :divide
 
       # Raise a unit to a power. This results in the generation of a compound
       # unit, e.g. m^3.
@@ -412,17 +450,13 @@ module Quantify
         end
         return new_unit
       end
+      alias :** :pow
 
       # Return new unit representing the reciprocal of self, i.e. 1/self
       def reciprocalize
         Unit.unity / self
       end
 
-      alias :times :multiply
-      alias :* :multiply
-      alias :/ :divide
-      alias :** :pow
-
       # Apply a prefix to self. Returns new unit according to the prefixed version
       # of self, complete with modified name, symbol, factor, etc..
       #

data/lib/quantify/unit/compound_base_unit.rb

@@ -67,20 +67,21 @@ module Quantify
         @index < 0
       end
 
-      def is_si_unit?
-        @unit.is_si_unit?
+      # 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
       end
 
-      def is_non_si_unit?
-        @unit.is_non_si_unit?
-      end
-
-      # Physical quantity represented by self. This refers only to the unit, rather
-      # than the unit together with the index. Is used to match base units with
-      # similar units of same physical quantity
-      #
       def measures
-        @unit.dimensions.physical_quantity
+        @unit.measures
       end
 
       def initialize_copy(source)

data/lib/quantify/unit/compound_unit.rb

@@ -131,6 +131,10 @@ module Quantify
         @base_units.any? { |base| base.is_non_si_unit? }
       end
 
+      def is_base_quantity_si_unit?
+        @base_units.all? { |base| base.is_base_quantity_si_unit? }
+      end
+
       # Consolidate base units. A 'full' consolidation is performed, i.e.
       # consolidation across numerator and denominator. This is equivalent to the
       # automatic partial consolidation AND a cancelling of units (i.e.

data/lib/quantify/unit/non_si_unit.rb

@@ -10,8 +10,11 @@ module Quantify
       # These are required in order to perform conversion, e.g. kelvin => celsius
       # and therefore become and additional attribute to NonSI units
       #
-      def initialize(options)
-        @scaling = options[:scaling].nil? ? 0.0 : options.delete(:scaling).to_f
+      def initialize(options=nil)
+        @scaling = 0.0
+        if options.is_a? Hash and options[:scaling]
+          @scaling = options.delete(:scaling).to_f
+        end
         super(options)
       end
 

data/lib/quantify/unit/unit.rb

@@ -187,6 +187,14 @@ module Quantify
       end
     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
     #

data/spec/quantity_spec.rb

@@ -200,6 +200,11 @@ describe Quantity do
     speed.to_si.to_s(:name).should == "44.704 metres per second"
   end
 
+  it "should convert compound units to SI correctly" do
+    speed = Quantity.new 100, (Unit.km/Unit.h)
+    speed.to_si.to_s(:name).should == "27.7777777777778 metres per second"
+  end
+
   it "should convert compound units to SI correctly" do
     pressure = Quantity.new 100, (Unit.pound_force_per_square_inch)
     pressure.to_si.round.to_s(:name).should == "689476 pascals"
@@ -261,5 +266,69 @@ describe Quantity do
     quantity.rationalize_units!
     quantity.to_s.should eql  "144.0 yd^2"
   end
+
+  it "should be greater than" do
+    (20.ft > 1.m).should be_true
+  end
+
+  it "should be greater than" do
+    (20.ft > 7.m).should be_false
+  end
+
+  it "should be less than" do
+    (20.ft/1.h < 8.yd/60.min).should be_true
+  end
+
+  it "should be equal" do
+    (1.yd == 3.ft).should be_true
+  end
+
+  it "should be between with same units" do
+    (25.ft.between? 1.ft,30.ft).should be_true
+  end
+
+  it "should be between even with different units" do
+    (25.ft.between? 1.ft,10.m).should be_true
+  end
+
+  it "comparison with non quantity should raise error" do
+    lambda{20.ft > 3}.should raise_error
+  end
+
+  it "comparison with non compatible quantity should raise error" do
+    lambda{20.ft > 4.K}.should raise_error
+  end
+
+  it "should be range" do
+    (2.ft..20.ft).should be_a Range
+  end
+
+  it "should return between value from range" do
+    (2.ft..20.ft).include?(3.ft).should be_true
+  end
+
+  it "should return between value from range with different units" do
+    (2.ft..4.m).include?(200.cm).should be_true
+    (1.ly..1.parsec).include?(2.ly).should be_true
+    (1.ly..1.parsec).include?(2.in).should be_false
+  end
+
+  it "should return between value from range using === operator" do
+    (3.ft === (2.ft..20.ft)).should be_true
+  end
+
+  it "should return between value from range with different units using === operator" do
+    (200.cm === (2.ft..4.m)).should be_true
+    (2.ly === (1.ly..1.parsec)).should be_true
+    (2.in === (1.ly..1.parsec)).should be_false
+  end
+
+  it "range comparison with non compatible quantity should raise error" do
+    lambda{20.ft === (1.ft..3.K)}.should raise_error
+  end
+
+  it "range comparison with non quantity should raise error" do
+    lambda{20.ft === (1.ft..3)}.should raise_error
+  end
 end
 

data/spec/unit_spec.rb

@@ -168,16 +168,16 @@ describe Unit do
       end}.should raise_error
     end
 
-    it "should modify unit attributes with block and #operate" do
-      unit = (Unit.kg/Unit.kWh).operate do |u|
+    it "should modify unit attributes with block and #configure" do
+      unit = (Unit.kg/Unit.kWh).configure do |u|
         u.name = 'electricity emissions factor'
       end
       unit.class.should == Quantify::Unit::Compound
       unit.name = 'electricity emissions factor'
     end
 
-    it "should raise error with block and #operate which removes name" do
-      lambda{(Unit.kg/Unit.kWh).operate do |u|
+    it "should raise error with block and #configure which removes name" do
+      lambda{(Unit.kg/Unit.kWh).configure do |u|
         u.name = ""
       end}.should raise_error
     end
@@ -286,15 +286,65 @@ describe Unit do
     it "should make new unit configuration canonical" do
       unit = Unit.psi
       unit.name.should == 'pound force per square inch'
-      unit.operate {|unit| unit.name = 'PSI'}
+      unit.configure {|unit| unit.name = 'PSI'}
       unit.name.should == 'PSI'
       Unit.psi.name.should == 'pound force per square inch'
       unit.make_canonical
       Unit.psi.name.should == 'PSI'
-      unit.operate {|unit| unit.name = 'pound force per square inch'}
+      unit.configure {|unit| unit.name = 'pound force per square inch'}
       unit.make_canonical
     end
 
+    it "should change the label of canonical unit representation" do
+      unit = Unit.cubic_metre
+      unit.label.should eql "m^3"
+      unit.canonical_label = "m3"
+      unit.label.should eql "m3"
+      Unit.cubic_metre.label.should eql "m3"
+    end
+
+    it "should configure on canonical unit" do
+      unit = Unit.kg.configure_as_canonical do |unit|
+        unit.name = 'killogram'
+      end
+      unit.name.should eql 'killogram'
+      unit.symbol.should eql 'kg'
+      Unit.kg.name.should eql 'killogram'
+      (Unit.killogram).should be_a Unit::Base
+
+      unit = Unit.kg.configure_as_canonical do |unit|
+        unit.name = 'kilogram'
+      end
+    end
+
+    it "should configure on canonical unit even if changing label" do
+      unit = Unit.barn.configure_as_canonical do |unit|
+        unit.label = 'BARN'
+      end
+      unit.label.should eql 'BARN'
+      unit.symbol.should eql 'b'
+      Unit.barn.label.should eql 'BARN'
+      (Unit.BARN).should be_a Unit::Base
+
+      unit = Unit.barn.configure_as_canonical do |unit|
+        unit.label = 'b'
+      end
+    end
+
+    it "should configure on canonical unit even if changing label using canonical_label=" do
+      unit = Unit.barn.configure_as_canonical do |unit|
+        unit.canonical_label = 'BARN'
+      end
+      unit.label.should eql 'BARN'
+      unit.symbol.should eql 'b'
+      Unit.barn.label.should eql 'BARN'
+      (Unit.BARN).should be_a Unit::Base
+
+      unit = Unit.barn.configure_as_canonical do |unit|
+        unit.label = 'b'
+      end
+    end
+
   end
 
   describe "unit initialization" do
@@ -322,6 +372,33 @@ describe Unit do
     it "should load unit into module array with class method" do
       unit = Unit::NonSI.load :name => 'a name', :physical_quantity => :energy, :factor => 10, :symbol => 'anm', :label => 'a_name'
       Unit.non_si_units_by_name.should include 'a name'
+      Unit.unload(unit)
+    end
+
+    it "should load unit into module array with class method and block" do
+      Unit::NonSI.load do |unit|
+        unit.name = 'a name'
+        unit.physical_quantity = :energy
+        unit.factor = 10
+        unit.symbol = 'anm'
+        unit.label = 'a_name'
+      end
+      Unit.non_si_units_by_name.should include 'a name'
+      Unit.a_name.measures.should eql 'energy'
+      Unit.unload('a_name')
+    end
+
+    it "should load unit into module array with class method and block and #dimensions method" do
+      Unit::NonSI.load do |unit|
+        unit.name = 'a name'
+        unit.dimensions = :energy
+        unit.factor = 10
+        unit.symbol = 'anm'
+        unit.label = 'a_name'
+      end
+      Unit.non_si_units_by_name.should include 'a name'
+      Unit.a_name.measures.should eql 'energy'
+      Unit.unload('a_name')
     end
     
     it "should derive compound unit correctly" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: quantify
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 1
   - 0
-  - 4
-  version: 1.0.4
+  - 5
+  version: 1.0.5
 platform: ruby
 authors: 
 - Andrew Berkeley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-03 00:00:00 +00:00
+date: 2011-06-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency