axiom 0.1.1 → 0.2.0

data/spec/shared/invertible_method_behaviour.rb

@@ -4,6 +4,6 @@ shared_examples_for 'an invertible method' do
   it_should_behave_like 'an idempotent method'
 
   it 'is invertible' do
-    subject.inverse.should be(object)
+    expect(subject.inverse).to be(object)
   end
 end

data/spec/spec_helper.rb

@@ -20,14 +20,16 @@ if ENV['COVERAGE'] == 'true'
   end
 end
 
-require 'devtools/spec_helper'
 require 'axiom'
+require 'devtools/spec_helper'
 
 include Axiom
 
 RSpec.configure do |config|
+  EMPTY_PROC = proc {}.freeze
+
   config.expect_with :rspec do |expect_with|
-    expect_with.syntax = [:expect, :should]
+    expect_with.syntax = :expect
   end
 
   # Record the original Attribute descendants
@@ -42,13 +44,13 @@ RSpec.configure do |config|
 
   # Record the original Type descendants
   config.before do
-    Axiom::Types.finalize
-    @original_type_descendants = Axiom::Types::Type.descendants.dup
+    Types.finalize
+    @original_type_descendants = Types::Type.descendants.dup
   end
 
   # Reset the Type descendants
   config.after do
-    Axiom::Types::Type.descendants.replace(@original_type_descendants)
-    Axiom::Types.instance_variable_get(:@inference_cache).clear
+    Types::Type.descendants.replace(@original_type_descendants)
+    Types.instance_variable_get(:@inference_cache).clear
   end
 end

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

@@ -3,21 +3,19 @@
 require 'spec_helper'
 
 describe Aggregate, '#call' do
-  subject { object.call(nil, tuple) }
+  subject { object.call(accumulator, tuple) }
 
-  let(:described_class) { Class.new(Aggregate)              }
   let(:object)          { described_class.new(attribute)    }
+  let(:described_class) { Class.new(Aggregate)              }
+  let(:accumulator)     { double('accumulator')             }
   let(:attribute)       { Attribute::Integer.new(:id)       }
   let(:header)          { Relation::Header.new([attribute]) }
   let(:tuple)           { Tuple.new(header, [1])            }
 
   context 'when operand is an attribute' do
     before do
-      described_class.class_eval do
-        def self.call(accumulator, value)
-          value
-        end
-      end
+      expect(described_class).to receive(:call).with(accumulator, 1)
+        .and_return(1)
     end
 
     it { should eql(1) }
@@ -27,11 +25,8 @@ describe Aggregate, '#call' do
     let(:object) { described_class.new(2) }
 
     before do
-      described_class.class_eval do
-        def self.call(accumulator, value)
-          value
-        end
-      end
+      expect(described_class).to receive(:call).with(accumulator, 2)
+        .and_return(2)
     end
 
     it { should eql(2) }

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

@@ -5,7 +5,12 @@ require 'spec_helper'
 describe Aggregate, '.default' do
   subject { object.default }
 
-  let(:object) { described_class }
+  let(:object)  { Class.new(described_class) }
+  let(:default) { double('default')          }
 
-  specify { expect { subject }.to raise_error(NameError) }
+  before do
+    object.const_set(:DEFAULT, default)
+  end
+
+  it { should be(default) }
 end

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

@@ -11,7 +11,7 @@ describe Aggregate, '#default' do
 
   it 'delegates to self.class.default' do
     return_value = double('Return Value')
-    described_class.should_receive(:default).with(no_args).and_return(return_value)
+    expect(described_class).to receive(:default).with(no_args).and_return(return_value)
     should be(return_value)
   end
 end

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

@@ -12,7 +12,7 @@ describe Aggregate, '#finalize' do
 
   it 'delegates to self.class.finalize' do
     return_value = double('Return Value')
-    described_class.should_receive(:finalize).with(accumulator).and_return(return_value)
+    expect(described_class).to receive(:finalize).with(accumulator).and_return(return_value)
     should be(return_value)
   end
 end

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

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

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

