axiom 0.1.1 → 0.2.0

data/spec/unit/axiom/evaluator/context/add_spec.rb

@@ -14,7 +14,7 @@ describe Evaluator::Context, '#add' do
     its(:functions) { should eql(Attribute::Integer.new(:aggregate) => aggregate) }
 
     it 'returns self' do
-      subject.yield.equal?(subject).should be(true)
+      expect(subject.yield.equal?(subject)).to be(true)
     end
   end
 
@@ -26,31 +26,31 @@ describe Evaluator::Context, '#add' do
     its(:functions) { should eql(Attribute::Integer.new(:function) => function) }
 
     it 'returns self' do
-      subject.yield.equal?(subject).should be(true)
+      expect(subject.yield.equal?(subject)).to be(true)
     end
   end
 
   context 'when a proc is provided' do
     subject { described_class.new(header) { |object| object.add(:block, block) } }
 
-    let(:block) { proc {} }
+    let(:block) { EMPTY_PROC }
 
     its(:functions) { should eql(Attribute::Object.new(:block) => block) }
 
     it 'returns self' do
-      subject.yield.equal?(subject).should be(true)
+      expect(subject.yield.equal?(subject)).to be(true)
     end
   end
 
   context 'when a block is provided' do
     subject { described_class.new(header) { |object| object.add(:block, &block) } }
 
-    let(:block) { proc {} }
+    let(:block) { EMPTY_PROC }
 
     its(:functions) { should eql(Attribute::Object.new(:block) => block) }
 
     it 'returns self' do
-      subject.yield.equal?(subject).should be(true)
+      expect(subject.yield.equal?(subject)).to be(true)
     end
   end
 
@@ -60,7 +60,7 @@ describe Evaluator::Context, '#add' do
     its(:functions) { should eql(Attribute::Integer.new(:literal) => 1) }
 
     it 'returns self' do
-      subject.yield.equal?(subject).should be(true)
+      expect(subject.yield.equal?(subject)).to be(true)
     end
   end
 end

data/spec/unit/axiom/evaluator/context/element_reader_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Evaluator::Context, '#[]' do
   subject { object[name] }
 
-  let(:name)      { :id                               }
-  let(:attribute) { Attribute::Integer.new(name)      }
-  let(:header)    { Relation::Header.new([attribute]) }
-  let(:object)    { described_class.new(header) {}    }
+  let(:name)      { :id                                      }
+  let(:attribute) { Attribute::Integer.new(name)             }
+  let(:header)    { Relation::Header.new([attribute])        }
+  let(:object)    { described_class.new(header, &EMPTY_PROC) }
 
   it { should be(attribute) }
 end

data/spec/unit/axiom/evaluator/context/functions_spec.rb

@@ -7,7 +7,7 @@ describe Evaluator::Context, '#functions' do
 
   let(:attribute) { Attribute::Integer.new(:id)                                              }
   let(:header)    { Relation::Header.new([attribute])                                        }
-  let(:function)  { proc {}                                                                  }
+  let(:function)  { EMPTY_PROC                                                               }
   let(:object)    { described_class.new(header) { |object| object.add(attribute, function) } }
 
   it { should == { attribute => function } }

data/spec/unit/axiom/evaluator/context/method_missing_spec.rb

@@ -3,9 +3,9 @@
 require 'spec_helper'
 
 describe Evaluator::Context, '#method_missing' do
-  let(:attribute) { Attribute::Integer.new(:id)       }
-  let(:header)    { Relation::Header.new([attribute]) }
-  let(:object)    { described_class.new(header) {}    }
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:header)    { Relation::Header.new([attribute])        }
+  let(:object)    { described_class.new(header, &EMPTY_PROC) }
 
   context 'with a valid attribute' do
     subject { object.id }

data/spec/unit/axiom/evaluator/context/respond_to_predicate_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Evaluator::Context, '#respond_to?' do
   subject { object.respond_to?(method, include_private) }
 
-  let(:attribute) { Attribute::Integer.new(:id)       }
-  let(:header)    { Relation::Header.new([attribute]) }
-  let(:object)    { described_class.new(header) {}    }
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:header)    { Relation::Header.new([attribute])        }
+  let(:object)    { described_class.new(header, &EMPTY_PROC) }
 
   context 'when the method is an attribute name and include_private is true' do
     let(:method)          { attribute.name }

data/spec/unit/axiom/evaluator/context/send_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Evaluator::Context, '#send' do
   subject { object.send(method, args, &block) }
 
-  let(:attribute) { Attribute::Integer.new(:id)       }
-  let(:header)    { Relation::Header.new([attribute]) }
-  let(:object)    { described_class.new(header) {}    }
-  let(:method)    { :test                             }
-  let(:args)      { double('Arguments')               }
-  let(:block)     { proc {}                           }
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:header)    { Relation::Header.new([attribute])        }
+  let(:object)    { described_class.new(header, &EMPTY_PROC) }
+  let(:method)    { :test                                    }
+  let(:args)      { double('Arguments')                      }
+  let(:block)     { EMPTY_PROC                               }
 
   before do
     def object.test(args, &block)
