unite 1.2.0 → 1.3.0

data/lib/unite/lookup.rb

@@ -21,9 +21,19 @@ module Unite
     class << self
       def add object
         raise Invalid, object.errors.inspect unless object.valid?
-        raise Duplicate, "The Unit #{object.name} already exists" unless @@unit_names[object.name.to_sym].nil?
+
+        names = [object.name] + object.aliases
+
+        names.each do |name|
+          raise Duplicate, "The Unit #{name} already exists" unless @@unit_names[name.to_sym].nil?
+        end
+
         key = store_object object
-        @@unit_names[object.name.to_sym] = key
+
+        names.each do |name|
+           @@unit_names[name.to_sym] = key
+        end
+
         @@unit_ints[object.dimension_int] ||= []
         @@unit_ints[object.dimension_int] << key
       end

data/lib/unite/quantity.rb

@@ -5,6 +5,7 @@ module Unite
     include Dimension::Vector
     include Conversion
     include Arithmetic
+    include Simplify
 
     def initialize(attributes = {})
       attributes.each do |name, value|
@@ -13,7 +14,6 @@ module Unite
       super
     end
 
-
     #Initialize the quantity,
     #
     #A nil value is treated as 0.0

data/lib/unite/si_factor.rb

@@ -0,0 +1,35 @@
+
+# -*- encoding : utf-8 -*-
+module Unite
+  class IncompatibleError < RuntimeError
+  end
+
+  module SiFactor
+
+    extend ::ActiveSupport::Concern
+    include Fraction
+
+    included do
+
+    end
+
+    module ClassMethods
+
+    end
+
+    protected
+
+    def si_factor
+      value * (get_si_factor(numerator) / get_si_factor(denominator))
+    end
+
+    def get_si_factor unit_array
+      expand_unit_array(unit_array).map do |element|
+        Lookup.find!(element).si_factor
+      end.inject(BigDecimal.new(1)) {|product, factor| product*factor}
+    end
+
+
+  end
+end
+

data/lib/unite/simplify.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+module Unite
+
+  module Simplify
+    extend ::ActiveSupport::Concern
+
+    included Conversion
+    included Fraction
+
+    included do
+
+    end
+
+    module ClassMethods
+
+    end
+
+    def simplify
+      new_unit = simple_unit
+      convert_to!(new_unit) if new_unit && new_unit != self.unit
+      self
+    end
+
+    private
+
+    def simple_unit
+       u = Lookup.compatible_units(dimension_int).first
+       u ? u.name : u
+    end
+
+  end
+end
+

data/lib/unite/unit.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+module Unite
+  class Unit
+
+    include Dimension::Vector
+    include Comparison
+    include SiFactor
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+      super
+    end
+
+    #Initialize the quantity,
+    #
+    #A nil value is treated as 0.0
+    def self.init unit
+      new :expression => "#{unit}"
+    end
+
+    attr_accessor :name, :numerator, :denominator, :cached_expression
+    alias :to_s :expression
+
+    def value
+      @value ||= BigDecimal.new(1)
+    end
+
+    def value= x
+      value
+    end
+  end
+end

data/lib/unite/version.rb

@@ -1,3 +1,3 @@
 module Unite
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/unite.rb

@@ -21,11 +21,13 @@ end
 # Dir["#{Rails.root.to_s}/lib/units/**/*.rb"].each {|file| require file }
 require 'unite/fraction'
 require 'unite/dimension'
+require 'unite/si_factor'
 require 'unite/comparison'
 require 'unite/conversion'
 require 'unite/arithmetic'
+require 'unite/simplify'
 
-
+require "unite/unit"
 require 'unite/lookup'
 
 require "unite/quantity"

data/spec/dimension_spec.rb

@@ -17,9 +17,14 @@ describe Unite::Dimension do
   end
 
 
-  it "should return the correct si unit" do
+  it "should return the correct si unit for dimension name" do
     Unite::Dimension::LIST.map{|d| Unite::Dimension.si_unit(d)}.should == 
-      ['meter', 'second', 'kelvin', 'kilogram', 'ampere', 'mole', 'candela', 'GBP', '']
+      ['km', 's', 'K', 'kg', 'A', 'mol', 'cd', 'GBP', '']
+  end
+
+  it "should return the correct si unit for dimension index" do
+    Unite::Dimension::LIST.each_with_index.map {|_,i| Unite::Dimension.si_unit(i)}.should == 
+      ['km', 's', 'K', 'kg', 'A', 'mol', 'cd', 'GBP', '']
   end
 
   its(:blank_dimension_vector) { should == [0,0,0,0,0,0,0,0] }

data/spec/lookup/derived_unit_spec.rb

@@ -20,18 +20,14 @@ module Unite
 
     describe 'based off of simple units' do
       subject { DerivedUnit.new(:name => "J", :expression => 'kg*m^2/s^2') }
