axiom-optimizer 0.1.0 → 0.1.1

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

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

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

@@ -5,18 +5,16 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::EmptyOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation::Empty.new(header)                                      }
-  let(:relation) { base.project([ :id ])                                            }
-  let(:object)   { described_class.new(relation)                                    }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:base)     { Relation::Empty.new(header)                                }
+  let(:relation) { base.project([:id])                                        }
+  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(relation.header) }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should be(relation.header) }
 end

data/spec/unit/axiom/optimizer/algebra/projection/extension_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::ExtensionOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ]))                 }
-  let(:relation) { operand.project([ :id, :name ])                                                     }
-  let(:object)   { described_class.new(relation)                                                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String], [:age, Integer]]) }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]]))             }
+  let(:relation) { operand.project([:id, :name])                                               }
+  let(:object)   { described_class.new(relation)                                               }
 
   before do
-    object.operation.should be_kind_of(Algebra::Projection)
+    expect(object.operation).to be_kind_of(Algebra::Projection)
   end
 
   context 'when the operand is an extension, and the extended attribtue is removed ' do
@@ -22,7 +22,7 @@ describe Optimizer::Algebra::Projection::ExtensionOperand, '#optimizable?' do
 
   context 'when the operand is an extension, and the extended attribtue is not removed ' do
     let(:operand)  { base.extend { |r| r.add(:active, true) } }
-    let(:relation) { operand.project([ :id, :name, :active ]) }
+    let(:relation) { operand.project([:id, :name, :active])   }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/projection/extension_operand/optimize_spec.rb

@@ -5,18 +5,24 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::ExtensionOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ])          }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ]))                          }
-  let(:relation) { base.extend { |r| r.add(:subscriber, true); r.add(:active, true) }.project([ :id, :active ]) }
-  let(:object)   { described_class.new(relation)                                                                }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String], [:age, Integer]]) }
+  let(:base)   { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]]))             }
+  let(:object) { described_class.new(relation)                                               }
+
+  let(:relation) do
+    base.extend do |relation|
+      relation.add(:subscriber, true)
+      relation.add(:active, true)
+    end.project([:id, :active])
+  end
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Projection) }
 
   its(:operand) { should eql(base.extend { |r| r.add(:active, true) }) }
 
-  its(:header) { should == [ header[:id], Attribute::Boolean.new(:active) ] }
+  its(:header) { should == [header[:id], Attribute::Boolean.new(:active)] }
 end

data/spec/unit/axiom/optimizer/algebra/projection/projection_operand/optimizable_predicate_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::ProjectionOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ]))                 }
-  let(:relation) { operand.project([ :id ])                                                            }
-  let(:object)   { described_class.new(relation)                                                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String], [:age, Integer]]) }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]]))             }
+  let(:relation) { operand.project([:id])                                                      }
+  let(:object)   { described_class.new(relation)                                               }
 
   before do
-    object.operation.should be_kind_of(Algebra::Projection)
+    expect(object.operation).to be_kind_of(Algebra::Projection)
   end
 
   context 'when the operand is a projection' do
-    let(:operand) { base.project([ :id, :name ]) }
+    let(:operand) { base.project([:id, :name]) }
 
     it { should be(true) }
   end

data/spec/unit/axiom/optimizer/algebra/projection/projection_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::ProjectionOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ]))                 }
-  let(:relation) { base.project([ :id, :name ]).project([ :id ])                                       }
-  let(:object)   { described_class.new(relation)                                                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String], [:age, Integer]]) }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]]))             }
+  let(:relation) { base.project([:id, :name]).project([:id])                                   }
+  let(:object)   { described_class.new(relation)                                               }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Projection) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
-  its(:header) { should == [ header[:id] ] }
+  its(:header) { should == [header[:id]] }
 end

data/spec/unit/axiom/optimizer/algebra/projection/union_operand/optimizable_predicate_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::UnionOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ])    }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ])) }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 2, 'Dan Kubb', 35 ] ])) }
-  let(:relation) { operand.project([ :id ])                                            }
-  let(:object)   { described_class.new(relation)                                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer], [:name, String]])      }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[2, 'Dan Kubb', 35]])) }
+  let(:relation) { operand.project([:id])                                          }
+  let(:object)   { described_class.new(relation)                                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Projection)
+    expect(object.operation).to be_kind_of(Algebra::Projection)
   end
 
   context 'when the operand is a set operation' do

data/spec/unit/axiom/optimizer/algebra/projection/union_operand/optimize_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::UnionOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)     { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
-  let(:base_left)  { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ]))                 }
-  let(:base_right) { Relation.new(header, LazyEnumerable.new([ [ 2, 'Dan Kubb', 35 ] ]))                 }
-  let(:left)       { base_left.rename({})                                                                }
-  let(:right)      { base_right.rename({})                                                               }
-  let(:relation)   { left.union(right).project([ :id ])                                                  }
-  let(:object)     { described_class.new(relation)                                                       }
+  let(:header)     { Relation::Header.coerce([[:id, Integer], [:name, String], [:age, Integer]]) }
+  let(:base_left)  { Relation.new(header, LazyEnumerable.new([[1, 'Dan Kubb', 35]]))             }
+  let(:base_right) { Relation.new(header, LazyEnumerable.new([[2, 'Dan Kubb', 35]]))             }
+  let(:left)       { base_left.rename({})                                                        }
+  let(:right)      { base_right.rename({})                                                       }
+  let(:relation)   { left.union(right).project([:id])                                            }
+  let(:object)     { described_class.new(relation)                                               }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Union) }
 
