quantify 3.1.2 → 3.1.3

data/README.md

@@ -13,58 +13,58 @@ Homepage: https://github.com/spatchcock/quantify
 Quick introduction
 ------------------
 
-Operating on quantities
+    # Operating on quantities
 
-  12.feet + 12.feet                   => "24.0 feet"
+    12.feet + 12.feet                   #=> "24.0 feet"
 
-  6.m ** 2                            => "36.0 m²"
+    6.m ** 2                            #=> "36.0 m²"
 
-  100.km / 2.h                        => "50 kilometers per hour"
+    100.km / 2.h                        #=> "50 kilometers per hour"
 
-  5000.L.to_bbl                       => "31.4490528488754 barrels"
+    5000.L.to_bbl                       #=> "31.4490528488754 barrels"
 
-  1.5.lb.to_si.round(2)               => "0.68 kg"
+    1.5.lb.to_si.round(2)               #=> "0.68 kg"
 
-  Unit.ratio :kg, :ton                => "1.016047 kilograms per long ton"
+    Unit.ratio :kg, :ton                #=> "1016.047 kilograms per long ton"
 
 Note: these results are string representations of the actual objects
 which result from these operations, using the Quantity#to_s method which
 renders quantities using either the unit name or symbol.
 
-Handling units
+    # Handling units
 
-  Unit.ton.name                       => "long ton"
+    Unit.ton.name                       #=> "long ton"
 
-  Unit.ton.label                      => "ton_uk"
+    Unit.ton.label                      #=> "ton_uk"
 
-  Unit.ton.measures                   => "mass"
+    Unit.ton.measures                   #=> "mass"
 
-  Unit.ton.alternatives :name         => [ "kilogram",
-                                           "gram",
-                                           "carat",
-                                           "electron mass",
-                                           "grain",
-                                           "hundredweight long",
-                                           "hundredweight short",
-                                           "ounce",
-                                           "pennyweight",
-                                           "pound",
-                                           "short ton",
-                                           "stone",
-                                           "tonne",
-                                           "unified atomic mass" ]
+    Unit.ton.alternatives :name         #=> [ "kilogram",
+                                              "gram",
+                                              "carat",
+                                              "electron mass",
+                                              "grain",
+                                              "hundredweight long",
+                                              "hundredweight short",
+                                              "ounce",
+                                              "pennyweight",
+                                              "pound",
+                                              "short ton",
+                                              "stone",
+                                              "tonne",
+                                              "unified atomic mass" ]
+ 
+    Unit.ton.si_unit                    #=> 'kg'
 
-  Unit.ton.si_unit                    => 'kg'
+    Unit.ton.dimensions                 #=> <Quantify::Dimensions:0xb75467c8 ... >
 
-  Unit.ton.dimensions                 => <Quantify::Dimensions:0xb75467c8 ... >
+    Unit.ton.dimensions.describe        #=> "mass"
 
-  Unit.ton.dimensions.describe        => "mass"
+    Unit.ton.dimensions.mass            #=> 1
 
-  Unit.ton.dimensions.mass            => 1
+    Unit.ton.dimensions.length          #=> nil
 
-  Unit.ton.dimensions.length          => nil
-
-  
+    
 General introduction
 --------------------
 
@@ -73,89 +73,83 @@ Quantify represents physical quantities using the Quantify::Quantity class.
 A Quantity object holds both a value (Numeric) and a unit (of the class
 Quantify::Unit::Base), for example a Quantity object might represent 12 kgs (value, 12; unit, kilogram).
 
-Quantities can be manipulated and operated on, in all of the ways that might be required for real physical quantities. Operations include, addition, subtraction, multiplying and dividing by scalar values or other quantities, raising to powers, converting into alternative unit representations (e.g. kgs to lbs, miles per hour to metres per second), and rounding of values. Quantify handles the converting of both values and units so that the result is a an accurate representation of the
-operation. For example, multiplying 10 metres by 10 metres will result in a quanity of square metres, whereas dividing, say, 10 metres by 2 seconds will result in a quantity in metres per second.
+Quantities can be manipulated and operated on, in all of the ways that might be required for real physical quantities. Operations include, addition, subtraction, multiplying and dividing by scalar values or other quantities, raising to powers, converting into alternative unit representations (e.g. kgs to lbs, miles per hour to metres per second), and rounding of values. Quantify handles the converting of both values and units so that the result is a an accurate representation of the operation. For example, multiplying 10 metres by 10 metres will result in a quanity of square metres, whereas dividing, say, 10 metres by 2 seconds will result in a quantity in metres per second.
 
 In all cases the results of operations are a changes to the Quantity instance or a new instance of a Quantity object. The new value or unit can be accessed using the #value and #unit attributes, or the #to_s method which renders the quantity in string form.
 
 There are several ways to initialize a quantity object
 
