axiom-optimizer 0.1.0 → 0.1.1

data/spec/integration/axiom/algebra/union/optimize_spec.rb

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Algebra::Union, '#optimize' do
   subject { object.optimize }
 
-  let(:header)         { [ [ :id, Integer ] ]             }
-  let(:left_body)      { LazyEnumerable.new([ [ 1 ] ])    }
-  let(:right_body)     { LazyEnumerable.new([ [ 2 ] ])    }
+  let(:header)         { [[:id, Integer]]                 }
+  let(:left_body)      { LazyEnumerable.new([[1]])        }
+  let(:right_body)     { LazyEnumerable.new([[2]])        }
   let(:original_left)  { Relation.new(header, left_body)  }
   let(:original_right) { Relation.new(header, right_body) }
   let(:object)         { described_class.new(left, right) }
 
   before do
     # skip dup of the left and right body to avoid clearing the method stubs
-    left_body.stub!(:frozen?).and_return(true)
-    right_body.stub!(:frozen?).and_return(true)
+    left_body.stub(:frozen?).and_return(true)
+    right_body.stub(:frozen?).and_return(true)
   end
 
   context 'left is an empty relation' do
     let(:left)  { Relation::Empty.new(header) }
     let(:right) { original_right              }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -45,7 +45,7 @@ describe Algebra::Union, '#optimize' do
     let(:left)  { original_left               }
     let(:right) { Relation::Empty.new(header) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -68,7 +68,7 @@ describe Algebra::Union, '#optimize' do
     let(:left)  { Algebra::Restriction.new(original_left, Function::Proposition::Contradiction.instance) }
     let(:right) { original_right                                                                         }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -91,7 +91,7 @@ describe Algebra::Union, '#optimize' do
     let(:left)  { original_left                                                                           }
     let(:right) { Algebra::Restriction.new(original_right, Function::Proposition::Contradiction.instance) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -111,12 +111,12 @@ describe Algebra::Union, '#optimize' do
   end
 
   context 'left and right are equivalent relations' do
-    let(:left_body)  { LazyEnumerable.new([ [ 1 ] ]) }
-    let(:right_body) { LazyEnumerable.new([ [ 1 ] ]) }
-    let(:left)       { original_left                 }
-    let(:right)      { original_right                }
+    let(:left_body)  { LazyEnumerable.new([[1]]) }
+    let(:right_body) { LazyEnumerable.new([[1]]) }
+    let(:left)       { original_left             }
+    let(:right)      { original_right            }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -140,12 +140,12 @@ describe Algebra::Union, '#optimize' do
   end
 
   context 'left and right are equivalent materialized relations' do
-    let(:left_body)  { [ [ 1 ] ]      }
-    let(:right_body) { [ [ 1 ] ]      }
+    let(:left_body)  { [[1]]          }
+    let(:right_body) { [[1]]          }
     let(:left)       { original_left  }
     let(:right)      { original_right }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -170,7 +170,7 @@ describe Algebra::Union, '#optimize' do
     let(:left)  { original_left  }
     let(:right) { original_right }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'executes left_body#each' do
       left_body.should_receive(:each)
@@ -186,10 +186,10 @@ describe Algebra::Union, '#optimize' do
   end
 
   context 'left and right are materialized relations' do
-    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+    let(:left)  { Relation.new(header, [[1], [2]]) }
+    let(:right) { Relation.new(header, [[1]])      }
 
-    it { should eql(Relation::Materialized.new(header, [ [ 1 ], [ 2 ] ])) }
+    it { should eql(Relation::Materialized.new(header, [[1], [2]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/axiom/function/connective/conjunction/optimize_spec.rb

@@ -14,7 +14,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.lt(3) }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -23,7 +23,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { Function::Connective::Negation.new(attribute.gt(1)) }
     let(:right) { Function::Connective::Negation.new(attribute.lt(3)) }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it 'reverses the operands' do
       should eql(described_class.new(attribute.lte(1), attribute.gte(3)))
@@ -45,7 +45,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { Function::Proposition::Tautology.instance }
     let(:right) { Function::Proposition::Tautology.instance }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -54,7 +54,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { Function::Proposition::Contradiction.instance }
     let(:right) { Function::Proposition::Contradiction.instance }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -63,7 +63,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.gt(1)                           }
     let(:right) { Function::Proposition::Tautology.instance }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -72,7 +72,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { Function::Proposition::Tautology.instance }
     let(:right) { attribute.lt(3)                           }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -81,7 +81,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.gt(1)                               }
     let(:right) { Function::Proposition::Contradiction.instance }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -90,7 +90,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { Function::Proposition::Contradiction.instance }
     let(:right) { attribute.lt(3)                               }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -99,7 +99,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.eq(3) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -108,7 +108,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.ne(3) }
 
-    it { should eql(attribute.exclude([ 1, 3 ])) }
+    it { should eql(attribute.exclude([1, 3])) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -117,7 +117,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.ne(1) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -126,25 +126,25 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.eq(1) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.include([ 1, 2 ]) }
-    let(:right) { attribute.exclude([ 1, 2 ]) }
+    let(:left)  { attribute.include([1, 2]) }
+    let(:right) { attribute.exclude([1, 2]) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.exclude([ 1, 2 ]) }
-    let(:right) { attribute.include([ 1, 2 ]) }
+    let(:left)  { attribute.exclude([1, 2]) }
+    let(:right) { attribute.include([1, 2]) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -153,7 +153,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.gt(1)  }
     let(:right) { attribute.lte(1) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -162,7 +162,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.lte(1) }
     let(:right) { attribute.gt(1)  }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -171,7 +171,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.gte(1) }
     let(:right) { attribute.lt(1)  }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -180,7 +180,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.lt(1)  }
     let(:right) { attribute.gte(1) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -190,7 +190,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)      { attribute.match(/Dan Kubb/)    }
     let(:right)     { attribute.no_match(/Dan Kubb/) }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -200,7 +200,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)      { attribute.no_match(/Dan Kubb/) }
     let(:right)     { attribute.match(/Dan Kubb/)    }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -219,7 +219,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.eq(other)               }
     let(:right) { attribute.eq(1)                   }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -229,7 +229,7 @@ describe Function::Connective::Conjunction, '#optimize' do
     let(:left)  { attribute.eq(1)                   }
     let(:right) { attribute.eq(other)               }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/axiom/function/connective/disjunction/optimize_spec.rb

