axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/aggregate/maximum/class_methods/call_spec.rb

@@ -28,9 +28,9 @@ describe Aggregate::Maximum, '.call' do
   end
 
   context 'when the value is nil' do
-    let(:value)   { nil             }
-    let(:maximum) { mock('Maximum') }
+    let(:value)   { nil               }
+    let(:maximum) { double('Maximum') }
 
-    it { should equal(maximum) }
+    it { should be(maximum) }
   end
 end

data/spec/unit/axiom/aggregate/maximum/methods/maximum_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :maximum, :max ].each do |method|
+[:maximum, :max].each do |method|
   describe Aggregate::Maximum::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Aggregate::Maximum) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/aggregate/maximum/type_spec.rb

@@ -6,15 +6,15 @@ describe Aggregate::Maximum, '#type' do
   subject { object.type }
 
   let(:object)  { described_class.new(operand) }
-  let(:operand) { mock('Unhandled')            }
+  let(:operand) { double('Unhandled')          }
 
   before do
-    operand.stub(:freeze => operand, :frozen? => true)
+    operand.stub(freeze: operand, :frozen? => true)
   end
 
   it 'delegates to Attribute.infer_type' do
-    return_value = mock('Return Value')
+    return_value = double('Return Value')
     Attribute.should_receive(:infer_type).with(operand).and_return(return_value)
-    should equal(return_value)
+    should be(return_value)
   end
 end

data/spec/unit/axiom/aggregate/mean/class_methods/call_spec.rb

@@ -13,26 +13,26 @@ describe Aggregate::Mean, '.call' do
   let(:object)  { described_class }
 
   context 'when the value is 0' do
-    let(:values) { [ 0 ] }
+    let(:values) { [0] }
 
     it 'returns the expected count and mean of the values' do
-      should eql([ 1, 0.0 ])
+      should == [1, 0.0]
     end
   end
 
   context 'when the values are not nil' do
-    let(:values) { [ -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 ] }
+    let(:values) { [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6] }
 
     it 'returns the expected count and mean of the values' do
-      should eql([ 13, 0.0 ])
+      should == [13, 0.0]
     end
   end
 
   context 'when the values are nil' do
-    let(:values) { [ nil ] }
+    let(:values) { [nil] }
 
     it 'returns the default' do
-      should equal(default)
+      should be(default)
     end
   end
 end

data/spec/unit/axiom/aggregate/mean/class_methods/default_spec.rb

@@ -11,5 +11,5 @@ describe Aggregate::Mean, '.default' do
 
   it { should be_frozen }
 
-  it { should eql([ 0, nil ]) }
+  it { should eql([0, nil]) }
 end

data/spec/unit/axiom/aggregate/mean/class_methods/finalize_spec.rb

@@ -6,11 +6,11 @@ describe Aggregate::Mean, '.finalize' do
   subject { object.finalize(accumulator) }
 
   let(:object)      { described_class }
-  let(:accumulator) { [ count, mean ] }
-  let(:count)       { mock('Count')   }
-  let(:mean)        { mock('Mean')    }
+  let(:accumulator) { [count, mean]   }
+  let(:count)       { double('Count') }
+  let(:mean)        { double('Mean')  }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(mean) }
+  it { should be(mean) }
 end

data/spec/unit/axiom/aggregate/mean/class_methods/type_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Mean, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it { should be(Types::Float) }
+end

data/spec/unit/axiom/aggregate/mean/methods/mean_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :mean, :average, :avg ].each do |method|
+[:mean, :average, :avg].each do |method|
   describe Aggregate::Mean::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Aggregate::Mean) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/aggregate/minimum/class_methods/call_spec.rb

@@ -28,9 +28,9 @@ describe Aggregate::Minimum, '.call' do
   end
 
   context 'when the value is nil' do
-    let(:value)   { nil             }
-    let(:minimum) { mock('Minimum') }
+    let(:value)   { nil               }
+    let(:minimum) { double('Minimum') }
 
-    it { should equal(minimum) }
+    it { should be(minimum) }
   end
 end

data/spec/unit/axiom/aggregate/minimum/methods/minimum_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :minimum, :min ].each do |method|
+[:minimum, :min].each do |method|
   describe Aggregate::Minimum::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Aggregate::Minimum) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/aggregate/minimum/type_spec.rb

@@ -6,15 +6,15 @@ describe Aggregate::Minimum, '#type' do
   subject { object.type }
 
   let(:object)  { described_class.new(operand) }
-  let(:operand) { mock('Unhandled')            }
+  let(:operand) { double('Unhandled')          }
 
   before do