-  mass = Quantity.new(100,:lb)          => <Quantify::Quantity:0xb7332bbc ... >
-  mass = Quantity.new(100,'pound')      => <Quantify::Quantity:0xb7332bbc ... >
-  mass = 100.lb                         => <Quantify::Quantity:0xb7332bbc ... >
-  mass = 100.pound                      => <Quantify::Quantity:0xb7332bbc ... >
-  mass = Quantity.parse "100 lb"        => <Quantify::Quantity:0xb7332bbc ... >
-  mass = "100 lb".to_q                  => <Quantify::Quantity:0xb7332bbc ... >
+    mass = Quantity.new(100,:lb)          #=> <Quantify::Quantity:0xb7332bbc ... >
+    mass = Quantity.new(100,'pound')      #=> <Quantify::Quantity:0xb7332bbc ... >
+    mass = 100.lb                         #=> <Quantify::Quantity:0xb7332bbc ... >
+    mass = 100.pound                      #=> <Quantify::Quantity:0xb7332bbc ... >
+    mass = Quantity.parse "100 lb"        #=> <Quantify::Quantity:0xb7332bbc ... >
+    mass = "100 lb".to_q                  #=> <Quantify::Quantity:0xb7332bbc ... >
 
-Quantity object attributes
+Quantity object can be insterrogated for a range of attributes
 
-  mass.value                            => 100.0
-  mass.unit                             => <Quantify::Unit::NonSI:0xb7332b08 ... >
-  mass.unit.name                        => "pound"
-  mass.unit.symbol                      => "lb"
+    mass.value                            #=> 100.0
+    mass.unit                             #=> <Quantify::Unit::NonSI:0xb7332b08 ... >
+    mass.unit.name                        #=> "pound"
+    mass.unit.symbol                      #=> "lb"
 
-  # unique identifier, follows JScience
-  mass.unit.label                       => "lb"
-  mass.unit.pluralized_name             => "pounds"
-  mass.to_s                             => "100 lb"
-  mass.to_s(:name)                      => "100 pounds"
+    # unique identifier, follows JScience
+    mass.unit.label                       #=> "lb"
+    mass.unit.pluralized_name             #=> "pounds"
+    mass.to_s                             #=> "100 lb"
+    mass.to_s(:name)                      #=> "100 pounds"
 
-  # Describe the physical quantity represented by the quantity
-  mass.represents                       => "mass"
+    # Describe the physical quantity represented by the quantity
+    mass.represents                       #=> "mass"
 
 Convert a quantity to a different unit
 
-  energy = 100.kWh                      => "100 kilowatt hours"
-
-  new_energy = energy.to_megajoules     => "360.0 MJ"
-
-  new_energy = energy.to_MJ             => "360.0 MJ"
-
-  new_energy = energy.to(:MJ)           => "360.0 MJ"
-
-  # Initialize a unit object and pass as conversion argument
-  unit = Unit.MJ                        => <Quantify::Unit::SI:0xb75c9718 ... >
-  new_energy = energy.to(unit)          => "360.0 MJ"
+    energy = 100.kWh                      #=> "100 kilowatt hours"
+  
+    new_energy = energy.to_megajoules     #=> "360.0 MJ"
+  
+    new_energy = energy.to_MJ             #=> "360.0 MJ"
+  
+    new_energy = energy.to(:MJ)           #=> "360.0 MJ"
 
-Note: all of the above results are string representations of the actual objects which result from these operations.
+    # Initialize a unit object and pass as conversion argument
+    unit = Unit.MJ                        #=> <Quantify::Unit::SI:0xb75c9718 ... >
+    new_energy = energy.to(unit)          #=> "360.0 MJ"
 
 Convert the units of a quantity with a compound unit
 
-  speed = 70.mi/1.h                     => "70.0 mi/h"
-
-  speed_in_kms = speed.to_km            => "112.65408 km/h"
+    speed = 70.mi/1.h                     #=> "70.0 mi/h"
 
