unite 1.0.1

data/lib/unity/lookup.rb

@@ -0,0 +1,102 @@
+# -*- encoding : utf-8 -*-
+require 'active_model'
+require 'unity/lookup/simple_unit'
+require 'unity/lookup/derived_unit'
+require 'unity/lookup/property'
+require 'securerandom'
+
+module Unity
+  class Lookup
+
+    class Invalid < RuntimeError
+    end
+
+    class Duplicate < RuntimeError
+    end
+
+    class Undefined < RuntimeError
+    end
+
+
+    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?
+        key = store_object object
+        @@unit_names[object.name.to_sym] = key
+        @@unit_ints[object.dimension_int] ||= []
+        @@unit_ints[object.dimension_int] << key
+      end
+
+      def find! name
+        key = @@unit_names[name.to_sym].tap {|k| raise Undefined, "Unit #{name} is undefined" unless k }
+        get_object key
+      end
+
+      def compatible_units int_or_sym_or_string
+        int =
+          if int_or_sym_or_string.is_a? Integer
+            int_or_sym_or_string
+          else
+            tmp = find_property(int_or_sym_or_string)
+            tmp.nil? ? nil : tmp.dimension_int
+          end
+        (@@unit_ints[int] || []).map do |key|
+          get_object key
+        end
+      end
+
+      def find_property int_or_sym_or_string
+        key =
+          if int_or_sym_or_string.is_a? Integer
+            @@property_ints[int_or_sym_or_string]
+          else
+            @@property_names[int_or_sym_or_string.to_sym]
+          end.tap {|k| return nil unless k }
+          get_object key
+      end
+
+      def add_property object
+        raise Invalid, object.errors.inspect unless object.valid?
+        existing = @@property_ints[object.dimension_int]
+        raise Duplicate, "The property for dimension int #{object.dimension_int} is already defined as #{get_object(existing).name}" unless existing.nil?
+        key = store_object object
+        @@property_names[object.name.to_sym] = key 
+        @@property_ints[object.dimension_int]= key
+      end
+
+      def property_names
+        @@property_names.keys.map(&:to_sym)
+      end
+
+      def clear!
+        @@object_cache = {}
+        @@unit_names = Hash.new
+        @@unit_ints = Hash.new
+        @@property_ints = Hash.new
+        @@property_names= Hash.new
+      end
+
+      def reload!
+        load "#{File.dirname(__FILE__)}/lookup/definitions.rb"
+      end
+
+      private
+
+      def store_object object
+        SecureRandom.uuid.tap do |key|
+          @@object_cache[key] = object
+        end
+      end
+
+      def get_object key
+        @@object_cache[key]
+      end
+
+    end
+
+    clear!
+    reload!
+
+  end
+end

data/lib/unity/quantity.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+module Unity
+  class Quantity
+
+    include Dimension::Vector
+    include Conversion
+    include Arithmetic
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+      super
+    end
+
+    attr_accessor :name, :numerator, :denominator, :cached_expression, :value
+    alias :to_s :expression
+
+  end
+end

data/lib/unity/version.rb

@@ -0,0 +1,3 @@
+module Unity
+  VERSION = "1.0.1"
+end

data/lib/unity.rb

@@ -0,0 +1,20 @@
+require "unity/version"
+
+module Unity
+
+end
+
+
+require 'active_support'
+
+# Dir["#{Rails.root.to_s}/lib/units/**/*.rb"].each {|file| require file }
+require 'unity/fraction'
+require 'unity/dimension'
+require 'unity/comparison'
+require 'unity/conversion'
+require 'unity/arithmetic'
+
+
+require 'unity/lookup'
+
+require "unity/quantity"

data/spec/arithmetic_spec.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Arithmetic do
+
+end

data/spec/comparison_spec.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Comparison do
+
+end

data/spec/conversion_spec.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Conversion do
+
+end
+
+

data/spec/dimension/integer_spec.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Dimension::Integer do
+
+end
+

data/spec/dimension/vector_spec.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Dimension::Vector do
+
+end
+

data/spec/dimension_spec.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Dimension do
+
+  
+end

data/spec/fabricators/unit_fabricator.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+require 'unity/lookup/simple_unit'
+require 'unity/lookup/derived_unit'
+
+Fabricator(:simple_unit, :class_name => "Unity::SimpleUnit") do
+  si_factor 1000.0
+  name 'km'
+  dimension :length
+end
+
+Fabricator(:derived_unit, :class_name => "Unity::DerivedUnit") do
+  name 'kWh'
+end
+

data/spec/fraction_spec.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe Unity::Fraction do
+
+
+end

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
+