axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/predicate_partition/right_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::PredicatePartition, '#right' do
   subject { object.right }
 
-  let(:left_header)  { Relation::Header.coerce([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
-  let(:right_header) { Relation::Header.coerce([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
-  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                            }
+  let(:left_header)  { Relation::Header.coerce([[:id, Integer], [:user_name, String], Attribute::Boolean.new(:active_user), Attribute::Boolean.new(:active)])         }
+  let(:right_header) { Relation::Header.coerce([[:id, Integer], [:employee_name, String], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active)]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                      }
 
   context 'when the predicate is a tautology' do
     let(:predicate) { Function::Proposition::Tautology.instance }
 
     it 'partitions the predicate to the right' do
-      should equal(Function::Proposition::Tautology.instance)
+      should be(Function::Proposition::Tautology.instance)
     end
   end
 
@@ -21,7 +21,7 @@ describe Optimizer::PredicatePartition, '#right' do
     let(:predicate) { Function::Proposition::Contradiction.instance }
 
     it 'partitions the predicate to the right' do
-      should equal(Function::Proposition::Contradiction.instance)
+      should be(Function::Proposition::Contradiction.instance)
     end
   end
 
@@ -30,7 +30,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { left_header[:active_user] }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -38,7 +38,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { right_header[:active_employee] }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -46,7 +46,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { right_header[:active] }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
   end
@@ -56,7 +56,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
 
       it 'does not partition the predicate to the right' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -64,7 +64,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -72,7 +72,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { right_header[:id].eq(1) }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -80,7 +80,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { left_header[:active_user].eq(right_header[:active]) }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -88,7 +88,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { right_header[:active_employee].eq(right_header[:active]) }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -96,7 +96,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
 
       it 'does not partition the predicate to the right' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
   end
@@ -106,7 +106,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -114,7 +114,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -122,7 +122,7 @@ describe Optimizer::PredicatePartition, '#right' do
       let(:predicate) { Function::Connective::Negation.new(right_header[:active]) }
 
       it 'partitions the predicate to the right' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
   end
@@ -133,7 +133,7 @@ describe Optimizer::PredicatePartition, '#right' do
     let(:predicate)       { left_predicate.and(right_predicate)         }
 
     it 'partitions the predicate to the right that reference the right header' do
-      should equal(right_predicate)
+      should be(right_predicate)
     end
   end
 

data/spec/unit/axiom/optimizer/relation/materialized/empty_operand/optimizable_predicate_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Optimizer::Relation::Materialized::EmptyOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
-  let(:object)   { described_class.new(relation)            }
+  let(:relation) { Relation.new([[:id, Integer]], body) }
+  let(:object)   { described_class.new(relation)        }
 
   context 'with a body containing no entries' do
     let(:body) { [] }
@@ -15,7 +15,7 @@ describe Optimizer::Relation::Materialized::EmptyOperand, '#optimizable?' do
   end
 
   context 'with a body containing an entry' do
-    let(:body) { [ [ 1 ] ] }
+    let(:body) { [[1]] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/relation/materialized/empty_operand/optimize_spec.rb

@@ -5,17 +5,15 @@ require 'spec_helper'
 describe Optimizer::Relation::Materialized::EmptyOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:relation) { Relation.new(header, LazyEnumerable.new)      }
-  let(:object)   { described_class.new(relation)                 }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]]) }
+  let(:relation) { Relation.new(header, LazyEnumerable.new)  }
+  let(:object)   { described_class.new(relation)             }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Empty) }
 
-  its(:header) { should equal(header) }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should be(header) }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/empty_left/optimizable_predicate_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Binary::EmptyLeft, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:described_class) { Class.new(Optimizer::Relation::Operation::Binary) }
-  let(:relation)        { mock('Relation', :left => left, :right => right)  }
-  let(:right)           { mock('Right')                                     }
+  let(:relation)        { double('Relation', left: left, right: right)      }
+  let(:right)           { double('Right')                                   }
   let(:object)          { described_class.new(relation)                     }
 
   before do
@@ -15,13 +15,13 @@ describe Optimizer::Relation::Operation::Binary::EmptyLeft, '#optimizable?' do
   end
 
   context 'when left is empty' do