@@ -19,10 +19,10 @@ describe Evaluator::Context, '#send' do
   end
 
   it 'delegates the arguments to the method' do
-    subject[0].should be(args)
+    expect(subject[0]).to be(args)
   end
 
   it 'delegates the block to the method' do
-    subject[1].should be(block)
+    expect(subject[1]).to be(block)
   end
 end

data/spec/unit/axiom/function/binary/call_spec.rb

@@ -15,7 +15,7 @@ describe Function::Binary, '#call' do
   let(:object)          { described_class.new(left, right)                  }
 
   before do
-    described_class.should_receive(:call).with(true, false).and_return(response)
+    expect(described_class).to receive(:call).with(true, false).and_return(response)
   end
 
   it { should be(response) }

data/spec/unit/axiom/function/binary/type_spec.rb

@@ -5,11 +5,18 @@ require 'spec_helper'
 describe Function::Binary, '#type' do
   subject { object.type }
 
-  let(:object)          { described_class.new(*operands) }
-  let(:described_class) { Class.new(Function::Numeric)   }
+  let(:object)          { described_class.new(*operands)         }
+  let(:described_class) { Class.new(Function::Numeric)           }
+  let(:operands)        { types.map(&operand_class.method(:new)) }
 
-  let(:operands) do
-    types.map { |type| double(type: type, frozen?: true) }
+  let(:operand_class) do
+    Class.new do
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+    end
   end
 
   before do
@@ -41,12 +48,7 @@ describe Function::Binary, '#type' do
   end
 
   context 'when an operand is a primitive' do
-    let(:operands) do
-      [
-        double(type: Types::Integer, frozen?: true),
-        1,
-      ]
-    end
+    let(:operands) { [operand_class.new(Types::Integer), 1] }
 
     it { should be(Types::Integer) }
   end

data/spec/unit/axiom/function/comparable/class_methods/included_spec.rb

@@ -9,9 +9,9 @@ describe Function::Comparable, '.included' do
   let(:klass)  { Class.new       }
 
   it 'extends the klass' do
-    klass.singleton_class.should_not include(described_class::ClassMethods)
+    expect(klass.singleton_class).not_to include(described_class::ClassMethods)
     klass.send(:include, subject)
-    klass.singleton_class.should include(described_class::ClassMethods)
+    expect(klass.singleton_class).to include(described_class::ClassMethods)
   end
 
   it 'delegates to the ancestor' do

data/spec/unit/axiom/function/connective/negation/inverse_spec.rb

@@ -16,6 +16,6 @@ describe Function::Connective::Negation, '#inverse' do
   end
 
   it 'is not invertible' do
-    subject.inverse.should_not eql(object)
+    expect(subject.inverse).not_to eql(object)
   end
 end

data/spec/unit/axiom/function/predicate/call_spec.rb

@@ -6,13 +6,14 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate, '#call' do
   subject { object.call(tuple) }
 
-  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
-  let(:tuple)  { Tuple.new(header, [1])                    }
-  let(:object) { described_class.new(header[:id], 1)       }
+  let(:object)          { described_class.new(header[:id], 1)       }
+  let(:described_class) { Class.new(Function::Predicate)            }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+  let(:tuple)           { Tuple.new(header, [1])                    }
 
   it 'sends the left and right value to self.class.call' do
     response = double('#call response')
-    described_class.should_receive(:call).with(1, 1).and_return(response)
+    expect(described_class).to receive(:call).with(1, 1).and_return(response)
     should be(response)
   end
 end

data/spec/unit/axiom/function/predicate/enumerable/call_spec.rb

@@ -18,7 +18,7 @@ describe Function::Predicate::Enumerable, '#call' do
 
     it 'sends the left and right value to self.class.call' do
       response = double('#call response')
-      described_class.should_receive(:call).with(1, [1]).and_return(response)
+      expect(described_class).to receive(:call).with(1, [1]).and_return(response)
       should be(response)
     end
   end
@@ -29,7 +29,17 @@ describe Function::Predicate::Enumerable, '#call' do
 
     it 'sends the left and right value to self.class.call' do
       response = double('#call response')
-      described_class.should_receive(:call).with(1, [1]).and_return(response)
+      expect(described_class).to receive(:call).with(1, [1]).and_return(response)
+      should be(response)
+    end
+  end
+
+  context 'with an enumerable of attributes' do
+    let(:object)   { described_class.new(header[:id], [header[:id]]) }
+
+    it 'sends the left and right value to self.class.call' do
+      response = double('#call response')
+      expect(described_class).to receive(:call).with(1, [1]).and_return(response)
       should be(response)
     end
   end

