axiom-optimizer 0.1.0 → 0.1.1

data/spec/integration/axiom/function/predicate/inequality/optimize_spec.rb

@@ -12,7 +12,7 @@ describe Function::Predicate::Inequality, '#optimize' do
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,7 +20,7 @@ describe Function::Predicate::Inequality, '#optimize' do
     context 'and are not joinable' do
       let(:right) { Attribute::String.new(:other) }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -28,7 +28,7 @@ describe Function::Predicate::Inequality, '#optimize' do
     context 'and are joinable' do
       let(:right) { Attribute::Integer.new(:other) }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -38,7 +38,7 @@ describe Function::Predicate::Inequality, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 1 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -46,7 +46,7 @@ describe Function::Predicate::Inequality, '#optimize' do
     context 'right is an invalid value' do
       let(:right) { 'a' }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -64,7 +64,7 @@ describe Function::Predicate::Inequality, '#optimize' do
     context 'left is an invalid value' do
       let(:left) { 'a' }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -75,7 +75,7 @@ describe Function::Predicate::Inequality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -84,7 +84,7 @@ describe Function::Predicate::Inequality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/function/predicate/less_than/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Function::Predicate::LessThan, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
-  let(:left)      { attribute                                                            }
-  let(:right)     { attribute                                                            }
-  let(:object)    { described_class.new(left, right)                                     }
+  let(:attribute) { Attribute::Integer.new(:id, required: false, size: 1..2**31 - 1) }
+  let(:left)      { attribute                                                        }
+  let(:right)     { attribute                                                        }
+  let(:object)    { described_class.new(left, right)                                 }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,25 +20,25 @@ describe Function::Predicate::LessThan, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always less than right' do
-      let(:left)  { attribute                                             }
-      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+      let(:left)  { attribute                                          }
+      let(:right) { Attribute::Integer.new(:right, size: 2**31..2**31) }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always greater than or equal to right' do
-      let(:left)  { attribute                                     }
-      let(:right) { Attribute::Integer.new(:right, :size => 0..0) }
+      let(:left)  { attribute                                  }
+      let(:right) { Attribute::Integer.new(:right, size: 0..0) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -48,7 +48,7 @@ describe Function::Predicate::LessThan, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 2 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -56,7 +56,7 @@ describe Function::Predicate::LessThan, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -74,7 +74,7 @@ describe Function::Predicate::LessThan, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -85,7 +85,7 @@ describe Function::Predicate::LessThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -94,7 +94,7 @@ describe Function::Predicate::LessThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/function/predicate/less_than_or_equal_to/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
-  let(:left)      { attribute                                                            }
-  let(:right)     { attribute                                                            }
-  let(:object)    { described_class.new(left, right)                                     }
+  let(:attribute) { Attribute::Integer.new(:id, required: false, size: 1..2**31 - 1) }
+  let(:left)      { attribute                                                        }
+  let(:right)     { attribute                                                        }
+  let(:object)    { described_class.new(left, right)                                 }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,25 +20,25 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always less than right' do
-      let(:left)  { attribute                                             }
-      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+      let(:left)  { attribute                                          }
+      let(:right) { Attribute::Integer.new(:right, size: 2**31..2**31) }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always greater than right' do
-      let(:left)  { attribute                                       }
-      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+      let(:left)  { attribute                                    }
+      let(:right) { Attribute::Integer.new(:right, size: -1..-1) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -48,7 +48,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 1 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -56,7 +56,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -74,7 +74,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -85,7 +85,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -94,7 +94,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { 2 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/relation/empty/optimize_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Empty, '#optimize' do
   subject { object.optimize }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ]) }
+  let(:object) { described_class.new([[:id, Integer]]) }
 
-  it { should equal(object) }
+  it { should be(object) }
 
   it_should_behave_like 'an optimize method'
 end

data/spec/integration/axiom/relation/materialized/optimize_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Materialized, '#optimize' do
   subject { object.optimize }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ], body) }
+  let(:object) { described_class.new([[:id, Integer]], body) }
 
   context 'with an empty Array' do
     let(:body) { [] }
@@ -20,9 +20,9 @@ describe Relation::Materialized, '#optimize' do
   end
 
   context 'with an nonempty Array' do
-    let(:body) { [ [ 1 ] ] }
+    let(:body) { [[1]] }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/axiom/relation/operation/limit/optimize_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#optimize' do
   subject { object.optimize }
 