-    operand.stub(:freeze => operand, :frozen? => true)
+    operand.stub(freeze: operand, :frozen? => true)
   end
 
   it 'delegates to Attribute.infer_type' do
-    return_value = mock('Return Value')
+    return_value = double('Return Value')
     Attribute.should_receive(:infer_type).with(operand).and_return(return_value)
-    should equal(return_value)
+    should be(return_value)
   end
 end

data/spec/unit/axiom/aggregate/standard_deviation/class_methods/finalize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Aggregate::StandardDeviation, '.finalize' do
   subject { object.finalize(accumulator) }
 
-  let(:object)      { described_class                 }
-  let(:accumulator) { [ count, mean, sum_of_squares ] }
+  let(:object)      { described_class               }
+  let(:accumulator) { [count, mean, sum_of_squares] }
 
   context 'when the variance is 0.0' do
     let(:count)          { 0   }
@@ -21,10 +21,10 @@ describe Aggregate::StandardDeviation, '.finalize' do
     let(:mean)           { 3.5  }
     let(:sum_of_squares) { 17.5 }
 
-    it { should be_within(1.70).of(0.01) }
+    it { should be_within(0.01).of(1.70) }
   end
 
-  context 'when the variance is 0.0' do
+  context 'when the variance is infinite' do
     let(:count)          { 1               }
     let(:mean)           { nil             }
     let(:sum_of_squares) { Float::INFINITY }

data/spec/unit/axiom/aggregate/standard_deviation/class_methods/type_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::StandardDeviation, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it { should be(Types::Float) }
+end

data/spec/unit/axiom/aggregate/standard_deviation/methods/standard_deviation_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :standard_deviation, :stddev ].each do |method|
+[:standard_deviation, :stddev].each do |method|
   describe Aggregate::StandardDeviation::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Aggregate::StandardDeviation) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/aggregate/sum/class_methods/call_spec.rb

@@ -13,7 +13,7 @@ describe Aggregate::Sum, '.call' do
   let(:object)  { described_class }
 
   context 'when the values are not nil' do
-    let(:values) { [ 1, 2, 3, 4, 5, 6 ] }
+    let(:values) { [1, 2, 3, 4, 5, 6] }
 
     it 'returns the expected sum of the values' do
       should eql(21)
@@ -21,10 +21,10 @@ describe Aggregate::Sum, '.call' do
   end
 
   context 'when the values are nil' do
-    let(:values) { [ nil ] }
+    let(:values) { [nil] }
 
     it 'returns the default' do
-      should equal(default)
+      should be(default)
     end
   end
 end

data/spec/unit/axiom/aggregate/sum/default_spec.rb

@@ -10,7 +10,7 @@ describe Aggregate::Sum, '#default' do
   context 'when the attribute is an Integer' do
     let(:attribute) { Attribute::Integer.new(:integer) }
 
-    it { should be_kind_of(attribute.class.primitive) }
+    it { should be_kind_of(attribute.type.primitive) }
 
     it { should be_zero }
   end
@@ -18,7 +18,7 @@ describe Aggregate::Sum, '#default' do
   context 'when the attribute is a Float' do
     let(:attribute) { Attribute::Float.new(:float) }
 
-    it { should be_instance_of(attribute.class.primitive) }
+    it { should be_instance_of(attribute.type.primitive) }
 
     it { should be_zero }
   end
@@ -26,7 +26,7 @@ describe Aggregate::Sum, '#default' do
   context 'when the attribute is a Decimal' do
     let(:attribute) { Attribute::Decimal.new(:decimal) }
 
-    it { should be_instance_of(attribute.class.primitive) }
+    it { should be_instance_of(attribute.type.primitive) }
 
     it { should be_zero }
   end

data/spec/unit/axiom/aggregate/sum/methods/sum_spec.rb

@@ -10,5 +10,5 @@ describe Aggregate::Sum::Methods, '#sum' do
 
   it { should be_instance_of(Aggregate::Sum) }
 
-  its(:operand) { should equal(object) }
+  its(:operand) { should be(object) }
 end

data/spec/unit/axiom/aggregate/sum/type_spec.rb

@@ -6,15 +6,15 @@ describe Aggregate::Sum, '#type' do
   subject { object.type }
 
   let(:object)  { described_class.new(operand) }
-  let(:operand) { mock('Unhandled')            }
+  let(:operand) { double('Unhandled')          }
 
   before do
-    operand.stub(:freeze => operand, :frozen? => true)
+    operand.stub(freeze: operand, :frozen? => true)
   end
 
   it 'delegates to Attribute.infer_type' do
