unitfy 1.0.0

data/spec/lookup/derived_unit_spec.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'unity/lookup/derived_unit.rb'
+
+module Unity
+  describe DerivedUnit do
+    it { should validate_presence_of(:name)}
+
+    %w{ F J Hz N }.each do |unit|
+      it "should allow valid unit #{unit}" do 
+        Fabricate.build(:derived_unit, :name => unit).should be_valid
+      end
+    end  
+
+    %w{km^3 m/g km*tonne}.each do |unit|
+      it "should not allow invalid unit #{unit}" do 
+        Fabricate.build(:derived_unit, :name => unit).should_not be_valid
+      end
+    end
+
+    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"
+    include_examples "dimension integer"
+    include_examples "convertable value"
+    include_examples "dimension vectors"
+    include_examples "unit fractions"
+
+  end
+end

data/spec/lookup/property_spec.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'unity/lookup/property.rb'
+
+module Unity
+  describe Property do
+    it { should validate_presence_of(:name)}
+
+
+    include_examples "comparable unit"
+    include_examples "dimension integer"
+    include_examples "convertable value"
+    include_examples "dimension vectors"
+    include_examples "unit fractions"
+
+  end
+end
+

data/spec/lookup/simple_unit_spec.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'unity/lookup/simple_unit.rb'
+
+module Unity
+  describe SimpleUnit do
+    it { should ensure_inclusion_of(:dimension).in_array(Dimension::LIST) }
+    it { should validate_presence_of(:si_factor)}
+    it { should validate_presence_of(:name)}
+    it { should validate_presence_of(:dimension)}
+
+    %w{ $ £ € m }.each do |unit|
+      it "should allow valid unit #{unit}" do
+        Fabricate.build(:simple_unit, :name => unit).should be_valid
+      end
+    end
+
+    %w{km^3 m/g km*tonne}.each do |unit|
+      it "should not allow invalid unit #{unit}" do 
+        Fabricate.build(:simple_unit, :name => unit).should_not be_valid
+      end
+    end
+
+    describe "instance methods" do
+      let(:dimension) { :length }
+      subject { Fabricate.build :simple_unit, :name => "m", :si_factor => 1, :dimension => :length }
+
+      its(:dimension_vector) { should == Dimension::LIST.map{|d| d == dimension ? 1 : 0}}
+      its(:property_name) { should == :distance }
+
+    end
+
+    describe "class methods" do
+      subject { SimpleUnit } 
+
+    end
+
+    include_examples "dimension integer"
+
+  end
+end

