auom 0.0.6 → 0.1.0

data/spec/shared/incompatible_operation_behavior.rb

@@ -1,5 +1,7 @@
+# encoding: UTF-8
+
 shared_examples_for 'an incompatible operation' do
   it 'should raise ArgumentError' do
-    expect { subject }.to raise_error(ArgumentError,'Incompatible units')
+    expect { subject }.to raise_error(ArgumentError, 'Incompatible units')
   end
 end

data/spec/shared/operation_behavior.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 shared_examples_for 'an operation' do
   it 'returns a new object' do
     object.should_not equal(subject)
@@ -8,7 +10,6 @@ shared_examples_for 'an operation' do
     __memoized.delete(:subject)
     should eql(first)
   end
- 
+
   its(:scalar) { should be_kind_of(::Rational) }
 end
-

data/spec/shared/sunits_shared.rb

@@ -1,6 +1,8 @@
+# encoding: UTF-8
+
 shared_examples_for 'unitless unit' do
   its(:numerators)   { should == [] }
   its(:denominators) { should == [] }
-  its(:unit) { should == [[],[]] }
+  its(:unit) { should == [[], []] }
   it { should be_unitless }
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'auom'
 require 'devtools'
 Devtools.init_spec_helper

data/spec/unit/auom/algebra/add_spec.rb

@@ -1,6 +1,8 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Algebra,'#add' do
+describe AUOM::Algebra, '#add' do
   subject { object.add(operand) }
 
   let(:object) { AUOM::Unit.new(*arguments) }
@@ -23,14 +25,14 @@ describe AUOM::Algebra,'#add' do
     end
 
     context 'and operand is a unitful unit' do
-      let(:operand) { AUOM::Unit.new(1,:meter) }
+      let(:operand) { AUOM::Unit.new(1, :meter) }
 
       it_should_behave_like 'an incompatible operation'
     end
   end
 
   context 'when unit is unitful' do
-    let(:arguments) { [1,:meter, :euro] }
+    let(:arguments) { [1, :meter, :euro] }
 
     context 'and operand is a Fixnum' do
       let(:operand) { 1 }
@@ -45,15 +47,15 @@ describe AUOM::Algebra,'#add' do
     end
 
     context 'and operand is a incompatible unit' do
-      let(:operand) { AUOM::Unit.new(1,:euro) }
+      let(:operand) { AUOM::Unit.new(1, :euro) }
 
       it_should_behave_like 'an incompatible operation'
     end
 
     context 'and operand is a compatible unit' do
-      let(:operand) { AUOM::Unit.new(1,:meter, :euro) }
+      let(:operand) { AUOM::Unit.new(1, :meter, :euro) }
 
-      it { should eql(AUOM::Unit.new(2,:meter, :euro)) }
+      it { should eql(AUOM::Unit.new(2, :meter, :euro)) }
     end
   end
 end

data/spec/unit/auom/algebra/divide_spec.rb

@@ -1,15 +1,17 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Algebra,'#divide' do
+describe AUOM::Algebra, '#divide' do
   subject { object.divide(operand) }
 
   let(:object) { AUOM::Unit.new(*arguments) }
 
   context 'with unitless unit' do
-    let(:arguments) { [2] }
+    let(:arguments) { [4] }
 
     context 'when operand is a fixnum' do
-      let(:operand) { 1 }
+      let(:operand) { 2 }
 
       it_should_behave_like 'an operation'
 
@@ -17,7 +19,7 @@ describe AUOM::Algebra,'#divide' do
     end
 
     context 'when operand is a unitless unit' do
-      let(:operand) { AUOM::Unit.new(1) }
+      let(:operand) { AUOM::Unit.new(2) }
 
       it_should_behave_like 'an operation'
 
@@ -25,23 +27,23 @@ describe AUOM::Algebra,'#divide' do
     end
 
     context 'when operand is a unitful unit' do
-      let(:operand) { AUOM::Unit.new(1,:meter) }
+      let(:operand) { AUOM::Unit.new(2, :meter) }
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,[],:meter)) }
+      it { should eql(AUOM::Unit.new(2, [], :meter)) }
     end
   end
-  
+
   context 'with unitful unit' do
-    let(:arguments) { [2,:meter] }
+    let(:arguments) { [2, :meter] }
 
     context 'when operand is a fixnum' do
       let(:operand) { 1 }
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,:meter)) }
+      it { should eql(AUOM::Unit.new(2, :meter)) }
     end
 
     context 'when operand is a unitless unit' do
@@ -49,26 +51,35 @@ describe AUOM::Algebra,'#divide' do
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,:meter)) }
+      it { should eql(AUOM::Unit.new(2, :meter)) }
     end
 
     context 'when operand is a unitful unit' do
 
