axiom-optimizer 0.1.0 → 0.1.1

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

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Algebra::Rename, '#optimize' do
   subject { object.optimize }
 
-  let(:body)     { LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])                   }
-  let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
-  let(:operand)  { relation                                                    }
-  let(:aliases)  { { :id => :other_id }                                        }
-  let(:object)   { described_class.new(operand, aliases)                       }
+  let(:body)     { LazyEnumerable.new([[1, 'Dan Kubb']])                 }
+  let(:relation) { Relation.new([[:id, Integer], [:name, String]], body) }
+  let(:operand)  { relation                                              }
+  let(:aliases)  { { id: :other_id }                                     }
+  let(:object)   { described_class.new(operand, aliases)                 }
 
   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)
@@ -42,15 +42,15 @@ describe Algebra::Rename, '#optimize' do
   context 'containing an optimizable relation' do
     let(:operand) { relation.project(relation.header) }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
     it 'sets aliases the same as the original object' do
-      subject.aliases.should == object.aliases
+      expect(subject.aliases).to eql(object.aliases)
     end
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -65,22 +65,22 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a object operation' do
-    let(:operand) { described_class.new(relation, :id => :other_id) }
-    let(:aliases) { { :name => :other_name }                        }
+    let(:operand) { described_class.new(relation, id: :other_id) }
+    let(:aliases) { { name: :other_name }                        }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
     it 'sets aliases as a union of both aliases' do
-      subject.aliases.should == described_class::Aliases.coerce(
+      expect(subject.aliases).to eql(described_class::Aliases.coerce(
         relation.header,
-        :id   => :other_id,
-        :name => :other_name
-      )
+        id:   :other_id,
+        name: :other_name
+      ))
     end
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -95,21 +95,21 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a object operation with overlapping aliases' do
-    let(:operand) { described_class.new(relation, :id => :other_id) }
-    let(:aliases) { { :other_id => :another_id }                    }
+    let(:operand) { described_class.new(relation, id: :other_id) }
+    let(:aliases) { { other_id: :another_id }                    }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
     it 'sets aliases as a union of both aliases' do
-      subject.aliases.should == described_class::Aliases.coerce(
+      expect(subject.aliases).to eql(described_class::Aliases.coerce(
         relation.header,
-        :id => :another_id
-      )
+        id: :another_id
+      ))
     end
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -124,10 +124,10 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an inverse object operation' do
-    let(:operand) { described_class.new(relation, :id => :other_id) }
-    let(:aliases) { { :other_id => :id }                            }
+    let(:operand) { described_class.new(relation, id: :other_id) }
+    let(:aliases) { { other_id: :id }                            }
 