-
       its(:dimension_vector) { should == [2, -2, 0, 1, 0, 0, 0, 0] }
       its(:property_name) { should == :energy }
     end
 
     describe 'based off of other derived unit' do
-
       subject { DerivedUnit.new(:name => "kWh", :expression => '3.6e5*J') }
-
       its(:dimension_vector) { should == [2, -2, 0, 1, 0, 0, 0, 0] }
       its(:property_name) { should == :energy }
-
     end
 
     include_examples "comparable unit"

data/spec/lookup/simple_unit_spec.rb

@@ -31,10 +31,8 @@ module Unite
     describe "instance methods" do
       let(:dimension) { :length }
       subject { Fabricate.build :simple_unit, :name => "m", :si_factor => 1, :dimension => :length }
-
       its(:dimension_vector) { should == Dimension::VECTOR_LIST.map{|d| d == dimension ? 1 : 0}}
       its(:property_name) { should == :distance }
-
     end
 
     describe "class methods" do

data/spec/lookup_spec.rb

@@ -9,7 +9,7 @@ module Unite
     describe "adding and finding" do
 
       def unit_stub stubs_hash
-        stub({:valid? => true, :errors => {} , :dimension_int => 30}.merge(stubs_hash))
+        stub({:valid? => true, :errors => {} , :dimension_int => 30, :aliases => []}.merge(stubs_hash))
       end
 
       def property_stub stubs_hash
@@ -23,7 +23,8 @@ module Unite
 
       describe "units" do
         let(:name) { 'scott' }
-        let(:unit_object) { unit_stub(:valid? => valid, :name => name) }
+        let(:aliases) { ['awesome', 'greatest_of_all_time']  }
+        let(:unit_object) { unit_stub(:valid? => valid, :name => name, :aliases => aliases) }
         context "with invalid object" do
           let(:valid) { false }
 
@@ -43,6 +44,11 @@ module Unite
             subject.find!(name).should == unit_object
           end
 
+          it 'should be able to find the unit by alias' do
+            aliases.each do |a|
+              subject.find!(a).should == unit_object
+            end
+          end
 
           it "should raise not found if unit is undefined" do
             lambda { subject.find!(name+"undefined") }.should raise_exception(Lookup::Undefined)
@@ -57,6 +63,16 @@ module Unite
             end
           end
 
+          context "with non uniq alias" do
+            let(:duplicate_alias) { aliases.first }
+            let(:uniq_name) { name + "uniq" }
+            let(:duplicate_unit_object) { unit_stub(:name => uniq_name, :aliases => [duplicate_alias]) }
+
+            it "should raise an error" do
+              lambda { subject.add(duplicate_unit_object) }.should raise_exception(Lookup::Duplicate)
+            end
+          end
+
           describe "compatible units" do
             let(:compatible_unit_object) { unit_stub(:name => "unit_name1", :dimension_int => unit_object.dimension_int) }
             let(:incompatible_unit_object) { unit_stub(:name => "unit_name2", :dimension_int => (unit_object.dimension_int + 10)) }

data/spec/money_spec.rb

@@ -0,0 +1,35 @@
+# require 'spec_helper'
+
+# module Unite
+  # describe "Money Conversions" do
+  #   describe "performing arithmetic" do
+  #     subject { Quantity.init("100", "GBP") }
+
+  #     context "when currency is the same" do
+  #       let(:other) { Quantity.init("100", "GBP") }
+
+  #       [:+,:-, :/, :*].each do |op|
+  #         it "should not raise error when op is #{op}" do
+  #           lambda { subject.send(op,other) }.should_not raise_exception
+  #         end
+  #       end
+
+  #     end
+
+  #     context "when currency is different" do
+  #       let(:other) { Quantity.init("100", "CAD") }
+
+  #       [:+,:-, :/, :*].each do |op|
+  #         it "should not raise error when op is #{op}" do
+  #           subject.send(op,other)
+  #           # lambda { 
+  #             # debugger
+  #             # subject.send(op,other) }.should_not raise_exception
+  #         end
+  #       end
+
+  #     end
+
+  #   end
+  # end
+# end

data/spec/quantity_spec.rb

@@ -12,6 +12,7 @@ module Unite
     include_examples "convertable value"
     include_examples "dimension vectors"
     include_examples "unit fractions"
+    include_examples "simplify units"
 
 
     describe ".init" do

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 
 begin
-  require 'ruby-debug'
+  require 'byebug'
   puts "USING DEBUGGER"
 rescue
   puts "NOT USING DEBUGGER"
@@ -19,7 +19,6 @@ require 'mocha'
 require 'unite'
 require 'fabrication'
 
-
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

data/spec/support/shared_examples/units/arithmetic.rb

@@ -102,6 +102,27 @@ shared_examples "unit arithmetic" do
         include_examples "division operation"
       end
 