-      context 'and units NOT cancle each other' do
-        let(:operand) { AUOM::Unit.new(1,:euro) }
+      context 'and units get added to denominator' do
+        let(:operand) { AUOM::Unit.new(1, :euro) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2, :meter, :euro)) }
+      end
+
+      context 'and units get added to numerator' do
+        let(:operand) { AUOM::Unit.new(1, nil, :euro) }
 
         it_should_behave_like 'an operation'
 
-        it { should eql(AUOM::Unit.new(2,:meter,:euro)) }
+        it { should eql(AUOM::Unit.new(2, [:euro, :meter])) }
       end
 
-      context 'and untis cancle each other' do
-        let(:operand) { AUOM::Unit.new(1,:meter) }
+      context 'and units cancle each other' do
+        let(:operand) { AUOM::Unit.new(1, :meter) }
 
         it_should_behave_like 'an operation'
 
         it { should eql(AUOM::Unit.new(2)) }
       end
+
     end
   end
 end

data/spec/unit/auom/algebra/multiply_spec.rb

@@ -1,19 +1,21 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Algebra,'#multiply' do
+describe AUOM::Algebra, '#multiply' do
   subject { object.multiply(operand) }
 
   let(:object) { AUOM::Unit.new(*arguments) }
 
   context 'with unitless unit' do
-    let(:arguments) { [1] }
+    let(:arguments) { [2] }
 
     context 'when operand is a fixnum' do
       let(:operand) { 2 }
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2)) }
+      it { should eql(AUOM::Unit.new(4)) }
     end
 
     context 'when operand is a unitless unit' do
@@ -21,27 +23,27 @@ describe AUOM::Algebra,'#multiply' do
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2)) }
+      it { should eql(AUOM::Unit.new(4)) }
     end
 
     context 'when operand is a unitful unit' do
-      let(:operand) { AUOM::Unit.new(2,:meter) }
+      let(:operand) { AUOM::Unit.new(2, :meter) }
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,:meter)) }
+      it { should eql(AUOM::Unit.new(4, :meter)) }
     end
   end
-  
+
   context 'with unitful unit' do
-    let(:arguments) { [1,:meter] }
+    let(:arguments) { [2, :meter, :kilogramm] }
 
     context 'when operand is a fixnum' do
       let(:operand) { 2 }
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,:meter)) }
+      it { should eql(AUOM::Unit.new(4, :meter, :kilogramm)) }
     end
 
     context 'when operand is a unitless unit' do
@@ -49,25 +51,33 @@ describe AUOM::Algebra,'#multiply' do
 
       it_should_behave_like 'an operation'
 
-      it { should eql(AUOM::Unit.new(2,:meter)) }
+      it { should eql(AUOM::Unit.new(4, :meter, :kilogramm)) }
     end
 
     context 'when operand is a unitful unit' do
 
-      context 'and units NOT cancle each other' do
-        let(:operand) { AUOM::Unit.new(2,:meter) }
+      context 'and units get added to numerator' do
+        let(:operand) { AUOM::Unit.new(2, :meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(4, [:meter, :meter], :kilogramm)) }
+      end
+
+      context 'and units get added to denominator' do
+        let(:operand) { AUOM::Unit.new(2, [], :euro) }
 
         it_should_behave_like 'an operation'
 
-        it { should eql(AUOM::Unit.new(2,[:meter,:meter])) }
+        it { should eql(AUOM::Unit.new(4, :meter, [:euro, :kilogramm])) }
       end
 
       context 'and units cancle each other' do
-        let(:operand) { AUOM::Unit.new(2,[],:meter) }
+        let(:operand) { AUOM::Unit.new(2, [], :meter) }
 
         it_should_behave_like 'an operation'
 
-        it { should eql(AUOM::Unit.new(2)) }
+        it { should eql(AUOM::Unit.new(4, [], :kilogramm)) }
       end
     end
   end

data/spec/unit/auom/algebra/substract_spec.rb

@@ -1,6 +1,8 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Algebra,'#substract' do
+describe AUOM::Algebra, '#substract' do
   subject { object.substract(operand) }
 
   let(:object) { AUOM::Unit.new(*arguments) }
@@ -23,14 +25,14 @@ describe AUOM::Algebra,'#substract' do
     end
 
     context 'and operand is a unitful unit' do
-      let(:operand) { AUOM::Unit.new(1,:meter) }
+      let(:operand) { AUOM::Unit.new(1, :meter) }
 
       it_should_behave_like 'an incompatible operation'
     end
   end
 
   context 'when unit is unitful' do
-    let(:arguments) { [1,:meter] }
+    let(:arguments) { [1, :meter] }
 
     context 'and operand is a Fixnum' do
       let(:operand) { 1 }
@@ -45,15 +47,15 @@ describe AUOM::Algebra,'#substract' do
     end
 
     context 'and operand is a incompatible unit' do