-  speed_in_mins = speed_in_kms.to_min   => "1.877568 km/min"
+    speed_in_kms = speed.to_km            #=> "112.65408 km/h"
 
-Note: all of the above results are string representations of the actual objects which result from these operations.
+    speed_in_mins = speed_in_kms.to_min   #=> "1.877568 km/min"
 
 Convert a quantity to the corresponding SI unit
 
-  energy = 100.kWh                      => "100 kWh"
-  si = quantity.to_si                   => "360000000.0 J"
-
-Note: all of the above results are string representations of the actual
-objects which result from these operations.
+    energy = 100.kWh                      #=> "100 kWh"
+    si = quantity.to_si                   #=> "360000000.0 J"
 
 Operate on a quantity
 
-  mass = 10.kg * 3                      => "30.0 kg"
+    mass = 10.kg * 3                      #=> "30.0 kg"
 
-  distance = 100.light_years / 20       => "5.0 ly"
+    distance = 100.light_years / 20       #=> "5.0 ly"
 
-  area = 10.m * 10.m                    => "100.0 square metres"
+    area = 10.m * 10.m                    #=> "100.0 square metres"
 
-  speed = 250.mi / 3.h                  => "83.3333333333333 miles per hour"
+    speed = 250.mi / 3.h                  #=> "83.3333333333333 miles per hour"
 
-  speed = 70.mi/1.h                     => <Quantify::Quantity:0xb7332bbc ... >
-  time = 0.5.h                          => <Quantify::Quantity:3xf3472hjc ... >
-  distance = speed * time               => <Quantify::Quantity:7d7f8g9d5g ... >
-  distance.to_s                         => "35.0 mi"
+    speed = 70.mi/1.h                     #=> <Quantify::Quantity:0xb7332bbc ... >
+    time = 0.5.h                          #=> <Quantify::Quantity:3xf3472hjc ... >
+    distance = speed * time               #=> <Quantify::Quantity:7d7f8g9d5g ... >
+    distance.to_s                         #=> "35.0 mi"
 
 Note: all of the above results are string representations of the actual
 objects which result from these operations.
 
 Additional operations
+---------------------
+
 The result of quantity operations is commonly a new quantity with a compound unit. Unless the result is equivalent to one of the base SI units (m, kg, s, K, etc.) or one of the following, square metre, cubic metre, joule, watt, newton or pascal, then the compound unit represents appropriate combination of the units involved, albeit with any like-units within the numerator and denominator grouped under a single
 power/index.
 
@@ -163,64 +157,24 @@ Units are not automatically cancelled or rationalized (made consistent). This is
 and the user may not necessarily prefer a conversion into consistent mass units (e.g. g/g or t/t). Therefore, the following methods are available...
 
 Where units representing the same physical quantity appear together, they can be made consistent by simply converting to the unit which is desired:
-
-  area = 12.yd * 36.ft                  => <Quantify::Quantity:0xb7332bbc ... >
-  area.to_s                             => "432.0 yd ft"
-  area.to_yd
-  area.to_s                             => "144.0 yd²"
+    
+    area = 12.yd * 36.ft                  #=> <Quantify::Quantity:0xb7332bbc ... >
+    area.to_s                             #=> "432.0 yd ft"
+    area.to_yd
+    area.to_s                             #=> "144.0 yd²"
 
 Alternatively, all units within the numerator and denominator respectively can be standardized:
 
-  quantity = (12.ft*8.mi)/(1.s*8.min)
-  quantity.to_s                         => 12.0 ft mi/s min
-  quantity.rationalize_units!
-  quantity.to_s                         => 1056.0 ft²/s²
+    quantity = (12.ft*8.mi)/(1.s*8.min)
+    quantity.to_s                         #=> 12.0 ft mi/s min
+    quantity.rationalize_units!
+    quantity.to_s                         #=> 1056.0 ft²/s²
 
 A quantity with arbitrary cancelable units can be cancelled manually:
 