-    return_value = mock('Return Value')
+    return_value = double('Return Value')
     Attribute.should_receive(:infer_type).with(operand).and_return(return_value)
-    should equal(return_value)
+    should be(return_value)
   end
 end

data/spec/unit/axiom/aggregate/variance/class_methods/call_spec.rb

@@ -13,26 +13,26 @@ describe Aggregate::Variance, '.call' do
   let(:object)  { described_class }
 
   context 'when the values are not nil' do
-    let(:values)         { [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 ] }
-    let(:count)          { values.count                                   }
-    let(:mean)           { 0.0                                            }
-    let(:sum_of_squares) { values.map { |value| value ** 2.0 }.reduce(:+) }
+    let(:values)         { [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6] }
+    let(:count)          { values.count                                  }
+    let(:mean)           { 0.0                                           }
+    let(:sum_of_squares) { values.map { |value| value**2.0 }.reduce(:+)  }
 
     it 'returns the expected count' do
       subject.fetch(0).should be(count)
     end
 
     it 'returns the expected mean' do
-      subject.fetch(1).should eql(mean)
+      subject.fetch(1).should == mean
     end
 
     it 'returns the expected sum of squares' do
-      subject.fetch(2).should eql(sum_of_squares)
+      subject.fetch(2).should == sum_of_squares
     end
   end
 
   context 'when the values are nil' do
-    let(:values)         { [ nil ]          }
+    let(:values)         { [nil]            }
     let(:count)          { default.fetch(0) }
     let(:mean)           { default.fetch(1) }
     let(:sum_of_squares) { default.fetch(2) }
@@ -42,11 +42,11 @@ describe Aggregate::Variance, '.call' do
     end
 
     it 'returns the default mean' do
-      subject.fetch(1).should eql(mean)
+      subject.fetch(1).should == mean
     end
 
     it 'returns the default sum of squares' do
-      subject.fetch(2).should eql(sum_of_squares)
+      subject.fetch(2).should == sum_of_squares
     end
   end
 end

data/spec/unit/axiom/aggregate/variance/class_methods/default_spec.rb

@@ -11,5 +11,5 @@ describe Aggregate::Variance, '.default' do
 
   it { should be_frozen }
 
-  it { should eql([ 0, nil, 0.0 ]) }
+  it { should == [0, nil, 0.0] }
 end

data/spec/unit/axiom/aggregate/variance/class_methods/finalize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Aggregate::Variance, '.finalize' do
   subject { object.finalize(accumulator) }
 
-  let(:object)      { described_class                 }
-  let(:accumulator) { [ count, mean, sum_of_squares ] }
+  let(:object)      { described_class               }
+  let(:accumulator) { [count, mean, sum_of_squares] }
 
   context 'when the count is 0' do
     let(:count)          { 0 }
@@ -21,6 +21,14 @@ describe Aggregate::Variance, '.finalize' do
     let(:mean)           { 3.5  }
     let(:sum_of_squares) { 17.5 }
 
-    it { should be_within(2.91).of(0.01) }
+    it { should be_within(0.01).of(2.91) }
+  end
+
+  context 'when the sum of squares is infinte' do
+    let(:count)          { 1               }
+    let(:mean)           { nil             }
+    let(:sum_of_squares) { Float::INFINITY }
+
+    it { should eql(Float::INFINITY) }
   end
 end

data/spec/unit/axiom/aggregate/variance/class_methods/type_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Variance, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it { should be(Types::Float) }
+end

data/spec/unit/axiom/aggregate/variance/methods/variance_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :variance, :var ].each do |method|
+[:variance, :var].each do |method|
   describe Aggregate::Variance::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Aggregate::Variance) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/algebra/difference/delete_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Difference, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(left, right)              }
-  let(:left)           { Relation.new(header, [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:right)          { Relation.new(header, [ [ 1 ] ])               }
-  let(:other_relation) { Relation.new(header, [ [ 2 ] ])               }
-  let(:header)         { [ [ :id, Integer ] ]                          }
+  let(:object)         { described_class.new(left, right)      }
+  let(:left)           { Relation.new(header, [[1], [2], [3]]) }
+  let(:right)          { Relation.new(header, [[1]])           }
+  let(:other_relation) { Relation.new(header, [[2]])           }
+  let(:header)         { [[:id, Integer]]                      }
 
   shared_examples_for 'Algebra::Difference#delete' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Difference, '#delete' do
     its(:header) { should == header }
 
     it 'deletes the tuples' do
-      should == [ [ 3 ] ]
+      should == [[3]]
     end
   end