-  its(:left) { should eql(base_left.project([ :id ])) }
+  its(:left) { should eql(base_left.project([:id])) }
 
-  its(:right) { should eql(base_right.project([ :id ])) }
+  its(:right) { should eql(base_right.project([:id])) }
 end

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::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(:relation) { operand.project([ :id ])                                         }
-  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.project([:id])                                      }
+  let(:object)   { described_class.new(relation)                               }
 
   before do
-    object.operation.should be_kind_of(Algebra::Projection)
+    expect(object.operation).to be_kind_of(Algebra::Projection)
   end
 
   context 'when the operand is optimizable' do

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

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Projection::UnoptimizedOperand, '#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(:relation) { base.restrict { Function::Proposition::Tautology.instance }.project([ :id ]) }
-  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) { base.restrict { Function::Proposition::Tautology.instance }.project([:id]) }
+  let(:object)   { described_class.new(relation)                                              }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Projection) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
-  its(:header) { should == [ header[:id] ] }
+  its(:header) { should == [header[:id]] }
 end

data/spec/unit/axiom/optimizer/algebra/rename/aliases_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename, '#aliases' do
   subject { object.aliases }
 
-  let(:attribute) { Attribute::Integer.new(:id)                         }
-  let(:header)    { Relation::Header.new([ attribute ])                 }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:aliases)   { { :id => :other_id }                                }
-  let(:object)    { described_class.new(relation)                       }
+  let(:attribute) { Attribute::Integer.new(:id)                     }
+  let(:header)    { Relation::Header.new([attribute])               }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:aliases)   { { id: :other_id }                               }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Rename)
+    expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
   let(:relation) { base.rename(aliases) }
 
   it { should be_kind_of(Algebra::Rename::Aliases) }
 
-  it { should equal(relation.aliases) }
+  it { should be(relation.aliases) }
 end

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

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::EmptyOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:relation) { operand.rename(:id => :other_id)              }
-  let(:object)   { described_class.new(relation)                 }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]]) }
+  let(:relation) { operand.rename(id: :other_id)             }
+  let(:object)   { described_class.new(relation)             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Rename)
+    expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
   context 'when the operand is an empty relation' do
@@ -20,7 +20,7 @@ describe Optimizer::Algebra::Rename::EmptyOperand, '#optimizable?' do
   end
 
   context 'when the operand is not an empty relation' do
-    let(:operand) { Relation.new(header, [ [ 1 ] ]) }
+    let(:operand) { Relation.new(header, [[1]]) }
 
     it { should be(false) }
   end

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

@@ -5,17 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::EmptyOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:operand)  { Relation::Empty.new([ [ :id, Integer ] ]) }
-  let(:relation) { operand.rename(:id => :other_id)          }
-  let(:object)   { described_class.new(relation)             }
+  let(:operand)  { Relation::Empty.new([[:id, Integer]]) }
+  let(:relation) { operand.rename(id: :other_id)         }
+  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(relation.header) }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should be(relation.header) }
 end

data/spec/unit/axiom/optimizer/algebra/rename/limit_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::LimitOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:aliases)  { { :id => :other_id }                                              }
-  let(:relation) { operand.rename(aliases)                                           }
-  let(:object)   { described_class.new(relation)                                     }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:aliases)  { { id: :other_id }                                         }
+  let(:relation) { operand.rename(aliases)                                   }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Rename)
+    expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
   context 'when the operand is an limit operation' do

data/spec/unit/axiom/optimizer/algebra/rename/limit_operand/optimize_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::LimitOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:order)    { base.sort_by { |r| r.id }                           }
-  let(:relation) { order.take(2).rename(:id => :other_id)              }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:order)    { base.sort_by { |r| r.id }                       }
+  let(:relation) { order.take(2).rename(id: :other_id)             }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Operation::Limit) }
 
-  its(:operand) { should eql(order.rename(:id => :other_id)) }
+  its(:operand) { should eql(order.rename(id: :other_id)) }
 
   its(:limit) { should == 2 }
 end

data/spec/unit/axiom/optimizer/algebra/rename/offset_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::OffsetOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:aliases)  { { :id => :other_id }                                              }
-  let(:relation) { operand.rename(aliases)                                           }
-  let(:object)   { described_class.new(relation)                                     }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:aliases)  { { id: :other_id }                                         }
+  let(:relation) { operand.rename(aliases)                                   }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Rename)
+    expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
   context 'when the operand is an offset operation' do

data/spec/unit/axiom/optimizer/algebra/rename/offset_operand/optimize_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::OffsetOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:order)    { base.sort_by { |r| r.id }                           }
-  let(:relation) { order.drop(1).rename(:id => :other_id)              }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:order)    { base.sort_by { |r| r.id }                       }
+  let(:relation) { order.drop(1).rename(id: :other_id)             }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Operation::Offset) }
 
-  its(:operand) { should eql(order.rename(:id => :other_id)) }
+  its(:operand) { should eql(order.rename(id: :other_id)) }
 
   its(:offset) { should == 1 }
 end

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Rename::OrderOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:aliases)  { { :id => :other_id }                                              }
-  let(:relation) { operand.rename(aliases)                                           }
-  let(:object)   { described_class.new(relation)                                     }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:aliases)  { { id: :other_id }                                         }
+  let(:relation) { operand.rename(aliases)                                   }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Rename)
+    expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
   context 'when the operand is an order operation' do