-  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
-  let(:directions) { [ relation[:id] ]                           }
-  let(:order)      { relation.sort_by { directions }             }
-  let(:operand)    { order                                       }
-  let(:limit)      { 1                                           }
-  let(:object)     { described_class.new(operand, limit)         }
+  let(:body)       { LazyEnumerable.new([[1], [2], [3]])  }
+  let(:relation)   { Relation.new([[:id, Integer]], body) }
+  let(:directions) { [relation[:id]]                      }
+  let(:order)      { relation.sort_by { directions }      }
+  let(:operand)    { order                                }
+  let(:limit)      { 1                                    }
+  let(:object)     { described_class.new(operand, limit)  }
 
   context 'when the limit is 0' do
     let(:limit) { 0 }
@@ -31,7 +31,7 @@ describe Relation::Operation::Limit, '#optimize' do
   end
 
   context 'containing an order operation' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -46,7 +46,7 @@ describe Relation::Operation::Limit, '#optimize' do
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(order) }
+    its(:operand) { should be(order) }
 
     its(:limit) { should == 1 }
 
@@ -68,10 +68,10 @@ describe Relation::Operation::Limit, '#optimize' do
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(order) }
+    its(:operand) { should be(order) }
 
     it 'uses the more restrictive object' do
-      subject.limit.should == 5
+      expect(subject.limit).to be(5)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -92,10 +92,10 @@ describe Relation::Operation::Limit, '#optimize' do
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(order) }
+    its(:operand) { should be(order) }
 
     it 'uses the more restrictive object' do
-      subject.limit.should == 5
+      expect(subject.limit).to be(5)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -114,7 +114,7 @@ describe Relation::Operation::Limit, '#optimize' do
     let(:operand) { order.take(10) }
     let(:limit)   { 10             }
 
-    it { should equal(operand) }
+    it { should be(operand) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -129,9 +129,9 @@ describe Relation::Operation::Limit, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+    let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer]], [[1]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/axiom/relation/operation/offset/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#optimize' do
   subject { object.optimize }
 
-  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
-  let(:directions) { [ relation[:id] ]                           }
-  let(:order)      { relation.sort_by { directions }             }
-  let(:operand)    { order                                       }
-  let(:offset)     { 1                                           }
-  let(:object)     { described_class.new(operand, offset)        }
+  let(:body)       { LazyEnumerable.new([[1], [2], [3]])  }
+  let(:relation)   { Relation.new([[:id, Integer]], body) }
+  let(:directions) { [relation[:id]]                      }
+  let(:order)      { relation.sort_by { directions }      }
+  let(:operand)    { order                                }
+  let(:offset)     { 1                                    }
+  let(:object)     { described_class.new(operand, offset) }
 
   context 'with an object of 0' do
     let(:offset) { 0 }
 
-    it { should equal(order) }
+    it { should be(order) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -31,7 +31,7 @@ describe Relation::Operation::Offset, '#optimize' do
   end
 
   context 'containing an order operation' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -46,7 +46,7 @@ describe Relation::Operation::Offset, '#optimize' do
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(order) }
+    its(:operand) { should be(order) }
 
     its(:offset) { should == 1 }
 
@@ -68,10 +68,10 @@ describe Relation::Operation::Offset, '#optimize' do
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(order) }
+    its(:operand) { should be(order) }
 
     it 'adds the object of the operations' do
-      subject.offset.should == 15
+      expect(subject.offset).to be(15)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -87,9 +87,9 @@ describe Relation::Operation::Offset, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+    let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 2 ], [ 3 ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer]], [[2], [3]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/axiom/relation/operation/order/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#optimize' do
   subject { object.optimize }
 
-  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
-  let(:operand)    { relation                                    }
-  let(:directions) { [ relation[:id] ]                           }
-  let(:object)     { described_class.new(operand, directions)    }
+  let(:body)       { LazyEnumerable.new([[1], [2], [3]])      }
+  let(:relation)   { Relation.new([[:id, Integer]], body)     }
+  let(:operand)    { relation                                 }
+  let(:directions) { [relation[:id]]                          }
+  let(:object)     { described_class.new(operand, directions) }
 
   context 'containing a relation' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -40,7 +40,7 @@ describe Relation::Operation::Order, '#optimize' do
   end
 
   context 'containing an object operation' do
-    let(:operand) { relation.sort_by { |r| [ r.id.desc ] } }
+    let(:operand) { relation.sort_by { |r| [r.id.desc] } }
 
     it { should eql(relation.sort_by { directions }) }
 
@@ -76,7 +76,7 @@ describe Relation::Operation::Order, '#optimize' do
   context 'containing a limit(1) operation' do
     let(:operand) { relation.sort_by { |r| r.id }.take(1) }
 
-    it { should equal(operand) }
+    it { should be(operand) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -91,10 +91,10 @@ describe Relation::Operation::Order, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-    let(:object)   { described_class.new(relation, directions)                   }
+    let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
+    let(:object)   { described_class.new(relation, directions)       }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer]], [[1], [2], [3]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object