auom 0.2.0 → 0.3.0

data/lib/auom/unit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AUOM
   # A scalar with units
   class Unit
@@ -102,7 +104,7 @@ module AUOM
     # @api public
     #
     def unitless?
-      numerators.empty? and denominators.empty?
+      numerators.empty? && denominators.empty?
     end
 
     # Test if units are the same
@@ -173,8 +175,7 @@ module AUOM
       scalar, numerators   = resolve([*numerators], scalar, :*)
       scalar, denominators = resolve([*denominators], scalar, :/)
 
-      # sorting on #to_s as Symbol#<=> is not present on 1.8.7
-      super(scalar, *[numerators, denominators].map { |base| base.sort_by(&:to_s) }).freeze
+      super(scalar, *[numerators, denominators].map(&:sort)).freeze
     end
 
     # Assert units are the same
@@ -186,9 +187,7 @@ module AUOM
     # @api private
     #
     def assert_same_unit(other)
-      unless same_unit?(other)
-        fail ArgumentError, 'Incompatible units'
-      end
+      fail ArgumentError, 'Incompatible units' unless same_unit?(other)
 
       self
     end
@@ -209,6 +208,7 @@ module AUOM
       unless converted
         fail ArgumentError, "Cannot convert #{operand.inspect} to #{self}"
       end
+
       converted
     end
 
@@ -254,7 +254,6 @@ module AUOM
       @denominators = denominators.freeze
 
       @unit = [numerators, denominators].freeze
-      scalar.freeze
     end
 
     # Return rational converted from value
@@ -317,6 +316,5 @@ module AUOM
     end
 
     private_class_method :lookup
-
   end # Unit
 end # AUOM

data/spec/shared/incompatible_operation_behavior.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'an incompatible operation' do
   it 'should raise ArgumentError' do
     expect { subject }.to raise_error(ArgumentError, 'Incompatible units')

data/spec/shared/operation_behavior.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'an operation' do
   it 'returns a new object' do
     expect(object).to_not equal(subject)
@@ -6,6 +8,7 @@ shared_examples_for 'an operation' do
   it 'is idempotent on equivalency' do
     first = subject
     fail unless RSpec.configuration.threadsafe?
+
     mutex = __memoized.instance_variable_get(:@mutex)
     memoized = __memoized.instance_variable_get(:@memoized)
     mutex.synchronize { memoized.delete(:subject) }

data/spec/shared/sunits_shared.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'unitless unit' do
   its(:numerators)   { should == [] }
   its(:denominators) { should == [] }

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'auom'
 require 'devtools/spec_helper'

