axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/algebra/restriction/unoptimized_operand/optimize_spec.rb

@@ -5,20 +5,20 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { base.rename({}).restrict { |r| r.id.eq(1) }         }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { base.rename({}).restrict { |r| r.id.eq(1) }     }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Restriction) }
 
-  it { should_not equal(relation) }
+  it { should_not be(relation) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
   its(:predicate) { should == base[:id].eq(1) }
 end

data/spec/unit/axiom/optimizer/algebra/summarization/empty_operand/class_methods/extension_default_spec.rb

@@ -8,7 +8,7 @@ describe Optimizer::Algebra::Summarization::EmptyOperand, '.extension_default' d
   let(:object) { described_class }
 
   context 'when the function has a default' do
-    let(:operand)  { mock('Operand')               }
+    let(:operand)  { double('Operand')             }
     let(:function) { Aggregate::Count.new(operand) }
 
     it { should eql(0) }

data/spec/unit/axiom/optimizer/algebra/summarization/empty_operand/optimizable_predicate_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::EmptyOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)        { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)          { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ]))  }
-  let(:relation)      { operand.summarize(summarize_per) {}                              }
-  let(:summarize_per) { TABLE_DEE                                                        }
-  let(:object)        { described_class.new(relation)                                    }
+  let(:header)        { Relation::Header.coerce([[:id, Integer], [:name, String]])  }
+  let(:base)          { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb']])) }
+  let(:relation)      { operand.summarize(summarize_per) {}                         }
+  let(:summarize_per) { TABLE_DEE                                                   }
+  let(:object)        { described_class.new(relation)                               }
 
   before do
-    object.operation.should be_kind_of(Algebra::Summarization)
+    expect(object.operation).to be_kind_of(Algebra::Summarization)
   end
 
   context 'when the operand is empty' do

data/spec/unit/axiom/optimizer/algebra/summarization/empty_operand/optimize_spec.rb

@@ -5,42 +5,42 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::EmptyOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)        { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)          { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:attribute)     { Attribute::Object.new(:test)                        }
-  let(:operand)       { base.restrict { false }                             }
-  let(:summarize_per) { TABLE_DEE                                           }
-  let(:object)        { described_class.new(relation)                       }
+  let(:header)        { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)          { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:attribute)     { Attribute::Object.new(:test)                    }
+  let(:operand)       { base.restrict { false }                         }
+  let(:summarize_per) { TABLE_DEE                                       }
+  let(:object)        { described_class.new(relation)                   }
 
   context 'when the function has a default' do
     let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, r.id.count) } }
 
     before do
-      object.should be_optimizable
+      expect(object).to be_optimizable
     end
 
     it { should be_kind_of(Algebra::Extension) }
 
-    it { should_not equal(operand) }
+    it { should_not be(operand) }
 
-    its(:operand) { should equal(summarize_per) }
+    its(:operand) { should be(summarize_per) }
 
     its(:extensions) { should == { attribute => 0 } }
   end
 
   context 'when the function does not have a default' do
-    let(:function) { lambda { |acc, tuple| 1 }                                           }
+    let(:function) { ->(acc, tuple) { 1 }                                                }
     let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
 
     before do
-      object.should be_optimizable
+      expect(object).to be_optimizable
     end
 
     it { should be_kind_of(Algebra::Extension) }
 
-    it { should_not equal(operand) }
+    it { should_not be(operand) }
 
-    its(:operand) { should equal(summarize_per) }
+    its(:operand) { should be(summarize_per) }
 
     its(:extensions) { should == { attribute => nil } }
   end

data/spec/unit/axiom/optimizer/algebra/summarization/empty_summarize_per/optimizable_predicate_spec.rb

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::EmptySummarizePer, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ]))  }
-  let(:operand)  { base                                                             }
-  let(:relation) { operand.summarize(summarize_per) {}                              }
-  let(:object)   { described_class.new(relation)                                    }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String]])  }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb']])) }
+  let(:operand)  { base                                                        }
+  let(:relation) { operand.summarize(summarize_per) {}                         }
+  let(:object)   { described_class.new(relation)                               }
 
   before do
-    object.operation.should be_kind_of(Algebra::Summarization)
+    expect(object.operation).to be_kind_of(Algebra::Summarization)
   end
 
   context 'when the summarize_per is empty' do