-    it { should equal(relation) }
+    it { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -142,13 +142,13 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a projection' do
-    let(:operand) { relation.project([ :id ]) }
+    let(:operand) { relation.project([:id]) }
 
     it { should be_kind_of(Algebra::Projection) }
 
     its(:operand) { should eql(described_class.new(relation, aliases)) }
 
-    its(:header) { should == [ [ :other_id, Integer ] ] }
+    its(:header) { should == [[:other_id, Integer]] }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -163,11 +163,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a projection, containing a object that cancels out' do
-    let(:operand) { relation.rename(:id => :other_id).project([ :other_id ]) }
-    let(:aliases) { { :other_id => :id }                                     }
+    let(:operand) { relation.rename(id: :other_id).project([:other_id]) }
+    let(:aliases) { { other_id: :id }                                   }
 
     it 'pushes the object before the projection, and then cancel it out' do
-      should eql(relation.project([ :id ]))
+      should eql(relation.project([:id]))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -189,7 +189,7 @@ describe Algebra::Rename, '#optimize' do
 
     its(:operand) { should eql(described_class.new(relation, aliases)) }
 
-    its(:header) { should == [ [ :other_id, Integer ], [ :name, String ] ] }
+    its(:header) { should == [[:other_id, Integer], [:name, String]] }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -204,8 +204,8 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a restriction, containing a object that cancels out' do
-    let(:operand) { relation.rename(:id => :other_id).restrict { |r| r.other_id.eq(1) } }
-    let(:aliases) { { :other_id => :id }                                                }
+    let(:operand) { relation.rename(id: :other_id).restrict { |r| r.other_id.eq(1) } }
+    let(:aliases) { { other_id: :id }                                                }
 
     it 'pushes the object before the restriction, and then cancel it out' do
       should eql(relation.restrict { |r| r.id.eq(1) })
@@ -224,9 +224,9 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a set operation' do
-    let(:left)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right)   { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-    let(:operand) { left.union(right)                                                                                }
+    let(:left)    { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right)   { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+    let(:operand) { left.union(right)                                                                      }
 
     it 'pushes the object to each relation' do
       should eql(left.rename(aliases).union(right.rename(aliases)))
@@ -245,10 +245,10 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a set operation, containing a object that cancels out' do
-    let(:left)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right)   { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-    let(:operand) { left.rename(:id => :other_id).union(right.rename(:id => :other_id))                              }
-    let(:aliases) { { :other_id => :id }                                                                             }
+    let(:left)    { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right)   { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+    let(:operand) { left.rename(id: :other_id).union(right.rename(id: :other_id))                          }
+    let(:aliases) { { other_id: :id }                                                                      }
 
     it 'pushes the object to each relation, then cancel it out' do
       should eql(left.union(right))
@@ -267,11 +267,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a reverse operation' do
-    let(:limit)   { relation.sort_by { |r| [ r.id, r.name ] }.take(2) }
-    let(:operand) { limit.reverse                                     }
+    let(:limit)   { relation.sort_by { |r| [r.id, r.name] }.take(2) }
+    let(:operand) { limit.reverse                                   }
 
     it 'pushes the object under the order, limit and reverse' do
-      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.take(2).reverse)
+      should eql(relation.rename(aliases).sort_by { |r| [r.other_id, r.name] }.take(2).reverse)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -287,12 +287,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a reverse operation, containing a object that cancels out' do
-    let(:limit)   { relation.sort_by { |r| [ r.id, r.name ] }.take(2) }
-    let(:operand) { limit.rename(:id => :other_id).reverse            }
-    let(:aliases) { { :other_id => :id }                              }
+    let(:limit)   { relation.sort_by { |r| [r.id, r.name] }.take(2) }
+    let(:operand) { limit.rename(id: :other_id).reverse             }
+    let(:aliases) { { other_id: :id }                               }
 
     it 'pushes the object under the order, limit and reverse, and then cancel it out' do
-      should eql(relation.sort_by { |r| [ r.id, r.name ] }.take(2).reverse)
+      should eql(relation.sort_by { |r| [r.id, r.name] }.take(2).reverse)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -308,10 +308,10 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an order operation' do
-    let(:operand) { relation.sort_by { |r| [ r.id, r.name ] } }
+    let(:operand) { relation.sort_by { |r| [r.id, r.name] } }
 
     it 'pushes the object under the order' do
-      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] })
+      should eql(relation.rename(aliases).sort_by { |r| [r.other_id, r.name] })
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -327,11 +327,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an order operation, containing a object that cancels out' do
-    let(:operand) { relation.rename(:id => :other_id).sort_by { |r| [ r.other_id, r.name ] } }
-    let(:aliases) { { :other_id => :id }                                                     }
+    let(:operand) { relation.rename(id: :other_id).sort_by { |r| [r.other_id, r.name] } }
+    let(:aliases) { { other_id: :id }                                                   }
 
     it 'pushes the object under the order, and then cancel it out' do
-      should eql(relation.sort_by { |r| [ r.id, r.name ] })
+      should eql(relation.sort_by { |r| [r.id, r.name] })
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -347,11 +347,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a limit operation' do
-    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
-    let(:operand) { order.take(2)                             }
+    let(:order)   { relation.sort_by { |r| [r.id, r.name] } }
+    let(:operand) { order.take(2)                           }
 
     it 'pushes the object under the limit and order' do
-      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.take(2))
+      should eql(relation.rename(aliases).sort_by { |r| [r.other_id, r.name] }.take(2))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -367,12 +367,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a limit operation, containing a object that cancels out' do
-    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
-    let(:operand) { order.rename(:id => :other_id).take(2)    }
-    let(:aliases) { { :other_id => :id }                      }
+    let(:order)   { relation.sort_by { |r| [r.id, r.name] } }
+    let(:operand) { order.rename(id: :other_id).take(2)     }
+    let(:aliases) { { other_id: :id }                       }
 
     it 'pushes the object under the limit and order, and then cancel it out' do
-      should eql(relation.sort_by { |r| [ r.id, r.name ] }.take(2))
+      should eql(relation.sort_by { |r| [r.id, r.name] }.take(2))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -388,11 +388,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an offset operation' do
-    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
-    let(:operand) { order.drop(1)                             }
+    let(:order)   { relation.sort_by { |r| [r.id, r.name] } }
+    let(:operand) { order.drop(1)                           }
 
     it 'pushes the object under the offset and order' do
-      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.drop(1))
+      should eql(relation.rename(aliases).sort_by { |r| [r.other_id, r.name] }.drop(1))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -408,12 +408,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an offset operation, containing a object that cancels out' do
-    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
-    let(:operand) { order.rename(:id => :other_id).drop(1)    }
-    let(:aliases) { { :other_id => :id }                      }
+    let(:order)   { relation.sort_by { |r| [r.id, r.name] } }
+    let(:operand) { order.rename(id: :other_id).drop(1)     }
+    let(:aliases) { { other_id: :id }                       }
 
     it 'pushes the object under the offset and order, and then cancel it out' do