data/spec/lookup_spec.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Unity
+  describe Lookup do
+    subject { Lookup } 
+
+
+    describe "adding and finding" do
+
+      def unit_stub stubs_hash
+        stub({:valid? => true, :errors => {} , :dimension_int => 30}.merge(stubs_hash))
+      end
+
+      def property_stub stubs_hash
+        stub({:name => :quasar, :expression => 'qu', :valid? => true, :errors => {} , :dimension_int => 30}.merge(stubs_hash))
+      end
+
+
+      after do
+        subject.reload!
+      end
+
+      describe "units" do
+        let(:name) { 'scott' }
+        let(:unit_object) { unit_stub(:valid? => valid, :name => name) }
+        context "with invalid object" do
+          let(:valid) { false }
+
+          it "should raise an error" do
+            lambda { subject.add(unit_object) }.should raise_exception(Lookup::Invalid)
+          end
+
+        end
+
+        context "with valid object" do
+          let(:valid) { true }
+          before do
+            subject.add(unit_object)
+          end
+
+          it 'should be able to find the unit by name' do
+            subject.find!(name).should == unit_object
+          end
+
+
+          it "should raise not found if unit is undefined" do
+            lambda { subject.find!(name+"undefined") }.should raise_exception(Lookup::Undefined)
+          end
+
+          context "with non uniq name" do
+            let(:duplicate_name) { name }
+            let(:duplicate_unit_object) { unit_stub(:name => duplicate_name) }
+
+            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)) }
+
+            before do
+              subject.add(compatible_unit_object)
+              subject.add(incompatible_unit_object)
+            end
+
+            describe "by integer" do
+              it "should find compatible units" do
+                subject.compatible_units(unit_object.dimension_int).should =~ [compatible_unit_object, unit_object]
+              end
+            end
+
+            describe "by property" do
+              let(:property_object) { property_stub(:dimension_int => unit_object.dimension_int) }
+              before do
+                subject.add_property(property_object)
+              end
+
+              it "should find compatible units" do
+                subject.compatible_units(property_object.name).should =~ [compatible_unit_object, unit_object]
+              end
+            end
+
+          end
+
+
+        end
+
+        describe "property" do
+          let(:propert_object) { property_stub(:name => :quasar, :expression => 'qu', :valid? => valid)}
+
+          context 'with invalid object' do
+            let(:valid) { false } 
+            it "should raise an error" do
+              lambda { subject.add_property(propert_object) }.should raise_exception(Lookup::Invalid)
+            end
+          end
+
+          context 'with valid object' do
+            let(:valid) { true }
+            before do
+              subject.add_property(propert_object)
+            end
+
+            it "should give a list of properties" do 
+              subject.property_names.should include(propert_object.name)
+            end
+
+            it "should return nil if not found" do
+              subject.find_property("undefined#{propert_object.name}").should == nil
+            end
+
+            it "should raise exception if already defined" do
+              lambda {subject.add_property(propert_object)}.should raise_exception Lookup::Duplicate
+            end
+
+            it 'should be able to find by dimension id' do
+              subject.find_property(propert_object.dimension_int).should == propert_object
+            end
+
+            it 'should be able to find by name' do
+              subject.find_property(propert_object.name).should == propert_object
+            end
+
+
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/quantity_spec.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+module Unity
+  describe Quantity do
+
+    subject { Quantity.new :expression => expression } 
+
+    include_examples "unit arithmetic"
+    include_examples "comparable unit"
+    include_examples "dimension integer"
+    include_examples "convertable value"
+    include_examples "dimension vectors"
+    include_examples "unit fractions"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'shoulda/matchers/active_model'
+require 'mocha'
+require 'unity'
+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}
+
+RSpec.configure do |config|
+
+  config.mock_with :mocha
+
+  config.before(:each) do
+  end
+
+  config.include(Shoulda::Matchers::ActiveModel)
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/load_debugger.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+begin
+  require 'ruby-debug'
+  puts "** USING THE RUBY DEBUGGER **"
+rescue LoadError
+  puts "!!! RUBY DEBUGGER NOT INSTALLED !!!"
+end

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