-    let(:summarize_per) { base.project([ :id ]).restrict { false } }
+    let(:summarize_per) { base.project([:id]).restrict { false } }
 
     it { should be(true) }
   end
 
   context 'when the summarize_per is not empty' do
-    let(:summarize_per) { base.project([ :id ]) }
+    let(:summarize_per) { base.project([:id]) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/summarization/empty_summarize_per/optimize_spec.rb

@@ -5,21 +5,19 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::EmptySummarizePer, '#optimize' do
   subject { object.optimize }
 
-  let(:header)        { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ])        }
-  let(:base)          { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ]))         }
+  let(:header)        { Relation::Header.coerce([[:id, Integer], [:name, String]])              }
+  let(:base)          { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb']]))             }
   let(:attribute)     { Attribute::Object.new(:test)                                            }
   let(:operand)       { base                                                                    }
-  let(:summarize_per) { base.project([ :id ]).restrict { false }                                }
+  let(:summarize_per) { base.project([:id]).restrict { false }                                  }
   let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, r.name.count) } }
   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 == [ [ :id, Integer ], [ :test, Object ] ] }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should == [[:id, Integer], [:test, Object]] }
 end

data/spec/unit/axiom/optimizer/algebra/summarization/order_operand/optimizable_predicate_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::OrderOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:relation) { operand.summarize([]) {}                               }
-  let(:object)   { described_class.new(relation)                          }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:relation) { operand.summarize([]) {}                           }
+  let(:object)   { described_class.new(relation)                      }
 
   context 'when operand is an order' do
     let(:operand) { base.sort_by { |r| r.id } }

data/spec/unit/axiom/optimizer/algebra/summarization/order_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::OrderOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:operand)  { base.sort_by { |r| r.id }                              }
-  let(:relation) { operand.summarize([]) {}                               }
-  let(:object)   { described_class.new(relation)                          }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:operand)  { base.sort_by { |r| r.id }                          }
+  let(:relation) { operand.summarize([]) {}                           }
+  let(:object)   { described_class.new(relation)                      }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Summarization) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
   its(:summarizers) { should eql(relation.summarizers) }
 end

data/spec/unit/axiom/optimizer/algebra/summarization/summarize_per_spec.rb

@@ -5,25 +5,25 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization, '#summarize_per' do
   subject { object.summarize_per }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:relation) { base.summarize(summarize_per) {}              }
-  let(:object)   { described_class.new(relation)                 }
+  let(:base)     { Relation.new([[:id, Integer]], [[1]]) }
+  let(:relation) { base.summarize(summarize_per) {}      }
+  let(:object)   { described_class.new(relation)         }
 
   before do
-    object.operation.should be_kind_of(Algebra::Summarization)
+    expect(object.operation).to be_kind_of(Algebra::Summarization)
   end
 
   context 'when summarize_per is optimized' do
     let(:summarize_per) { TABLE_DEE }
 
-    it { should equal(summarize_per) }
+    it { should be(summarize_per) }
   end
 
   context 'when summarize_per is not not optimized' do
    let(:summarize_per) { TABLE_DEE.rename({}) }
 
-    it { should_not equal(summarize_per) }
+    it { should_not be(summarize_per) }
 
-    it { should equal(TABLE_DEE) }
+    it { should be(TABLE_DEE) }
   end
 end

data/spec/unit/axiom/optimizer/algebra/summarization/summarizers_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization, '#summarizers' do
   subject { object.summarizers }
 
-  let(:base)          { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])                    }
+  let(:base)          { Relation.new([[:id, Integer]], [[1]])                            }
   let(:attribute)     { Attribute::Object.new(:test)                                     }
   let(:summarize_per) { TABLE_DEE                                                        }
   let(:relation)      { base.summarize(summarize_per) { |r| r.add(attribute, function) } }
   let(:object)        { described_class.new(relation)                                    }
 
   before do
-    object.operation.should be_kind_of(Algebra::Summarization)
+    expect(object.operation).to be_kind_of(Algebra::Summarization)
   end
 
   context 'when summarizers are optimized' do
@@ -24,7 +24,7 @@ describe Optimizer::Algebra::Summarization, '#summarizers' do
   context 'when summarizers are not optimized' do
     let(:function) { Aggregate::Sum.new(Function::Numeric::Absolute.new(1)) }
 
