veritas-optimizer 0.0.3 → 0.0.4

data/spec/integration/veritas/{logic → function}/predicate/inequality/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inequality, '#optimize' do
+describe Function::Predicate::Inequality, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)      }
@@ -10,7 +12,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
     context 'and are not joinable' do
       let(:right) { Attribute::String.new(:other) }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -44,7 +46,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
     context 'right is an invalid value' do
       let(:right) { 'a' }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -62,7 +64,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
     context 'left is an invalid value' do
       let(:left) { 'a' }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -73,7 +75,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -82,7 +84,7 @@ describe Logic::Predicate::Inequality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/veritas/{logic → function}/predicate/less_than/optimize_spec.rb

@@ -1,16 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::LessThan, '#optimize' do
+describe Function::Predicate::LessThan, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
-  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(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -27,7 +29,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
       let(:left)  { attribute                                             }
       let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -36,7 +38,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
       let(:left)  { attribute                                     }
       let(:right) { Attribute::Integer.new(:right, :size => 0..0) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -44,7 +46,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
 
   context 'left is an attribute' do
     context 'right is a valid value' do
-      let(:right) { 1 }
+      let(:right) { 2 }
 
       it { should equal(object) }
 
@@ -54,7 +56,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -64,7 +66,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
     context 'left is a valid value' do
       let(:left) { 1 }
 
-      it { should eql(Logic::Predicate::GreaterThan.new(attribute, 1)) }
+      it { should eql(Function::Predicate::GreaterThan.new(attribute, 1)) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -72,7 +74,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -92,7 +94,7 @@ describe Logic::Predicate::LessThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/veritas/{logic → function}/predicate/less_than_or_equal_to/optimize_spec.rb

@@ -1,16 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
+describe Function::Predicate::LessThanOrEqualTo, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
-  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(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -27,7 +29,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { attribute                                             }
       let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -36,7 +38,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { attribute                                       }
       let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -54,7 +56,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -62,9 +64,9 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
 
   context 'right is an attribute' do
     context 'left is a valid value' do
-      let(:left) { 1 }
+      let(:left) { 2 }
 
-      it { should eql(Logic::Predicate::GreaterThanOrEqualTo.new(attribute, 1)) }
+      it { should eql(Function::Predicate::GreaterThanOrEqualTo.new(attribute, 2)) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -72,7 +74,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -92,7 +94,7 @@ describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
       let(:left)  { 2 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Empty, '#optimize' do

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Materialized, '#optimize' do

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Operation::Limit, '#optimize' do
@@ -6,7 +8,7 @@ describe Relation::Operation::Limit, '#optimize' do
   let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
   let(:directions) { [ relation[:id] ]                        }
-  let(:order)      { relation.order(directions)               }
+  let(:order)      { relation.order { directions }            }
   let(:operand)    { order                                    }
   let(:limit)      { 1                                        }
   let(:object)     { described_class.new(operand, limit)      }

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Operation::Offset, '#optimize' do
@@ -6,7 +8,7 @@ describe Relation::Operation::Offset, '#optimize' do
   let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
   let(:directions) { [ relation[:id] ]                        }
-  let(:order)      { relation.order(directions)               }
+  let(:order)      { relation.order { directions }            }
   let(:operand)    { order                                    }
   let(:offset)     { 1                                        }
   let(:object)     { described_class.new(operand, offset)     }

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Operation::Order, '#optimize' do
@@ -23,7 +25,7 @@ describe Relation::Operation::Order, '#optimize' do
   context 'containing an optimizable relation' do
     let(:operand) { relation.project(relation.header) }
 
-    it { should eql(relation.order(directions)) }
+    it { should eql(relation.order { directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -40,7 +42,7 @@ describe Relation::Operation::Order, '#optimize' do
   context 'containing an object operation' do
     let(:operand) { relation.order { |r| [ r[:id].desc ] } }
 
-    it { should eql(relation.order(directions)) }
+    it { should eql(relation.order { directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/veritas/relation/operation/reverse/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation::Operation::Reverse, '#optimize' do
@@ -50,7 +52,7 @@ describe Relation::Operation::Reverse, '#optimize' do
   end
 
   context 'with an order operation' do
-    it { should eql(relation.order(object.directions)) }
+    it { should eql(relation.order { object.directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -67,7 +69,7 @@ describe Relation::Operation::Reverse, '#optimize' do
   context 'with an order operation when optimized' do
     let(:operand) { order.rename({}) }
 
-    it { should eql(relation.order(object.directions)) }
+    it { should eql(relation.order { object.directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/veritas/relation/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Relation, '#optimize' do

data/spec/shared/{logic_connective_binary_optimize_behavior.rb → function_connective_binary_optimize_behavior.rb}

@@ -1,4 +1,6 @@
-shared_examples_for 'Logic::Connective::Binary#optimize' do
+# encoding: utf-8
+
+shared_examples_for 'Function::Connective::Binary#optimize' do
   context 'left and right are the same' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.gt(1) }
@@ -9,9 +11,9 @@ shared_examples_for 'Logic::Connective::Binary#optimize' do
   end
 
   context 'left and right are the same, after optimizing the left' do
-    let(:original_left) { attribute.gt(1)                                           }
-    let(:left)          { original_left.and(Logic::Proposition::Tautology.instance) }
-    let(:right)         { attribute.gt(1)                                           }
+    let(:original_left) { attribute.gt(1)                                              }
+    let(:left)          { original_left.and(Function::Proposition::Tautology.instance) }
+    let(:right)         { attribute.gt(1)                                              }
 
     it { should equal(original_left) }
 
@@ -19,8 +21,8 @@ shared_examples_for 'Logic::Connective::Binary#optimize' do
   end
 
   context 'left and right are the same, after optimizing the right' do
-    let(:left)  { attribute.gt(1)                                             }
-    let(:right) { attribute.gt(1).and(Logic::Proposition::Tautology.instance) }
+    let(:left)  { attribute.gt(1)                                                }
+    let(:right) { attribute.gt(1).and(Function::Proposition::Tautology.instance) }
 
     it { should equal(left) }
 
@@ -37,9 +39,9 @@ shared_examples_for 'Logic::Connective::Binary#optimize' do
   end
 
   context 'left and right are different, after optimizing the left' do
-    let(:original_left) { attribute.gt(1)                                           }
-    let(:left)          { original_left.and(Logic::Proposition::Tautology.instance) }
-    let(:right)         { attribute.lt(1)                                           }
+    let(:original_left) { attribute.gt(1)                                              }
+    let(:left)          { original_left.and(Function::Proposition::Tautology.instance) }
+    let(:right)         { attribute.lt(1)                                              }
 
     add_method_missing
 
@@ -55,9 +57,9 @@ shared_examples_for 'Logic::Connective::Binary#optimize' do
   end
 
   context 'left and right are different, after optimizing the right' do
-    let(:original_right) { attribute.lt(1)                                            }
-    let(:left)           { attribute.gt(1)                                            }
-    let(:right)          { original_right.and(Logic::Proposition::Tautology.instance) }
+    let(:original_right) { attribute.lt(1)                                               }
+    let(:left)           { attribute.gt(1)                                               }
+    let(:right)          { original_right.and(Function::Proposition::Tautology.instance) }
 
     add_method_missing
 

data/spec/shared/idempotent_method_behavior.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 shared_examples_for 'an idempotent method' do
   it 'is idempotent' do
     should equal(instance_eval(&self.class.subject))

data/spec/shared/optimize_method_behavior.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 shared_examples_for 'an optimize method' do
   it_should_behave_like 'an idempotent method'
 

data/spec/support/add_method_missing.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module AddMethodMissing
   def add_method_missing(name = :described_class)
     before do

data/spec/unit/veritas/optimizer/algebra/difference/empty_left/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Difference::EmptyLeft, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/difference/empty_right/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Difference::EmptyRight, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/difference/equal_operands/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Difference::EqualOperands, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/extension/extensions_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension, '#extensions' do
+  subject { object.extensions }
+
+  let(:base)          { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])  }
+  let(:attribute)     { Attribute::Object.new(:test)                   }
+  let(:summarize_per) { TABLE_DEE                                      }
+  let(:relation)      { base.extend { |r| r.add(attribute, function) } }
+  let(:object)        { described_class.new(relation)                  }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Extension)
+  end
+
+  context 'when extensions are optimized' do
+    let(:function) { 1 }
+
+    it { should eql(relation.extensions) }
+  end
+
+  context 'when extensions are not optimized' do
+    let(:function) { Function::Numeric::Absolute.new(1) }
+
+    it { should_not equal(relation.extensions) }
+
+    it { should eql(attribute => 1) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/extension/order_operand/optimizable_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
+  let(:relation) { operand.extend {}                           }
+  let(:object)   { described_class.new(relation)               }
+
+  context 'when operand is an order' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when operand is not an order' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/extension/order_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
+  let(:operand)  { base.order                                  }
+  let(:relation) { operand.extend {}                           }
+  let(:object)   { described_class.new(relation)               }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Extension) }
+
+  its(:operand) { should equal(base) }
+
+  its(:extensions) { should eql(relation.extensions) }
+end

data/spec/unit/veritas/optimizer/algebra/extension/unoptimized_operand/optimizable_spec.rb

@@ -1,26 +1,36 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)     { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:base)       { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:extensions) { [ :text, lambda { |tuple| 1 } ]            }
-  let(:relation)   { operand.extend { |r| r.add(*extensions) }  }
-  let(:object)     { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:relation) { operand.extend { |r| r.add(*extensions) }  }
+  let(:object)   { described_class.new(relation)              }
 
   before do
     object.operation.should be_kind_of(Algebra::Extension)
   end
 
   context 'when the operand is optimizable' do
-    let(:operand) { base.rename({}) }
+    let(:operand)    { base.rename({}) }
+    let(:extensions) { [ :text, 1 ]    }
+
+    it { should be(true) }
+  end
+
+  context 'when the extensions are optimizable' do
+    let(:operand)    { base                                          }
+    let(:extensions) { [ :text, Function::Numeric::Absolute.new(1) ] }
 
     it { should be(true) }
   end
 
-  context 'when the operand is not optimizable' do
-    let(:operand) { base }
+  context 'when the operand and extensions are not optimizable' do
+    let(:operand)    { base         }
+    let(:extensions) { [ :text, 1 ] }
 
     it { should be(false) }
   end

data/spec/unit/veritas/optimizer/algebra/extension/unoptimized_operand/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimize' do
@@ -6,7 +8,7 @@ describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimize' do
   let(:header)    { Relation::Header.new([ [ :id, Integer ] ])        }
   let(:base)      { Relation.new(header, [ [ 1 ] ].each)              }
   let(:attribute) { Attribute::Object.new(:text)                      }
-  let(:function)  { lambda { |tuple| 1 }                              }
+  let(:function)  { Function::Numeric::Absolute.new(1)                }
   let(:operand)   { base.rename({})                                   }
   let(:relation)  { operand.extend { |r| r.add(attribute, function) } }
   let(:object)    { described_class.new(relation)                     }
@@ -21,5 +23,5 @@ describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimize' do
 
   its(:operand) { should equal(base) }
 
-  its(:extensions) { should == { attribute => function } }
+  its(:extensions) { should == { attribute => 1 } }
 end

data/spec/unit/veritas/optimizer/algebra/intersection/empty_left/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Intersection::EmptyLeft, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/intersection/empty_right/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Intersection::EmptyRight, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/intersection/equal_operands/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Intersection::EqualOperands, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/join/equal_headers/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Join::EqualHeaders, '#optimizable?' do

data/spec/unit/veritas/optimizer/algebra/join/equal_headers/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Join::EqualHeaders, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/product/table_dee_left/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Product::TableDeeLeft, '#optimizable?' do