data/spec/unit/axiom/function/predicate/eql_spec.rb

@@ -6,9 +6,10 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:left)   { Attribute::Integer.new(:id)      }
-  let(:right)  { 1                                }
-  let(:object) { described_class.new(left, right) }
+  let(:object)          { described_class.new(left, right) }
+  let(:described_class) { Class.new(Function::Predicate)   }
+  let(:left)            { Attribute::Integer.new(:id)      }
+  let(:right)           { 1                                }
 
   context 'with the same object' do
     let(:other) { object }

data/spec/unit/axiom/function/predicate/equality/methods/eq_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::Equality::Methods, '#eq' do
   subject { object.eq(other) }
 
+  let(:object)          { described_class.new.freeze   }
   let(:described_class) { EqualityMethodsSpecs::Object }
   let(:other)           { true                         }
-  let(:object)          { described_class.new          }
 
   it { should be_instance_of(Function::Predicate::Equality) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/exclusion/class_methods/call_spec.rb

@@ -6,18 +6,47 @@ describe Function::Predicate::Exclusion, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
+  let(:left)   { 1               }
 
-  context 'when left is excluded from right' do
-    let(:left)  { 1   }
-    let(:right) { [0] }
+  context 'when right responds to #cover?' do
+    # Create class that only delegates #cover?
+    let(:coverable) do
+      Class.new do
+        def initialize(object)
+          @object = object
+        end
 
-    it { should be(true) }
+        def cover?(value)
+          @object.cover?(value)
+        end
+      end
+    end
+
+    context 'when left is excluded in right' do
+      let(:right) { coverable.new(1..1) }
+
+      it { should be(false) }
+    end
+
+    context 'when left is not excluded in right' do
+      let(:right) { coverable.new(0..0) }
+
+      it { should be(true) }
+    end
   end
 
-  context 'when left is not excluded from right' do
-    let(:left)  { 1   }
-    let(:right) { [1] }
+  context 'when right responds to #include?' do
+
+    context 'when left is excluded in right' do
+      let(:right) { [1] }
+
+      it { should be(false) }
+    end
+
+    context 'when left is not excluded in right' do
+      let(:right) { [0] }
 
-    it { should be(false) }
+      it { should be(true) }
+    end
   end
 end

data/spec/unit/axiom/function/predicate/exclusion/methods/exclude_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::Exclusion::Methods, '#exclude' do
   subject { object.exclude(other) }
 
+  let(:object)          { described_class.new.freeze    }
   let(:described_class) { ExclusionMethodsSpecs::Object }
-  let(:other)           { [true, false]                 }
-  let(:object)          { described_class.new           }
+  let(:other)           { [true, false].freeze          }
 
   it { should be_instance_of(Function::Predicate::Exclusion) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/greater_than/methods/gt_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::GreaterThan::Methods, '#gt' do
   subject { object.gt(other) }
 
+  let(:object)          { described_class.new.freeze      }
   let(:described_class) { GreaterThanMethodsSpecs::Object }
   let(:other)           { 1                               }
-  let(:object)          { described_class.new             }
 
   it { should be_instance_of(Function::Predicate::GreaterThan) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/greater_than_or_equal_to/methods/gte_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::GreaterThanOrEqualTo::Methods, '#gte' do
   subject { object.gte(other) }
 
+  let(:object)          { described_class.new.freeze               }
   let(:described_class) { GreaterThanOrEqualToMethodsSpecs::Object }
   let(:other)           { 1                                        }
-  let(:object)          { described_class.new                      }
 
   it { should be_instance_of(Function::Predicate::GreaterThanOrEqualTo) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/inclusion/class_methods/call_spec.rb

@@ -6,18 +6,47 @@ describe Function::Predicate::Inclusion, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
+  let(:left)   { 1               }
 
-  context 'when left is included in right' do
-    let(:left)  { 1   }
-    let(:right) { [1] }
+  context 'when right responds to #cover?' do
+    # Create class that only delegates #cover?
+    let(:coverable) do
+      Class.new do
+        def initialize(object)
+          @object = object
+        end
 
-    it { should be(true) }
+        def cover?(value)
+          @object.cover?(value)
+        end
+      end
+    end
+
+    context 'when left is included in right' do
+      let(:right) { coverable.new(1..1) }
+
+      it { should be(true) }
+    end
+
+    context 'when left is not included in right' do
+      let(:right) { coverable.new(0..0) }
+
+      it { should be(false) }
+    end
   end
 
-  context 'when left is not included in right' do
-    let(:left)  { 1   }
-    let(:right) { [0] }
+  context 'when right responds to #include?' do
+
+    context 'when left is included in right' do
+      let(:right) { [1] }
+
+      it { should be(true) }
+    end
+
+    context 'when left is not included in right' do
+      let(:right) { [0] }
 
-    it { should be(false) }
+      it { should be(false) }
+    end
   end
 end