@@ -0,0 +1,127 @@
+# -*- encoding : utf-8 -*-
+shared_examples "unit arithmetic" do
+
+  shared_examples "addition operation" do
+
+    context "addition result" do
+      subject { object1 + object2 } 
+      let(:addition_value) { addition_result.first } 
+      let(:addition_unit) { addition_result.last } 
+
+      its(:value) { should == addition_value }
+      its(:unit) { should == addition_unit }
+    end
+
+  end
+  shared_examples "subtraction operation" do
+
+    context "subtraction result" do
+      subject { object1 - object2 } 
+      let(:subtraction_value) { subtraction_result.first } 
+      let(:subtraction_unit) { subtraction_result.last }
+
+      its(:value) { should == subtraction_value }
+      its(:unit) { should == subtraction_unit }
+    end
+
+  end
+  shared_examples "multiplication operation" do
+
+    context "multiplication result" do
+      subject { object1 * object2 } 
+      let(:multiplication_value) { multiplication_result.first } 
+      let(:multiplication_unit) { multiplication_result.last } 
+
+      its(:value) { should == multiplication_value }
+      its(:unit) { should == multiplication_unit }
+    end
+
+  end
+  shared_examples "division operation" do
+
+    context "division result" do
+      subject { object1 / object2 } 
+      let(:division_value) { division_result.first } 
+      let(:division_unit) { division_result.last } 
+
+      its(:value) { should == division_value }
+      its(:unit) { should == division_unit }
+    end
+
+  end
+
+  describe "arithmetic" do
+    describe 'with no units' do
+      let(:expression1) { 100.0 }
+      let(:expression2) { 10.0 }
+
+      let(:addition_result) { [110.0, ''] }
+      let(:subtraction_result) { [90.0, ''] }
+      let(:division_result) { [10.0, ''] }
+      let(:multiplication_result) { [1000.0, ''] }
+
+      context "with an numeric as the first object" do
+        let(:object1) { expression1.to_f }
+        let(:object2) { described_class.new :expression => expression2.to_s }
+
+        include_examples "addition operation"
+        include_examples "subtraction operation"
+        include_examples "multiplication operation"
+        include_examples "division operation"
+      end
+
+
+      context "with an numeric as the second object" do
+        let(:object1) { described_class.new :expression => expression1.to_s }
+        let(:object2) { expression2.to_f }
+
+        include_examples "addition operation"
+        include_examples "subtraction operation"
+        include_examples "multiplication operation"
+        include_examples "division operation"
+      end
+
+    end
+
+    context "with units" do
+      let(:object1) { described_class.new :expression => expression1 }
+      let(:object2) { described_class.new :expression => expression2 }
+
+      context "that are compatible" do
+        let(:expression1) { "10*km" }
+        let(:expression2) { "1000*m" }
+
+        let(:addition_result) { [11.0, 'km'] }
+        let(:subtraction_result) { [9.0, 'km'] }
+        let(:division_result) { [10.0, ''] }
+        let(:multiplication_result) { [10.0, 'km^2'] }
+
+        include_examples "addition operation"
+        include_examples "subtraction operation"
+        include_examples "multiplication operation"
+        include_examples "division operation"
+      end
+
+      context "that are incompatible " do
+        let(:expression1) { "10*kg" }
+        let(:expression2) { "10*m" }
+
+        let(:division_result) { [1.0, 'kg/m'] }
+        let(:multiplication_result) { [100.0, 'kg*m'] }
+
+        include_examples "multiplication operation"
+        include_examples "division operation"
+
+        it "should raise error for subtraction" do
+          lambda { object1 - object2 }.should raise_exception Unity::IncompatibleError
+        end
+        it "should raise error for addition" do
+          lambda { object1 + object2 }.should raise_exception Unity::IncompatibleError
+        end
+
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+shared_examples_for "comparable unit" do
+  let(:comparible1) { described_class.new :expression => expression1 }
+  let(:comparible2) { described_class.new :expression => expression2 }
+
+  describe "#compatible?" do
+    subject { comparible1.compatible? comparible2 } 
+
+    context "with compatible units" do
+      let(:expression1) { "km" }
+      let(:expression2) { "m" }
+
+      it { should be_true }
+    end
+
+
+    context "with non compatible units" do
+      let(:expression1) { "km" }
+      let(:expression2) { "g" }
+
+      it { should be_false }
+    end
+  end
+
+  describe "#compatible!" do
+    subject { comparible1.compatible! comparible2 } 
+
+    context "with compatible units" do
+      let(:expression1) { "km" }
+      let(:expression2) { "m" }
+
+      it { should be_true }
+    end
+
+
+    context "with non compatible units" do
+      let(:expression1) { "km" }
+      let(:expression2) { "g" }
+
+      it "should raise exception" do
+        lambda { subject }.should raise_exception Unity::IncompatibleError 
+      end
+    end
+  end
+
+  describe "equality  #==" do
+    subject { comparible1 == comparible2 } 
+
+    context "with comparible units" do
+      let(:expression1) { "1*km" }
+
+      context "and same value" do
+        let(:expression2) { "1000*m" }
+        it { should be_true }
+      end
+
+      context "and different value" do
+        let(:expression2) { "1*m" }
+        it { should be_false }
+      end
+    end
+
+    context "with non comparible units" do
+      let(:expression1) { "1*m" }
+      let(:expression2) { "1*g" }
+      it { should be_false } 
+    end
+  end
+end