auom 0.2.0 → 0.3.0

data/.circle.yml

@@ -1,4 +0,0 @@
----
-test:
-  override: 
-    - bundle exec rake ci

data/TODO

@@ -1 +0,0 @@
-* Make built-in units configurable

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

@@ -1,57 +0,0 @@
-describe AUOM::Algebra, '#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

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

@@ -1,83 +0,0 @@
-describe AUOM::Algebra do
-  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
-end

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

@@ -1,80 +0,0 @@
-describe AUOM::Algebra, '#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

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

@@ -1,57 +0,0 @@
-describe AUOM::Algebra, '#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

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

@@ -1,29 +0,0 @@
-describe AUOM::Inspection, '.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

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

@@ -1,39 +0,0 @@
-describe AUOM::Inspection, '#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

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

@@ -1,38 +0,0 @@
-describe AUOM::Relational, '#greater_than_or_equal_to?' do
-
-  subject { object.greater_than_or_equal_to?(operand) }
-
-  let(:object) { AUOM::Unit.new(1, :meter) }
-
-  let(:operand) { AUOM::Unit.new(scalar, unit) }
-
-  context 'when operand unit is the same' do
-
-    let(:unit) { :meter }
-
-    context 'and operand scalar is less than receiver scalar' do
-      let(:scalar) { 0 }
-
-      it { should be(true) }
-    end
-
-    context 'and operand scalar is equal to receiver scalar' do
-      let(:scalar) { 1 }
-
-      it { should be(true) }
-    end
-
-    context 'and operand scalar is greater than receiver scalar' do
-      let(:scalar) { 2 }
-
-      it { should be(false) }
-    end
-  end
-
-  context 'when operand unit is not the same' do
-    let(:scalar) { 1     }
-    let(:unit)   { :euro }
-
-    it_should_behave_like 'an incompatible operation'
-  end
-end

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

@@ -1,38 +0,0 @@
-describe AUOM::Relational, '#greater_than?' do
-
-  subject { object.greater_than?(operand) }
-
-  let(:object) { AUOM::Unit.new(1, :meter) }
-
-  let(:operand) { AUOM::Unit.new(scalar, unit) }
-
-  context 'when operand unit is the same' do
-
-    let(:unit) { :meter }
-
-    context 'and operand scalar is less than receiver scalar' do
-      let(:scalar) { 0 }
-
-      it { should be(true) }
-    end
-
-    context 'and operand scalar is equal to receiver scalar' do
-      let(:scalar) { 1 }
-
-      it { should be(false) }
-    end
-
-    context 'and operand scalar is greater than receiver scalar' do
-      let(:scalar) { 2 }
-
-      it { should be(false) }
-    end
-  end
-
-  context 'when operand unit is not the same' do
-    let(:scalar) { 1     }
-    let(:unit)   { :euro }
-
-    it_should_behave_like 'an incompatible operation'
-  end
-end

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

@@ -1,38 +0,0 @@
-describe AUOM::Relational, '#less_than_or_equal_to?' do
-
-  subject { object.less_than_or_equal_to?(operand) }
-
-  let(:object) { AUOM::Unit.new(1, :meter) }
-
-  let(:operand) { AUOM::Unit.new(scalar, unit) }
-
-  context 'when operand unit is the same' do
-
-    let(:unit) { :meter }
-
-    context 'and operand scalar is less than receiver scalar' do
-      let(:scalar) { 0 }
-
-      it { should be(false) }
-    end
-
-    context 'and operand scalar is equal to receiver scalar' do
-      let(:scalar) { 1 }
-
-      it { should be(true) }
-    end
-
-    context 'and operand scalar is greater than receiver scalar' do
-      let(:scalar) { 2 }
-
-      it { should be(true) }
-    end
-  end
-
-  context 'when operand unit is not the same' do
-    let(:scalar) { 1     }
-    let(:unit)   { :euro }
-
-    it_should_behave_like 'an incompatible operation'
-  end
-end