-      should eql(relation.sort_by { |r| [ r.id, r.name ] }.drop(1))
+      should eql(relation.sort_by { |r| [r.id, r.name] }.drop(1))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -429,9 +429,9 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:operand) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+    let(:operand) { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']]) }
 
-    it { should eql(Relation::Materialized.new([ [ :other_id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ])) }
+    it { should eql(Relation::Materialized.new([[:other_id, Integer], [:name, String]], [[1, 'Dan Kubb']])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

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

@@ -1,19 +1,18 @@
 # encoding: utf-8
-
 require 'spec_helper'
 
 describe Algebra::Restriction, '#optimize' do
   subject { object.optimize }
 
-  let(:body)     { LazyEnumerable.new([ [ 1 ] ])            }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
-  let(:operand)  { relation                                 }
-  let(:object)   { described_class.new(operand, predicate)  }
+  let(:body)     { LazyEnumerable.new([[1]])               }
+  let(:relation) { Relation.new([[:id, Integer]], body)    }
+  let(:operand)  { relation                                }
+  let(:object)   { described_class.new(operand, predicate) }
 
   context 'with a tautology' do
     let(:predicate) { Function::Proposition::Tautology.instance }
 
-    it { should equal(relation) }
+    it { should be(relation) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -43,7 +42,7 @@ describe Algebra::Restriction, '#optimize' do
   context 'with a predicate' do
     let(:predicate) { relation[:id].eq(1) }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -56,13 +55,13 @@ describe Algebra::Restriction, '#optimize' do
   context 'with an optimizable predicate' do
     let(:predicate) { relation[:id].eq(1).and(Function::Proposition::Tautology.instance) }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
     its(:predicate) { should eql(relation[:id].eq(1)) }
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -80,13 +79,13 @@ describe Algebra::Restriction, '#optimize' do
     let(:operand)    { relation.project(relation.header) }
     let(:predicate)  { relation[:id].eq(1)               }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
-    its(:predicate) { should equal(predicate) }
+    its(:predicate) { should be(predicate) }
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -101,10 +100,10 @@ describe Algebra::Restriction, '#optimize' do
   end
 
   context 'with an empty relation' do
-    let(:operand)   { Relation::Empty.new([ [ :id, Integer ] ]) }
-    let(:predicate) { operand[:id].gte(1)                       }
+    let(:operand)   { Relation::Empty.new([[:id, Integer]]) }
+    let(:predicate) { operand[:id].gte(1)                   }
 
-    it { should equal(operand) }
+    it { should be(operand) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -141,13 +140,13 @@ describe Algebra::Restriction, '#optimize' do
     let(:operand)         { described_class.new(relation, other_predicate) }
     let(:predicate)       { operand[:id].gte(1)                            }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
     its(:predicate) { should eql(other_predicate & predicate) }
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -162,10 +161,10 @@ describe Algebra::Restriction, '#optimize' do
   end
 
   context 'with a set operation' do
-    let(:left)      { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-    let(:right)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 2 ] ])) }
-    let(:operand)   { left.union(right)                                                 }
-    let(:predicate) { operand[:id].gte(1)                                               }
+    let(:left)      { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+    let(:right)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[2]])) }
+    let(:operand)   { left.union(right)                                         }
+    let(:predicate) { operand[:id].gte(1)                                       }
 
     it 'pushes the object to each relation' do
       should eql(left.restrict { |r| r.id.gte(1) }.union(right.restrict { |r| r.id.gte(1) }))
@@ -204,10 +203,10 @@ describe Algebra::Restriction, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-    let(:predicate) { operand[:id].eq(1)                                   }
+    let(:operand)   { Relation.new([[:id, Integer]], [[1], [2]]) }
+    let(:predicate) { operand[:id].eq(1)                         }
 
-    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/algebra/summarization/optimize_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Summarization, '#optimize' do
   subject { object.optimize }
 
-  let(:header)        { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]           }
-  let(:body)          { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ], [ 2, 'Jane Doe', 24 ] ]) }
-  let(:relation)      { Relation.new(header, body)                                           }
-  let(:operand)       { relation                                                             }
-  let(:summarize_per) { relation.project([ :id ])                                            }
-  let(:summarizers)   { { Attribute.coerce(:count) => lambda { |acc, tuple| acc.to_i + 1 } } }
-  let(:object)        { described_class.new(operand, summarize_per, summarizers)             }
+  let(:header)        { [[:id, Integer], [:name, String], [:age, Integer]]              }
+  let(:body)          { LazyEnumerable.new([[1, 'Dan Kubb', 35], [2, 'Jane Doe', 24]])  }
+  let(:relation)      { Relation.new(header, body)                                      }
+  let(:operand)       { relation                                                        }
+  let(:summarize_per) { relation.project([:id])                                         }
+  let(:summarizers)   { { Attribute.coerce(:count) => ->(acc, tuple) { acc.to_i + 1 } } }
+  let(:object)        { described_class.new(operand, summarize_per, summarizers)        }
 
   context 'when the operand is empty' do
     let(:operand) { relation.restrict { false } }
@@ -31,7 +31,7 @@ describe Algebra::Summarization, '#optimize' do
   end
 
   context 'when the summarize_per is empty' do
-    let(:summarize_per) { relation.project([ :id ]).restrict { false } }
+    let(:summarize_per) { relation.project([:id]).restrict { false } }
 
     it { should eql(Relation::Empty.new(object.header)) }