@@ -16,7 +16,7 @@ describe Aggregate::Mean, '.call' do
     let(:values) { [0] }
 
     it 'returns the expected count and mean of the values' do
-      should == [1, 0.0]
+      should eql([1, 0.to_r])
     end
   end
 
@@ -24,7 +24,7 @@ describe Aggregate::Mean, '.call' do
     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 == [13, 0.0]
+      should eql([13, 0.to_r])
     end
   end
 

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

@@ -8,9 +8,16 @@ describe Aggregate::Mean, '.finalize' do
   let(:object)      { described_class }
   let(:accumulator) { [count, mean]   }
   let(:count)       { double('Count') }
-  let(:mean)        { double('Mean')  }
 
-  it_should_behave_like 'an idempotent method'
+  context 'when the accumulator mean is nil' do
+    let(:mean) { nil }
 
-  it { should be(mean) }
+    it { should be_nil }
+  end
+
+  context 'when the accumulator mean is not nil' do
+    let(:mean) { 1.to_r }
+
+    it { should eql(1.0) }
+  end
 end

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

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

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

@@ -7,27 +7,53 @@ describe Aggregate::Sum, '#default' do
 
   let(:object) { described_class.new(attribute) }
 
+  # This is needed to test the contract that the DEFAULT constant is
+  # used for the identity. Subclasses of this function may rely on this.
+  def self.default_value(value)
+    before do
+      stub_const("#{described_class}::DEFAULT", value)
+    end
+  end
+
   context 'when the attribute is an Integer' do
     let(:attribute) { Attribute::Integer.new(:integer) }
 
-    it { should be_kind_of(attribute.type.primitive) }
+    context 'with the default value of 0' do
+      it { should be(0) }
+    end
+
+    context 'with a default value other than 0' do
+      default_value(1)
 
-    it { should be_zero }
+      it { should be(1) }
+    end
   end
 
   context 'when the attribute is a Float' do
     let(:attribute) { Attribute::Float.new(:float) }
 
-    it { should be_instance_of(attribute.type.primitive) }
+    context 'with the default value of 0' do
+      it { should eql(0.0) }
+    end
 
-    it { should be_zero }
+    context 'with the default value other than 0' do
+      default_value(1)
+
+      it { should eql(1.0) }
+    end
   end
 
   context 'when the attribute is a Decimal' do
     let(:attribute) { Attribute::Decimal.new(:decimal) }
 
-    it { should be_instance_of(attribute.type.primitive) }
+    context 'with the default value of 0' do
+      it { should eql(BigDecimal('0')) }
+    end
+
+    context 'with the default value other than 0' do
+      default_value(1)
 
-    it { should be_zero }
+      it { should eql(BigDecimal('1')) }
+    end
   end
 end

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

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

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

@@ -19,15 +19,15 @@ describe Aggregate::Variance, '.call' do
     let(:sum_of_squares) { values.map { |value| value**2.0 }.reduce(:+)  }
 
     it 'returns the expected count' do
-      subject.fetch(0).should be(count)
+      expect(subject.fetch(0)).to be(count)
     end
 
     it 'returns the expected mean' do
-      subject.fetch(1).should == mean
+      expect(subject.fetch(1)).to eq(mean)
     end
 
     it 'returns the expected sum of squares' do
-      subject.fetch(2).should == sum_of_squares
+      expect(subject.fetch(2)).to eq(sum_of_squares)
     end
   end
 
@@ -38,15 +38,15 @@ describe Aggregate::Variance, '.call' do
     let(:sum_of_squares) { default.fetch(2) }
 
     it 'returns the default count' do
-      subject.fetch(0).should be(count)
+      expect(subject.fetch(0)).to be(count)
     end
 
     it 'returns the default mean' do
-      subject.fetch(1).should == mean
+      expect(subject.fetch(1)).to eq(mean)
     end
 
     it 'returns the default sum of squares' do
-      subject.fetch(2).should == sum_of_squares
+      expect(subject.fetch(2)).to eq(sum_of_squares)
     end
   end
 end

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