-    it { should_not equal(relation.summarizers) }
+    it { should_not be(relation.summarizers) }
 
     it { should eql(attribute => Aggregate::Sum.new(1)) }
   end

data/spec/unit/axiom/optimizer/algebra/summarization/unoptimized_operand/optimizable_predicate_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ])    }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ]))     }
+  let(:header)    { Relation::Header.coerce([[:id, Integer], [:name, String]])          }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb']]))         }
   let(:attribute) { Attribute::Object.new(:test)                                        }
   let(:relation)  { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
   let(:object)    { described_class.new(relation)                                       }
 
   before do
-    object.operation.should be_kind_of(Algebra::Summarization)
+    expect(object.operation).to be_kind_of(Algebra::Summarization)
   end
 
   context 'when the operand is optimizable' do

data/spec/unit/axiom/optimizer/algebra/summarization/unoptimized_operand/optimize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)        { Relation::Header.coerce([ [ :id, Integer ] ])                       }
-  let(:base)          { Relation.new(header, LazyEnumerable.new([ [ 1 ] ]))                 }
+  let(:header)        { Relation::Header.coerce([[:id, Integer]])                           }
+  let(:base)          { Relation.new(header, LazyEnumerable.new([[1]]))                     }
   let(:attribute)     { Attribute::Object.new(:text)                                        }
   let(:function)      { Aggregate::Sum.new(Function::Numeric::Absolute.new(1))              }
   let(:operand)       { base.rename({})                                                     }
@@ -15,16 +15,16 @@ describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
   let(:object)        { described_class.new(relation)                                       }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Summarization) }
 
-  it { should_not equal(operand) }
+  it { should_not be(operand) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
-  its(:summarize_per) { should equal(TABLE_DEE) }
+  its(:summarize_per) { should be(TABLE_DEE) }
 
   its(:summarizers) { should == { attribute => Aggregate::Sum.new(1) } }
 end

data/spec/unit/axiom/optimizer/algebra/union/empty_left/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Union::EmptyLeft, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation::Empty.new(header)                         }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
-  let(:relation) { left.union(right)                                   }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation::Empty.new(header)                     }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[2]])) }
+  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 equal(right) }
+  it { should be(right) }
 end

data/spec/unit/axiom/optimizer/algebra/union/empty_right/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Union::EmptyRight, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation::Empty.new(header)                         }
-  let(:relation) { left.union(right)                                   }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation::Empty.new(header)                     }
+  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 equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/algebra/union/equal_operands/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Union::EqualOperands, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.union(right)                                   }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[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 equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/class_methods/chain_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Optimizer, '.chain' do
-  let(:operation)       { mock('Operation')    }
+  let(:operation)       { double('Operation')  }
   let(:object)          { Optimizer            }
   let(:identity)        { object::Identity     }
   let(:optimizer_class) { Class.new(Optimizer) }
@@ -11,17 +11,17 @@ describe Optimizer, '.chain' do
   context 'with no optimizers' do
     subject { object.chain }
 
-    it { should equal(identity) }
+    it { should be(identity) }
 
     it 'returns a block that returns the operation' do
-      subject.call(operation).should equal(operation)
+      expect(subject.call(operation)).to be(operation)
     end
   end
 
   context 'with an optimizer that can optimize the operation' do
     subject { object.chain(optimizer_class) }
 
-    let(:optimized) { mock('Optimized') }
+    let(:optimized) { double('Optimized') }
 
     before do
       optimized = self.optimized
@@ -29,12 +29,12 @@ describe Optimizer, '.chain' do
       optimizer_class.send(:define_method, :optimize)     { optimized }
     end
 
-    it { should_not equal(identity) }
+    it { should_not be(identity) }
 
     it { should be_kind_of(Proc) }
 
     it 'returns a block that optimizes the operation' do
-      subject.call(operation).should equal(optimized)
+      expect(subject.call(operation)).to be(optimized)
     end
   end
 
@@ -45,12 +45,12 @@ describe Optimizer, '.chain' do
       optimizer_class.send(:define_method, :optimizable?) { false }
     end
 
-    it { should_not equal(identity) }
+    it { should_not be(identity) }
 
     it { should be_kind_of(Proc) }
 
     it 'returns a block that calls the successor (Identity) with the operation' do
-      subject.call(operation).should equal(operation)
+      expect(subject.call(operation)).to be(operation)
     end
   end
 end