@@ -14,7 +14,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.lt(3) }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -23,7 +23,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { Function::Connective::Negation.new(attribute.gt(1)) }
     let(:right) { Function::Connective::Negation.new(attribute.lt(3)) }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it 'reverses the operands' do
       should eql(Function::Connective::Disjunction.new(attribute.lte(1), attribute.gte(3)))
@@ -36,7 +36,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.gt(1) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -45,7 +45,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { Function::Proposition::Tautology.instance }
     let(:right) { Function::Proposition::Tautology.instance }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -54,8 +54,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { Function::Proposition::Contradiction.instance }
     let(:right) { Function::Proposition::Contradiction.instance }
 
-
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -64,7 +63,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1)                           }
     let(:right) { Function::Proposition::Tautology.instance }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -73,7 +72,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { Function::Proposition::Tautology.instance }
     let(:right) { attribute.lt(3)                           }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -82,7 +81,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1)                               }
     let(:right) { Function::Proposition::Contradiction.instance }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -91,7 +90,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { Function::Proposition::Contradiction.instance }
     let(:right) { attribute.lt(3)                               }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -100,7 +99,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.eq(3) }
 
-    it { should eql(attribute.include([ 1, 3 ])) }
+    it { should eql(attribute.include([1, 3])) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -109,7 +108,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.ne(3) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -118,7 +117,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.ne(1) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -127,25 +126,25 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.eq(1) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.include([ 1, 2 ]) }
-    let(:right) { attribute.exclude([ 1, 2 ]) }
+    let(:left)  { attribute.include([1, 2]) }
+    let(:right) { attribute.exclude([1, 2]) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.exclude([ 1, 2 ]) }
-    let(:right) { attribute.include([ 1, 2 ]) }
+    let(:left)  { attribute.exclude([1, 2]) }
+    let(:right) { attribute.include([1, 2]) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -154,7 +153,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1)  }
     let(:right) { attribute.lte(1) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -163,7 +162,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.lte(1) }
     let(:right) { attribute.gt(1)  }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -172,7 +171,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gte(1) }
     let(:right) { attribute.lt(1)  }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -181,7 +180,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.lt(1)  }
     let(:right) { attribute.gte(1) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -191,7 +190,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)      { attribute.match(/Dan Kubb/)    }
     let(:right)     { attribute.no_match(/Dan Kubb/) }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -201,7 +200,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)      { attribute.no_match(/Dan Kubb/) }
     let(:right)     { attribute.match(/Dan Kubb/)    }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -220,7 +219,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.eq(other)               }
     let(:right) { attribute.eq(1)                   }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -230,7 +229,7 @@ describe Function::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.eq(1)                   }
     let(:right) { attribute.eq(other)               }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end