+
+      context "that are compatible but inverse" do
+        let(:expression1) { "10*km" }
+        let(:expression2) { "1000/m" }
+
+
+        let(:division_result) { [0.00001, 'km^2'] }
+        let(:multiplication_result) { [10000000, ''] }
+
+        include_examples "multiplication operation"
+        include_examples "division operation"
+
+        it "should raise error for subtraction" do
+          lambda { object1 - object2 }.should raise_exception Unite::IncompatibleError
+        end
+        it "should raise error for addition" do
+          lambda { object1 + object2 }.should raise_exception Unite::IncompatibleError
+        end
+      end
+
+
       context "that are incompatible " do
         let(:expression1) { "10*kg" }
         let(:expression2) { "10*m" }

data/spec/support/shared_examples/units/conversion.rb

@@ -4,53 +4,124 @@ shared_examples "convertable value" do
   describe "converted unit" do
     let(:original) { described_class.new :expression => from }
     let(:final) { described_class.new :expression => to } 
-    subject { original.convert_to(final) }
 
-    context "with compatible units" do
-      let(:from) { '2*km' } 
-      let(:to) { 'm' }
+    describe "convert_to" do
+      subject { original.convert_to(final) }
 
-      its(:value) { should == 2000.0 }
-      its(:unit) { should == 'm' }
-    end
+      context "with compatible units" do
+        let(:from) { '2*km' } 
+        let(:to) { 'm' }
 
-    context "with no unit" do
-      let(:from) { '1.0' } 
-      let(:to) { '' }
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
 
-      its(:value) { should == 1.0 }
-      its(:unit) { should == '' }
-    end
+      context "with no unit" do
+        let(:from) { '1.0' } 
+        let(:to) { '' }
 
-    context "with exponents on units" do
-      let(:from) { '1000000*m^2' } 
-      let(:to) { 'km^2' }
+        its(:value) { should == 1.0 }
+        its(:unit) { should == '' }
+      end
 
-      its(:value) { should == 1.0 }
-      its(:unit) { should == 'km^2' }
-    end
+      context "with exponents on units" do
+        let(:from) { '1000000*m^2' } 
+        let(:to) { 'km^2' }
 
-    context "with non compatible units" do
-      let(:from) { '1000000*m' } 
-      let(:to) { 'km^2' }
-      it { should be_nil } 
-    end
+        its(:value) { should == 1.0 }
+        its(:unit) { should == 'km^2' }
+      end
+
+      context "with non compatible units" do
+        let(:from) { '1000000*m' } 
+        let(:to) { 'km^2' }
+        it { should be_nil } 
+      end
+
+      context "with derived units" do
+        let(:from) { '3.6e7*J' } 
+        let(:to) { 'kWh' }
+
+        its(:value) { should == 10.0 }
+        its(:unit) { should == 'kWh' }
+      end
 
-    context "with derived units" do
-      let(:from) { '3.6e7*J' } 
-      let(:to) { 'kWh' }
+      context "with value on the to" do
+        let(:from) { '2*km' } 
+        let(:to) { '10*m' }
+
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
+
+      context "with string value for to" do
+        let(:from) { '2*km' } 
+        let(:final) { 'm' }
+
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
 
-      its(:value) { should == 10.0 }
-      its(:unit) { should == 'kWh' }
     end
 
-    context "with value on the to" do
-      let(:from) { '2*km' } 
-      let(:to) { '10*m' }
+    describe "convert_to!" do
+      subject { original.convert_to!(final) }
+
+      context "with compatible units" do
+        let(:from) { '2*km' } 
+        let(:to) { 'm' }
+
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
+
+      context "with no unit" do
+        let(:from) { '1.0' } 
+        let(:to) { '' }
+
+        its(:value) { should == 1.0 }
+        its(:unit) { should == '' }
+      end
+
+      context "with exponents on units" do
+        let(:from) { '1000000*m^2' } 
+        let(:to) { 'km^2' }
+
+        its(:value) { should == 1.0 }
+        its(:unit) { should == 'km^2' }
+      end
+
+      context "with non compatible units" do
+        let(:from) { '1000000*m' } 
+        let(:to) { 'km^2' }
+        it { -> { subject }.should raise_exception(Unite::IncompatibleError) } 
+      end
+
+      context "with derived units" do
+        let(:from) { '3.6e7*J' } 
+        let(:to) { 'kWh' }
+
+        its(:value) { should == 10.0 }
+        its(:unit) { should == 'kWh' }
+      end
+
+      context "with value on the to" do
+        let(:from) { '2*km' } 
+        let(:to) { '10*m' }
+
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
+
+      context "with string value for to" do
+        let(:from) { '2*km' } 
+        let(:final) { 'm' }
+
+        its(:value) { should == 2000.0 }
+        its(:unit) { should == 'm' }
+      end
 