-    let(:left) { Relation::Empty.new([ [ :id, Integer ] ]) }
+    let(:left) { Relation::Empty.new([[:id, Integer]]) }
 
     it { should be(true) }
   end
 
   context 'when left is not empty' do
-    let(:left) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+    let(:left) { Relation.new([[:id, Integer]], [[1]]) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/relation/operation/binary/empty_right/optimizable_predicate_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Binary::EmptyRight, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:described_class) { Class.new(Optimizer::Relation::Operation::Binary) }
-  let(:relation)        { mock('Relation', :left => left, :right => right)  }
-  let(:left)            { mock('Left')                                      }
+  let(:relation)        { double('Relation', left: left, right: right)      }
+  let(:left)            { double('Left')                                    }
   let(:object)          { described_class.new(relation)                     }
 
   before do
@@ -15,13 +15,13 @@ describe Optimizer::Relation::Operation::Binary::EmptyRight, '#optimizable?' do
   end
 
   context 'when right is empty' do
-    let(:right) { Relation::Empty.new([ [ :id, Integer ] ]) }
+    let(:right) { Relation::Empty.new([[:id, Integer]]) }
 
     it { should be(true) }
   end
 
   context 'when right is not empty' do
-    let(:right) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+    let(:right) { Relation.new([[:id, Integer]], [[1]]) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/relation/operation/binary/equal_operands/optimizable_predicate_spec.rb

@@ -6,9 +6,9 @@ describe Optimizer::Relation::Operation::Binary::EqualOperands, '#optimizable?'
   subject { object.optimizable? }
 
   let(:described_class)  { Class.new(Optimizer::Relation::Operation::Binary) }
-  let(:relation)         { mock('Relation', :left => left, :right => right)  }
-  let(:materialized)     { mock('Materialized')                              }
-  let(:not_materialized) { mock('Not Materialized')                          }
+  let(:relation)         { double('Relation', left: left, right: right)      }
+  let(:materialized)     { double('Materialized')                            }
+  let(:not_materialized) { double('Not Materialized')                        }
   let(:object)           { described_class.new(relation)                     }
 
   before do

data/spec/unit/axiom/optimizer/relation/operation/binary/left_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary, '#left' do
   subject { object.left }
 
-  let(:optimized) { mock('Optimized')                                }
-  let(:left)      { mock('Left', :optimize => optimized)             }
-  let(:right)     { mock('Right')                                    }
-  let(:relation)  { mock('Relation', :left => left, :right => right) }
-  let(:object)    { described_class.new(relation)                    }
+  let(:optimized) { double('Optimized')                          }
+  let(:left)      { double('Left', optimize: optimized)          }
+  let(:right)     { double('Right')                              }
+  let(:relation)  { double('Relation', left: left, right: right) }
+  let(:object)    { described_class.new(relation)                }
 
-  it { should equal(optimized) }
+  it { should be(optimized) }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/materialized_operands/optimizable_predicate_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::MaterializedOperands, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:materialized)     { Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ])       }
-  let(:not_materialized) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:left)             { not_materialized                                                  }
-  let(:right)            { not_materialized                                                  }
-  let(:relation)         { left.union(right)                                                 }
-  let(:object)           { described_class.new(relation)                                     }
+  let(:materialized)     { Relation::Materialized.new([[:id, Integer]], [[1]])       }
+  let(:not_materialized) { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:left)             { not_materialized                                          }
+  let(:right)            { not_materialized                                          }
+  let(:relation)         { left.union(right)                                         }
+  let(:object)           { described_class.new(relation)                             }
 
   context 'when the right and right are materialized' do
     let(:left)  { materialized }

data/spec/unit/axiom/optimizer/relation/operation/binary/materialized_operands/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::MaterializedOperands, '#optimize' do
   subject { object.optimize }
 
-  let(:left)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:right)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:relation) { left.union(right)                             }
-  let(:object)   { described_class.new(relation)                 }
+  let(:left)     { Relation.new([[:id, Integer]], [[1]]) }
+  let(:right)    { Relation.new([[:id, Integer]], [[1]]) }
+  let(:relation) { left.union(right)                     }
+  let(:object)   { described_class.new(relation)         }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Materialized) }
 