-  quantity = (12.m**6) / 2.m**2
-  quantity.to_s                         => "746496.0 m^6/m²"
-  quantity.cancel_base_units! :m
-  quantity.to_s                         => "746496.0 m^4"
-
-Note: there are more comprehensive and flexible methods for manupulating compound units available as part of of the class Unit::Compound. These can be used to convert a conpound unit into the precise form required. If such an approach is used, any quantity object can be converted to the new form by simply passing the new unit object into the Quantity#to method.
-
-Initializing unit objects
--------------------------
-
-  unit = Unit.for :km                    => <Quantify::Unit::SI:0xb75c9718 ... >
-  unit = Unit.km                         => <Quantify::Unit::SI:0xb75c9718 ... >
-  unit = Unit.kilometre                  => <Quantify::Unit::SI:0xb75c9718 ... >
-  
-  unit.name                              => 'kilometre'
-  unit.symbol                            => 'kg'
-  unit.label                             => 'kg'
-  unit.dimensions                        => <Quantify::Dimensions:0xb75c4254 .. >
-  unit.measures                          => 'length'
-  unit.alternatives :name                => ['metre','megametre','gigametre',
-                                             'terametre','angstrom','astronomical unit',
-                                             'baromil','chain','dram','ell','fathom',
-                                             'fermi','foot us survey','foot','furlong',
-                                             'hand','inch','nautical league',
-                                             'statute league','light year', 'line','link',
-                                             'yard']
-
-  other_unit = Unit.hour
-  other_unit.name                        => 'hour'
-  other_unit.symbol                      => 'h'
-  other_unit.measures                    => 'time'
-  other_unit.alternatives :symbol        => [ 's', 'ks', 'Ms', 'Gs', 'Ts', 'd', 'min' ]
-
-  another_unit = unit / other_unit       => <Quantify::Unit::Compound:0xb74af323 ... >
-  another_unit.name                      => 'kilometer per hour'
-  another_unit.symbol                    => 'km/h'
-  another_unit.measures                  => 'velocity'
-  another_unit.base_units.map(&:name)    => ['kilogram','hour']
-
-  last_unit = Unit.m
-  last.unit.measures                     => 'length'
-  square = last_unit ** 2                => <Quantify::Unit::Compound:0xb446f12f ... >
-  square.symbol                          => 'm²'
-  square.measures                        => 'area'
-
+    quantity = (12.m**6) / 2.m**2
+    quantity.to_s                         #=> "746496.0 m^6/m²"
+    quantity.cancel_base_units! :m
+    quantity.to_s                         #=> "746496.0 m^4"
 
+Note: there are more comprehensive and flexible methods for manupulating compound units available as part of of the class Unit::Compound. These can be used to convert a conpound unit into the precise form required. If such an approach is used, any quantity object can be converted to the new form by simply passing the new unit object into the Quantity#to method.

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.3

data/lib/quantify/core_extensions/numeric.rb

@@ -1,4 +1,3 @@
-
 class Numeric
   # Syntactic sugar for defining instances of the Quantity class.
   #
@@ -10,7 +9,9 @@ class Numeric
   #   1000.t         is equivalent to Quantity. new 1000, :t
   #
   def method_missing(method, *args, &block)
-    if unit = Unit.for(method.to_s)
+    if (method == :to_str || method == :to_ary)
+      super
+    elsif unit = Unit.for(method.to_s)
       Quantify::Quantity.new self, unit
     else
       super

data/lib/quantify/quantity.rb

@@ -44,20 +44,47 @@ module Quantify
     # 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.
-    def self.parse(string)
-      words = string.words
-      quantities = words.each_with_index.map do |word,index|
+    def self.parse(string,options={})
+      
+      quantities   = []
+      remainder    = []
+      words        = string.words
+
+      until words.empty? do
+        word = words.shift
         if word.starts_with_number?
-          # 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 (Unit::QUANTITY_REGEX).match(word)
-          # Parse string for unit references
-          unit = Unit.parse(string, :iterative => true) || Unit.dimensionless
-          # Instantiate quantity using value and unit
-          Quantity.new(value,unit)
+          if (Unit::QUANTITY_REGEX).match(word)
+            word, other = $1, $2
+            words.unshift(other)
+          end
+          quantities << [word]
+        else
+          if quantities.empty?
+            remainder << word
+          else
+            quantities.last << word
+          end
         end
+      end      
+
+      remainders = []
+      remainders << remainder.join(" ")
+
+      quantities.map! do |words|
+
+        value = words.shift
+        string = words.join(" ")
+
+        # Parse string for unit references
+        unit, remainder = Unit.parse(string, :iterative => true, :remainder => true) 
+        unit, remainder = Unit.dimensionless, string if unit.nil?
+        remainders << remainder
+
+        # Instantiate quantity using value and unit
+        Quantity.new(value,unit)
+          
       end.compact