-      let(:operand) { AUOM::Unit.new(1,:euro) }
+      let(:operand) { AUOM::Unit.new(1, :euro) }
 
       it_should_behave_like 'an incompatible operation'
     end
 
     context 'and operand is a compatible unit' do
-      let(:operand) { AUOM::Unit.new(1,:meter) }
+      let(:operand) { AUOM::Unit.new(1, :meter) }
 
-      it { should eql(AUOM::Unit.new(0,:meter)) }
+      it { should eql(AUOM::Unit.new(0, :meter)) }
     end
   end
 end

data/spec/unit/auom/equalization/equality_operator_spec.rb

@@ -1,9 +1,11 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Equalization,'#==' do
+describe AUOM::Equalization, '#==' do
   subject { object == other }
 
-  let(:object) { AUOM::Unit.new(1,:meter) }
+  let(:object) { AUOM::Unit.new(1, :meter) }
 
   context 'when is other kind of object' do
 
@@ -29,7 +31,7 @@ describe AUOM::Equalization,'#==' do
   end
 
   context 'when is same kind of object' do
-    let(:other) { AUOM::Unit.new(scalar,*unit) }
+    let(:other) { AUOM::Unit.new(scalar, *unit) }
 
     let(:scalar) { 1 }
     let(:unit) { [:meter] }

data/spec/unit/auom/inspection/class_methods/prettify_unit_part_spec.rb

@@ -1,6 +1,8 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Inspection,'.prettify_unit_part' do
+describe AUOM::Inspection, '.prettify_unit_part' do
   subject { object.prettify_unit_part(part) }
 
   let(:object) { AUOM::Inspection }
@@ -11,17 +13,17 @@ describe AUOM::Inspection,'.prettify_unit_part' do
   end
 
   context 'with mixed part' do
-    let(:part) { [:meter,:euro] }
+    let(:part) { [:meter, :euro] }
     it { should eql('euro*meter') }
   end
 
   context 'with complex part' do
-    let(:part) { [:meter,:meter,:euro] }
+    let(:part) { [:meter, :meter, :euro] }
     it { should eql('meter^2*euro') }
   end
 
   context 'with very complex part' do
-    let(:part) { [:meter,:meter,:euro,:euro,:kilogramm] }
+    let(:part) { [:meter, :meter, :euro, :euro, :kilogramm] }
     it { should eql('euro^2*meter^2*kilogramm') }
   end
 end

data/spec/unit/auom/inspection/inspect_spec.rb

@@ -1,41 +1,43 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Inspection,'#inspect' do
+describe AUOM::Inspection, '#inspect' do
   subject { object.inspect }
 
-  let(:object) { AUOM::Unit.new(scalar,*unit) }
+  let(:object) { AUOM::Unit.new(scalar, *unit) }
   let(:unit) { [] }
 
   context 'when scalar is exact in decimal' do
     let(:scalar) { 1 }
 
-    it { should eql("<AUOM::Unit @scalar=1>") }
+    it { should eql('<AUOM::Unit @scalar=1>') }
   end
 
   context 'when scalar is NOT exact in decimal' do
-    let(:scalar) { Rational(1,3) }
+    let(:scalar) { Rational(1, 2) }
 
-    it { should eql("<AUOM::Unit @scalar=~0.3333>") }
+    it { should eql('<AUOM::Unit @scalar=~0.5000>') }
   end
 
   context 'when has only numerator' do
-    let(:scalar) { Rational(1,3) }
+    let(:scalar) { Rational(1, 3) }
     let(:unit) { [:meter] }
 
-    it { should eql("<AUOM::Unit @scalar=~0.3333 meter>") }
+    it { should eql('<AUOM::Unit @scalar=~0.3333 meter>') }
   end
 
   context 'when has only denominator' do
-    let(:scalar) { Rational(1,3) }
-    let(:unit) { [[],:meter] }
+    let(:scalar) { Rational(1, 3) }
+    let(:unit) { [[], :meter] }
 
-    it { should eql("<AUOM::Unit @scalar=~0.3333 1/meter>") }
+    it { should eql('<AUOM::Unit @scalar=~0.3333 1/meter>') }
   end
 
   context 'when has numerator and denominator' do
-    let(:scalar) { Rational(1,3) }
-    let(:unit) { [:euro,:meter] }
+    let(:scalar) { Rational(1, 3) }
+    let(:unit) { [:euro, :meter] }
 
-    it { should eql("<AUOM::Unit @scalar=~0.3333 euro/meter>") }
+    it { should eql('<AUOM::Unit @scalar=~0.3333 euro/meter>') }
   end
 end

data/spec/unit/auom/relational/greater_than_or_equal_to_predicate_spec.rb

@@ -1,6 +1,8 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe AUOM::Relational,'#greater_than_or_equal_to?' do
+describe AUOM::Relational, '#greater_than_or_equal_to?' do
 
   subject { object.greater_than_or_equal_to?(operand) }