-  its(:header) { should equal(relation.header) }
+  its(:header) { should be(relation.header) }
 
-  it { should == [ [ 1 ] ] }
+  it { should == [[1]] }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/order_left/optimizable_predicate_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::OrderLeft, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:relation) { mock('Relation', :left => left, :right => right) }
-  let(:right)    { mock('Right')                                    }
-  let(:object)   { described_class.new(relation)                    }
+  let(:relation) { double('Relation', left: left, right: right) }
+  let(:right)    { double('Right')                              }
+  let(:object)   { described_class.new(relation)                }
 
   context 'when left is an order' do
-    let(:left) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new).sort_by { |r| r.id } }
+    let(:left) { Relation.new([[:id, Integer]], LazyEnumerable.new).sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
   context 'when left is not an order' do
-    let(:left) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+    let(:left) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/relation/operation/binary/order_left/optimize_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::OrderLeft, '#optimize' do
   subject { object.optimize }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:left)     { base.sort_by { |r| r.id }                              }
-  let(:right)    { base                                                   }
-  let(:relation) { left.union(right)                                      }
-  let(:object)   { described_class.new(relation)                          }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:left)     { base.sort_by { |r| r.id }                          }
+  let(:right)    { base                                               }
+  let(:relation) { left.union(right)                                  }
+  let(:object)   { described_class.new(relation)                      }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(relation.class) }
 
-  its(:left) { should equal(base) }
+  its(:left) { should be(base) }
 
-  its(:right) { should equal(right) }
+  its(:right) { should be(right) }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/order_right/optimizable_predicate_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::OrderRight, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:relation) { mock('Relation', :left => left, :right => right) }
-  let(:left)     { mock('Left')                                     }
-  let(:object)   { described_class.new(relation)                    }
+  let(:relation) { double('Relation', left: left, right: right) }
+  let(:left)     { double('Left')                               }
+  let(:object)   { described_class.new(relation)                }
 
   context 'when right is an order' do
-    let(:right) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new).sort_by { |r| r.id } }
+    let(:right) { Relation.new([[:id, Integer]], LazyEnumerable.new).sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
   context 'when right is not an order' do
-    let(:right) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+    let(:right) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/relation/operation/binary/order_right/optimize_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::OrderRight, '#optimize' do
   subject { object.optimize }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:left)     { base                                                   }
-  let(:right)    { base.sort_by { |r| r.id }                              }
-  let(:relation) { left.union(right)                                      }
-  let(:object)   { described_class.new(relation)                          }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:left)     { base                                               }
+  let(:right)    { base.sort_by { |r| r.id }                          }
+  let(:relation) { left.union(right)                                  }
+  let(:object)   { described_class.new(relation)                      }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(relation.class) }
 
-  its(:left) { should equal(left) }
+  its(:left) { should be(left) }
 
-  its(:right) { should equal(base) }
+  its(:right) { should be(base) }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/right_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary, '#right' do
   subject { object.right }
 
-  let(:optimized) { mock('Optimized')                                }
-  let(:left)      { mock('Left')                                     }
-  let(:right)     { mock('Right', :optimize => optimized)            }
-  let(:relation)  { mock('Relation', :left => left, :right => right) }
-  let(:object)    { described_class.new(relation)                    }
+  let(:optimized) { double('Optimized')                          }
+  let(:left)      { double('Left')                               }
+  let(:right)     { double('Right', optimize: optimized)         }
+  let(:relation)  { double('Relation', left: left, right: right) }
+  let(:object)    { described_class.new(relation)                }
 
-  it { should equal(optimized) }
+  it { should be(optimized) }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/unoptimized_operands/optimizable_predicate_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Binary::UnoptimizedOperands, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:optimized)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:unoptimized) { optimized.project(optimized.header)           }
-  let(:relation)    { left.union(right)                             }
-  let(:object)      { described_class.new(relation)                 }
+  let(:optimized)   { Relation.new([[:id, Integer]], [[1]]) }
+  let(:unoptimized) { optimized.project(optimized.header)   }
+  let(:relation)    { left.union(right)                     }
+  let(:object)      { described_class.new(relation)         }
 
   context 'when the left and right operands are optimized' do
     let(:left)  { optimized }