+      return [quantities, remainders] if options[:remainder] == true
       return quantities
     rescue Quantify::Exceptions::InvalidArgumentError
       raise Quantify::Exceptions::QuantityParseError, "Cannot parse string into value and unit"
@@ -66,7 +93,16 @@ module Quantify
     def self.configure(&block)
       self.class_eval(&block) if block
     end
+
+    def self.auto_consolidate_units=(true_or_false)
+      @auto_consolidate_units = true_or_false
+    end
     
+    def self.auto_consolidate_units?
+      @auto_consolidate_units.nil? ? false : @auto_consolidate_units
+    end
+    #alias :auto_consolidate_units? :auto_consolidate_units
+
     protected
 
     def self.is_basic_conversion_with_scalings?(quantity,new_unit)
@@ -281,6 +317,7 @@ module Quantify
         return self
       elsif other.kind_of? Quantity
         @unit = @unit.send(operator,other.unit).or_equivalent
+        @unit.consolidate_base_units! if @unit.is_compound_unit? && Quantity.auto_consolidate_units?
         @value = @value.send(operator,other.value)
         return self
       else

data/lib/quantify/unit/compound_unit.rb

@@ -146,7 +146,7 @@ module Quantify
       end
 
       # Consilidates base quantities by finding multiple instances of the same unit
-      # type and reducing them into a single unit represenation, by altering the
+      # type and reducing them into a single unit representation, by altering the
       # repsective index. It has the effect of raising units to powers and cancelling
       # those which appear in the numerator AND denominator
       #

data/lib/quantify/unit/unit.rb

@@ -247,10 +247,22 @@ module Quantify
     #
     def self.parse(string, options={})
       string = string.remove_underscores.without_superscript_characters
-      units = options[:iterative] == true ? Unit.iterative_parse(string) : Unit.simple_parse(string)
-      return nil if units.empty?
-      return units.first.unit if units.size == 1 && units.first.index == 1
-      return Unit::Compound.new(*units)
+      if options[:iterative] == true
+        units = Unit.iterative_parse(string, options) 
+        units, remainder = units if options[:remainder] == true
+      else
+        units = Unit.simple_parse(string)
+      end
+
+      if units.empty?
+        units = nil 
+      elsif units.size == 1 && units.first.index == 1
+        units = units.first.unit
+      else
+        units = Unit::Compound.new(*units)
+      end
+
+      options[:iterative] == true && options[:iterative] == true ? [units, remainder] : units
     end
     
     # This returns the suite of units which represents THE SI units for each of
@@ -320,7 +332,7 @@ module Quantify
       return units
     end
     
-    def self.iterative_parse(string)
+    def self.iterative_parse(string, options={})
       units=[]
       is_denominator = false
       current_exponent = nil
@@ -341,6 +353,7 @@ module Quantify
         match_length = term.size
         string = string[match_length, string.length-match_length].strip
       end
+      return [units, string] if options[:remainder] == true
       return units
     end
     