-      its(:value) { should == 2000.0 }
-      its(:unit) { should == 'm' }
     end
-  end
 
+  end
 end

data/spec/support/shared_examples/units/fractions.rb

@@ -6,12 +6,12 @@ shared_examples_for "unit fractions" do
 
     describe "required methods" do
       subject {  described_class.new }
-      it { should respond_to(:value) } 
-      it { should respond_to(:value=) } 
-      it { should respond_to(:numerator) } 
-      it { should respond_to(:numerator=) } 
-      it { should respond_to(:denominator=) } 
-      it { should respond_to(:denominator=) } 
+      it { should respond_to(:value) }
+      it { should respond_to(:value=) }
+      it { should respond_to(:numerator) }
+      it { should respond_to(:numerator=) }
+      it { should respond_to(:denominator=) }
+      it { should respond_to(:denominator=) }
     end
 
     describe "big decimal" do
@@ -37,7 +37,7 @@ shared_examples_for "unit fractions" do
 
         its(:unit) { should == '' }
         its(:value) { should == 5.7 }
-        its(:expression) { should == '5.7' } 
+        its(:expression) { should == '5.7' }
       end
 
       context "with number and unit" do
@@ -45,7 +45,7 @@ shared_examples_for "unit fractions" do
 
         its(:unit) { should == 'm/s^2' }
         its(:value) { should == 2.0 }
-        its(:expression) { should == '2.0*m/s^2' } 
+        its(:expression) { should == '2.0*m/s^2' }
       end
 
       context "with only unit" do
@@ -53,7 +53,7 @@ shared_examples_for "unit fractions" do
 
         its(:unit) { should == 'm/s' }
         its(:value) { should == 1.0 }
-        its(:expression) { should == '1.0*m/s' } 
+        its(:expression) { should == '1.0*m/s' }
       end
 
       context "with no numerator" do
@@ -61,7 +61,7 @@ shared_examples_for "unit fractions" do
 
         its(:unit) { should == '1.0/s' }
         its(:value) { should == 10.0 }
-        its(:expression) { should == '10.0/s' } 
+        its(:expression) { should == '10.0/s' }
       end
 
       context 'with too many /' do
@@ -75,25 +75,33 @@ shared_examples_for "unit fractions" do
         let(:expression) { '/' }
         its(:unit) { should == '' }
         its(:value) { should == 0.0 }
-        its(:expression) { should == '0.0' } 
+        its(:expression) { should == '0.0' }
       end
 
 
       context "with spaces" do
-        let(:expression) { '10 * km / 5 *h ' }
+        let(:expression) { '10 * km / 5 *h' }
 
         its(:unit) { should == 'km/h' }
         its(:value) { should == 2.0 }
-        its(:expression) { should == '2.0*km/h' } 
+        its(:expression) { should == '2.0*km/h' }
       end
 
+
+      context "with negative exponent" do
+        let(:expression) { '2 * s^-2 / m^-1 ' }
+
+        its(:unit) { should == 'm/s^2' }
+        its(:value) { should == 2.0 }
+        its(:expression) { should == '2.0*m/s^2' }
+      end
     end
 
     describe 'default' do
-      subject { described_class.new } 
+      subject { described_class.new }
       its(:unit) { should == '' }
       its(:value) { should == 0.0 }
-      its(:denominator) { should == [] } 
+      its(:denominator) { should == [] }
       its(:numerator) { should == [] }
     end
 
@@ -110,14 +118,14 @@ shared_examples_for "unit fractions" do
         let(:expression) { 'kg*s^2/s*kg^3' }
 
         its(:unit) { should == 's/kg^2' }
-        its(:expression) { should == '1.0*s/kg^2' } 
+        its(:expression) { should == '1.0*s/kg^2' }
       end
 
       context "with empty numerator" do
         let(:expression) { 'kg/kg^3' }
 
         its(:unit) { should == '1.0/kg^2' }
-        its(:expression) { should == '1.0/kg^2' } 
+        its(:expression) { should == '1.0/kg^2' }
       end
 
     end

data/spec/support/shared_examples/units/simplify.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+shared_examples "simplify units" do
+
+  describe "converted unit" do
+    subject {described_class.new(:expression => expression).simplify }
+
+
+    context "with cancelling units" do
+      let(:expression) { '5.7*km^2/m*h' }
+
+      its(:unit) { should == 'km/h' }
+      its(:value) { should be_within(1e-10).of(5700) }
+      its(:expression) { should == '5700.0*km/h' }
+    end
+
+    context "with a equivalent derived unit" do
+      let(:expression) { '1*kg*m^2/s^2' }
+
+      its(:unit) { should == 'J' }
+      its(:value) { should be_within(1e-10).of(1) }
+      its(:expression) { should == '1.0*J' }
+    end
+
+  end
+end
+