data/spec/unit/auom/algebra_spec.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+describe AUOM::Algebra do
+  describe '#add' do
+    subject { object.add(operand) }
+
+    let(:object) { AUOM::Unit.new(*arguments) }
+
+    context 'when unit is unitless' do
+      let(:arguments) { [1] }
+
+      context 'and operand is an Integer' do
+        let(:operand) { 2 }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(3)) }
+      end
+
+      context 'and operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(2) }
+
+        it { should eql(AUOM::Unit.new(3)) }
+      end
+
+      context 'and operand is a unitful unit' do
+        let(:operand) { AUOM::Unit.new(2, :meter) }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+    end
+
+    context 'when unit is unitful' do
+      let(:arguments) { [1, :meter, :euro] }
+
+      context 'and operand is an Integer' do
+        let(:operand) { 2 }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+
+      context 'and operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(2) }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+
+      context 'and operand is a incompatible unit' do
+        let(:operand) { AUOM::Unit.new(2, :euro) }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+
+      context 'and operand is a compatible unit' do
+        let(:operand) { AUOM::Unit.new(2, :meter, :euro) }
+
+        it { should eql(AUOM::Unit.new(3, :meter, :euro)) }
+      end
+    end
+  end
+
+  describe '#divide' do
+    subject { object.divide(operand) }
+
+    let(:object) { AUOM::Unit.new(*arguments) }
+
+    context 'with unitless unit' do
+      let(:arguments) { [4] }
+
+      context 'when operand is a fixnum' do
+        let(:operand) { 2 }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2)) }
+      end
+
+      context 'when operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(2) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2)) }
+      end
+
+      context 'when operand is a unitful unit' do
+        let(:operand) { AUOM::Unit.new(2, :meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2, [], :meter)) }
+      end
+    end
+
+    context 'with unitful unit' do
+      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)) }
+      end
+
+      context 'when operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(1) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2, :meter)) }
+      end
+
+      context 'when operand is a unitful unit' do
+        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, %i[euro meter])) }
+        end
+
+        context 'and units cancel 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
+
+  describe '#multiply' do
+    subject { object.multiply(operand) }
+
+    let(:object) { AUOM::Unit.new(*arguments) }
+
+    context 'with unitless unit' do
+      let(:arguments) { [2] }
+
+      context 'when operand is a fixnum' do
+        let(:operand) { 3 }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(6)) }
+      end
+
+      context 'when operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(3) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(6)) }
+      end
+
+      context 'when operand is a unitful unit' do
+        let(:operand) { AUOM::Unit.new(3, :meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(6, :meter)) }
+      end
+    end
+
+    context 'with unitful unit' do
+      let(:arguments) { [2, :meter, :kilogramm] }
+
+      context 'when operand is a fixnum' do
+        let(:operand) { 3 }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(6, :meter, :kilogramm)) }
+      end
+
+      context 'when operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(3) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(6, :meter, :kilogramm)) }
+      end
+
+      context 'when operand is a unitful unit' do
+        context 'and units get added to numerator' do
+          let(:operand) { AUOM::Unit.new(3, :meter) }
+
+          it_should_behave_like 'an operation'
+
+          it { should eql(AUOM::Unit.new(6, %i[meter meter], :kilogramm)) }
+        end
+
+        context 'and units get added to denominator' do
+          let(:operand) { AUOM::Unit.new(3, [], :euro) }
+
+          it_should_behave_like 'an operation'
+
+          it { should eql(AUOM::Unit.new(6, :meter, %i[euro kilogramm])) }
+        end
+
+        context 'and units cancel each other' do
+          let(:operand) { AUOM::Unit.new(3, [], :meter) }
+
+          it_should_behave_like 'an operation'
+
+          it { should eql(AUOM::Unit.new(6, [], :kilogramm)) }
+        end
+      end
+    end
+  end
+
+  describe '#subtract' do
+    subject { object.subtract(operand) }
+
+    let(:object) { AUOM::Unit.new(*arguments) }
+
+    context 'when unit is unitless' do
+      let(:arguments) { [1] }
+
+      context 'and operand is an Integer' do
+        let(:operand) { 1 }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(0)) }
+      end
+
+      context 'and operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(1) }
+
+        it { should eql(AUOM::Unit.new(0)) }
+      end
+
+      context 'and operand is a unitful unit' do
+        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] }
+
+      context 'and operand is an Integer' do
+        let(:operand) { 1 }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+
+      context 'and operand is a unitless unit' do
+        let(:operand) { AUOM::Unit.new(1) }
+
+        it_should_behave_like 'an incompatible operation'
+      end
+
+      context 'and operand is a incompatible unit' do
+        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) }
+
+        it { should eql(AUOM::Unit.new(0, :meter)) }
+      end
+    end
+  end
+end

data/spec/unit/auom/{equalization/equality_operator_spec.rb → equalization_spec.rb}

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 describe AUOM::Equalization, '#==' do
   subject { object == other }
 
   let(:object) { AUOM::Unit.new(1, :meter) }
 
   context 'when is other kind of object' do
-
     context 'that cannot be converted' do
       let(:other) { Object.new }
 

data/spec/unit/auom/inspection_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+describe AUOM::Inspection do
+  describe '#inspect' do
+    subject { object.inspect }
+
+    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>') }
+    end
+
+    context 'when scalar is NOT exact in decimal' do
+      let(:scalar) { Rational(1, 2) }
+
+      it { should eql('<AUOM::Unit @scalar=~0.5000>') }
+    end
+
+    context 'when has only numerator' do
+      let(:scalar) { Rational(1, 3) }
+      let(:unit) { [: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] }
+
+      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)   { %i[euro meter] }
+
+      it { should eql('<AUOM::Unit @scalar=~0.3333 euro/meter>') }
+    end
+  end
+
+  describe '.prettify_unit_part' do
+    subject { object.prettify_unit_part(part) }
+
+    let(:object) { AUOM::Inspection }
+
+    context 'with simple part' do
+      let(:part) { [:meter] }
+
+      it { should eql('meter') }
+    end
+
+    context 'with mixed part' do
+      let(:part) { %i[meter euro] }
+
+      it { should eql('euro*meter') }
+    end
+
+    context 'with complex part' do
+      let(:part) { %i[meter meter euro] }
+
+      it { should eql('meter^2*euro') }
+    end
+
+    context 'with very complex part' do
+      let(:part) { %i[meter meter euro euro kilogramm] }
+
+      it { should eql('euro^2*meter^2*kilogramm') }
+    end
+  end
+end