data/quantify.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "quantify"
-  s.version = "3.1.2"
+  s.version = "3.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andrew Berkeley"]
-  s.date = "2012-01-18"
+  s.date = "2012-05-01"
   s.description = "A gem to support physical quantities and unit conversions"
   s.email = "andrew.berkeley.is@googlemail.com"
   s.extra_rdoc_files = [
@@ -54,7 +54,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/spatchcock/quantify"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
+  s.rubygems_version = "1.8.17"
   s.summary = "Support for handling physical quantities, unit conversions, etc"
 
   if s.respond_to? :specification_version then

data/spec/quantity_spec.rb

@@ -249,6 +249,22 @@ describe Quantity do
     quantities.first.value.should == 10
     quantities.first.unit.symbol.should == 'mi/h'
   end
+
+  it "should create a valid instance with class parse method and return remainders" do
+    quantities = Quantity.parse "I sprayed 500L of fertilizer across 6000m^2 of farmland", :remainder => true
+    quantities.first.should be_a Array
+    quantities.first[0].value.should == 500
+    quantities.first[0].unit.name.should == 'litre'
+    quantities.first[0].unit.symbol.should == 'L'
+    quantities.first[1].value.should == 6000
+    quantities.first[1].unit.pluralized_name.should == 'square metres'
+    quantities.first[1].unit.symbol.should == 'm²'
+    quantities[1].should be_a Array
+    quantities[1].size.should eql 3
+    quantities[1][0].should eql "I sprayed"
+    quantities[1][1].should eql "of fertilizer across"
+    quantities[1][2].should eql "of farmland"
+  end
   
   it "should parse using string method" do
     "20 m".to_q.first.value.should == 20.0
@@ -525,13 +541,13 @@ describe Quantity do
   end
 
   it "should return between value from range" do
-    (2.ft..20.ft).send(RUBY_VERSION < "1.9" ? :include? : :cover?, 3.ft).should be_true
+    (2.ft..20.ft).cover?(3.ft).should be_true
   end
 
   it "should return between value from range with different units" do
-    (2.ft..4.m).send(RUBY_VERSION < "1.9" ? :include? : :cover?, 200.cm).should be_true
-    (1.ly..1.parsec).send(RUBY_VERSION < "1.9" ? :include? : :cover?, 2.ly).should be_true
-    (1.ly..1.parsec).send(RUBY_VERSION < "1.9" ? :include? : :cover?, 2.in).should be_false
+    (2.ft..4.m).cover?(200.cm).should be_true
+    (1.ly..1.parsec).cover?(2.ly).should be_true
+    (1.ly..1.parsec).cover?(2.in).should be_false
   end
 
   it "should return between value from range using === operator" do
@@ -551,5 +567,45 @@ describe Quantity do
   it "range comparison with non quantity should raise error" do
     lambda{20.ft === (1.ft..3)}.should raise_error
   end
+
+  it "should return unit consolidation setting" do
+    Quantity.auto_consolidate_units?.should be_false
+  end
+
+  it "should set unit consolidation setting" do
+    Quantity.auto_consolidate_units?.should be_false
+
+    Quantity.auto_consolidate_units=true
+    Quantity.auto_consolidate_units?.should be_true
+
+    Quantity.auto_consolidate_units=false
+    Quantity.auto_consolidate_units?.should be_false
+  end
+
+  it "should return non-consolidated units if consolidation disabled" do
+    quantity = 20.L * 1.km * (5.lb / 1.L)
+    quantity.to_s.should eql "100.0 L km lb/L"
+  end
+
+  it "should return equivalent units if consolidation disabled" do
+    quantity = 20.L * (5.lb / 1.L)
+    quantity.to_s.should eql "100.0 lb"
+  end
+
+  it "should return equivalent units if consolidation enabled" do
+    Quantity.auto_consolidate_units=true
+    quantity = 20.L * (5.lb / 1.L)
+    quantity.to_s.should eql "100.0 lb"
+  end
+
+  it "should return consolidated units if enabled" do
+    Quantity.auto_consolidate_units=true
+    quantity = 20.L * 1.km * (5.lb / 1.L)
+    quantity.to_s.should eql "100.0 km lb"
+  end
+
+  it "should return consolidated units if enabled" do
+    
+  end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: quantify
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 3
   - 1
-  - 2
-  version: 3.1.2
+  - 3
+  version: 3.1.3
 platform: ruby
 authors: 
 - Andrew Berkeley
@@ -15,10 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-18 00:00:00 Z
+date: 2012-05-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
+  prerelease: false
+  type: :runtime
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -29,11 +31,11 @@ dependencies:
         - 3
         - 0
         version: "3.0"
-  type: :runtime
-  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: i18n
+  prerelease: false
+  type: :runtime
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -43,11 +45,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :runtime
-  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: bundler
+  prerelease: false
+  type: :development
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -59,11 +61,11 @@ dependencies:
         - 0
         - 0
         version: 1.0.0
-  type: :development
-  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: jeweler
+  prerelease: false
+  type: :development
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -75,11 +77,11 @@ dependencies:
         - 6
         - 4
         version: 1.6.4
-  type: :development
-  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rspec
+  prerelease: false
+  type: :development
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -91,11 +93,11 @@ dependencies:
         - 6
         - 0
         version: 2.6.0
-  type: :development
-  prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: rcov
+  prerelease: false
+  type: :development
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -105,11 +107,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  prerelease: false
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: rdoc
+  prerelease: false
+  type: :development
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -119,8 +121,6 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  prerelease: false
   version_requirements: *id007
 description: A gem to support physical quantities and unit conversions
 email: andrew.berkeley.is@googlemail.com
@@ -194,7 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Support for handling physical quantities, unit conversions, etc