@@ -17,7 +17,7 @@ describe Algebra::Difference, '#each' do
 
     it 'yields no tuples' do
       subject
-      yields.should be_empty
+      expect(yields).to be_empty
     end
   end
 
@@ -28,12 +28,12 @@ describe Algebra::Difference, '#each' do
 
     it 'yields only tuples' do
       subject
-      yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+      yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
     end
 
     it 'yields only tuples with the expected header' do
       subject
-      yields.each { |tuple| tuple.header.should be(object.header) }
+      yields.each { |tuple| expect(tuple.header).to be(object.header) }
     end
 
     it 'yields only tuples with the expected data' do

data/spec/unit/axiom/algebra/extension/class_methods/new_spec.rb

@@ -15,7 +15,7 @@ describe Algebra::Extension, '.new' do
   end
 
   context 'with a duplicate attribute name provided' do
-    let(:extensions) { { id: proc {}, name: proc {} } }
+    let(:extensions) { { id: EMPTY_PROC, name: EMPTY_PROC } }
 
     specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: [:id, :name]') }
   end

data/spec/unit/axiom/algebra/extension/each_spec.rb

@@ -14,12 +14,12 @@ describe Algebra::Extension, '#each' do
 
   it 'yields only tuples' do
     subject
-    yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+    yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
   end
 
   it 'yields only tuples with the expected header' do
     subject
-    yields.each { |tuple| tuple.header.should be(object.header) }
+    yields.each { |tuple| expect(tuple.header).to be(object.header) }
   end
 
   it 'yields only tuples with the expected data' do

data/spec/unit/axiom/algebra/intersection/each_spec.rb

@@ -17,12 +17,12 @@ describe Algebra::Intersection, '#each' do
 
     it 'yields only tuples' do
       subject
-      yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+      yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
     end
 
     it 'yields only tuples with the expected header' do
       subject
-      yields.each { |tuple| tuple.header.should be(object.header) }
+      yields.each { |tuple| expect(tuple.header).to be(object.header) }
     end
 
     it 'yields only tuples with the expected data' do
@@ -39,7 +39,7 @@ describe Algebra::Intersection, '#each' do
 
     it 'yields no tuples' do
       subject
-      yields.should be_empty
+      expect(yields).to be_empty
     end
   end
 end

data/spec/unit/axiom/algebra/join/each_spec.rb

@@ -16,12 +16,12 @@ describe Algebra::Join, '#each' do
 
     it 'yields only tuples' do
       subject
-      yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+      yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
     end
 
     it 'yields only tuples with the expected header' do
       subject
-      yields.each { |tuple| tuple.header.should be(object.header) }
+      yields.each { |tuple| expect(tuple.header).to be(object.header) }
     end
 
     it 'yields only tuples with the expected data' do
@@ -38,12 +38,12 @@ describe Algebra::Join, '#each' do
 
     it 'yields only tuples' do
       subject
-      yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+      yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
     end
 
     it 'yields only tuples with the expected header' do
       subject
-      yields.each { |tuple| tuple.header.should be(object.header) }
+      yields.each { |tuple| expect(tuple.header).to be(object.header) }
     end
 
     it 'yields only tuples with the expected data' do
@@ -60,12 +60,12 @@ describe Algebra::Join, '#each' do
 
     it 'yields only tuples' do
       subject
-      yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+      yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
     end
 
     it 'yields only tuples with the expected header' do
       subject
-      yields.each { |tuple| tuple.header.should be(object.header) }
+      yields.each { |tuple| expect(tuple.header).to be(object.header) }
     end
 
     it 'yields only tuples with the expected data' do

data/spec/unit/axiom/algebra/product/each_spec.rb

@@ -15,12 +15,12 @@ describe Algebra::Product, '#each' do
 
   it 'yields only tuples' do
     subject
-    yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+    yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
   end
 
   it 'yields only tuples with the expected header' do
     subject
-    yields.each { |tuple| tuple.header.should be(object.header) }
+    yields.each { |tuple| expect(tuple.header).to be(object.header) }
   end
 
   it 'yields only tuples with the expected data' do