veritas 0.0.2 → 0.0.3

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Algebra::Summarization::UnoptimizedOperand#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)       { Optimizer::Algebra::Summarization::UnoptimizedOperand  }
-  let(:header)      { Relation::Header.new([ [ :id, Integer ] ])             }
-  let(:base)        { Relation.new(header, [ [ 1 ] ].each)                   }
-  let(:summarizers) { [ :text, lambda { |acc, tuple| 1 } ]                   }
-  let(:relation)    { operand.summarize(operand) { |r| r.add(*summarizers) } }
-  let(:object)      { klass.new(relation)                                    }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Summarization)
-  end
-
-  context 'when the operand is optimizable' do
-    let(:operand) { base.rename({}) }
-
-    it { should be(true) }
-  end
-
-  context 'when the operand is not optimizable' do
-    let(:operand) { base }
-
-    it { should be(false) }
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Algebra::Summarization::UnoptimizedOperand#optimize' do
-  subject { object.optimize }
-
-  let(:klass)     { Optimizer::Algebra::Summarization::UnoptimizedOperand         }
-  let(:header)    { Relation::Header.new([ [ :id, Integer ] ])                    }
-  let(:base)      { Relation.new(header, [ [ 1 ] ].each)                          }
-  let(:attribute) { Attribute::Object.new(:text)                                  }
-  let(:function)  { lambda { |acc, tuple| 1 }                                     }
-  let(:operand)   { base.rename({})                                               }
-  let(:relation)  { operand.summarize(operand) { |r| r.add(attribute, function) } }
-  let(:object)    { klass.new(relation)                                           }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Summarization)
-  end
-
-  it { should be_kind_of(Algebra::Summarization) }
-
-  it { should_not equal(operand) }
-
-  its(:operand) { should equal(base) }
-
-  its(:summarize_by) { should equal(operand) }
-
-  its(:summarizers) { should == { attribute => function } }
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Algebra::Union::EmptyLeft#optimize' do
-  subject { object.optimize }
-
-  let(:klass)    { Optimizer::Algebra::Union::EmptyLeft       }
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:left)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:right)    { Relation.new(header, [ [ 2 ] ].each)       }
-  let(:relation) { left.union(right)                          }
-  let(:object)   { klass.new(relation)                        }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Union)
-  end
-
-  it { should equal(right) }
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Algebra::Union::EmptyRight#optimize' do
-  subject { object.optimize }
-
-  let(:klass)    { Optimizer::Algebra::Union::EmptyRight      }
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:left)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:right)    { Relation.new(header, [ [ 2 ] ].each)       }
-  let(:relation) { left.union(right)                          }
-  let(:object)   { klass.new(relation)                        }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Union)
-  end
-
-  it { should equal(left) }
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Algebra::Union::EqualOperands#optimize' do
-  subject { object.optimize }
-
-  let(:klass)    { Optimizer::Algebra::Union::EqualOperands   }
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:left)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:right)    { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:relation) { left.union(right)                          }
-  let(:object)   { klass.new(relation)                        }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Union)
-  end
-
-  it { should equal(left) }
-end

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

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer.chain' do
-  let(:operation)       { mock('Operation')    }
-  let(:object)          { Optimizer            }
-  let(:noop)            { object::Noop         }
-  let(:optimizer_class) { Class.new(Optimizer) }
-
-  context 'with no optimizers' do
-    subject { object.chain }
-
-    it { should equal(noop) }
-
-    it 'returns a block that returns the operation' do
-      subject.call(operation).should equal(operation)
-    end
-  end
-
-  context 'with an optimizer that can optimize the operation' do
-    subject { object.chain(optimizer_class) }
-
-    let(:optimized) { mock('Optimized') }
-
-    before do
-      optimized = self.optimized
-      optimizer_class.send(:define_method, :optimizable?) { true      }
-      optimizer_class.send(:define_method, :optimize)     { optimized }
-    end
-
-    it { should_not equal(noop) }
-
-    it { should be_kind_of(Proc) }
-
-    it 'returns a block that optimizes the operation' do
-      subject.call(operation).should equal(optimized)
-    end
-  end
-
-  context 'with an optimizer that cannot optimize the operation' do
-    subject { object.chain(optimizer_class) }
-
-    before do
-      optimizer_class.send(:define_method, :optimizable?) { false }
-    end
-
-    it { should_not equal(noop) }
-
-    it { should be_kind_of(Proc) }
-
-    it 'returns a block that calls the successor (Noop) with the operation' do
-      subject.call(operation).should equal(operation)
-    end
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/equal_operands/optimizable_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::EqualOperands#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::EqualOperands }
-  let(:attribute)  { Attribute::Integer.new(:id)                         }
-  let(:connective) { left.and(right)                                     }
-  let(:object)     { klass.new(connective)                               }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  context 'when left and right are equivalent' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(1) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are not equivalent' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/equal_operands/optimize_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::EqualOperands#optimize' do
-  subject { object.optimize }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::EqualOperands }
-  let(:attribute)  { Attribute::Integer.new(:id)                         }
-  let(:left)       { attribute.eq(1)                                     }
-  let(:right)      { attribute.eq(1)                                     }
-  let(:connective) { left.and(right)                                     }
-  let(:object)     { klass.new(connective)                               }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  it { should equal(left) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/left_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary#left' do
-  subject { object.left }
-
-  let(:klass)           { Optimizer::Logic::Connective::Binary               }
-  let(:optimized_left)  { mock('Optimized Left')                             }
-  let(:optimized_right) { mock('Optimized Right')                            }
-  let(:left)            { mock('Left',  :optimize => optimized_left)         }
-  let(:right)           { mock('Right', :optimize => optimized_right)        }
-  let(:connective)      { mock('Connective', :left => left, :right => right) }
-  let(:object)          { klass.new(connective)                              }
-
-  it { should equal(optimized_left) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/redundant_left_operand/optimizable_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::RedundantLeftOperand#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::RedundantLeftOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                                }
-  let(:left)       { attribute.include([ 1 ])                                   }
-  let(:right)      { attribute.exclude([ 2 ])                                   }
-  let(:object)     { klass.new(connective)                                      }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  context 'when the left operand is redundant' do
-    let(:connective) { left.and(right).and(right) }
-
-    it { should be(true) }
-  end
-
-  context 'when the left operand is not redundant' do
-    let(:connective) { left.and(right) }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/redundant_left_operand/optimize_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::RedundantLeftOperand#optimize' do
-  subject { object.optimize }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::RedundantLeftOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                                }
-  let(:left)       { attribute.include([ 1 ])                                   }
-  let(:right)      { attribute.exclude([ 2 ])                                   }
-  let(:connective) { left.and(right).and(right)                                 }
-  let(:object)     { klass.new(connective)                                      }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  it { should be_kind_of(Logic::Connective::Conjunction) }
-
-  its(:left) { should eql(attribute.eq(1)) }
-
-  its(:right) { should eql(attribute.ne(2)) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/redundant_right_operand/optimizable_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::RedundantRightOperand#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::RedundantRightOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:left)       { attribute.include([ 1 ])                                    }
-  let(:right)      { attribute.exclude([ 2 ])                                    }
-  let(:object)     { klass.new(connective)                                       }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  context 'when the right operand is redundant' do
-    let(:connective) { left.and(left.and(right)) }
-
-    it { should be(true) }
-  end
-
-  context 'when the right operand is not redundant' do
-    let(:connective) { left.and(right) }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/redundant_right_operand/optimize_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::RedundantRightOperand#optimize' do
-  subject { object.optimize }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::RedundantRightOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:left)       { attribute.include([ 1 ])                                    }
-  let(:right)      { attribute.exclude([ 2 ])                                    }
-  let(:connective) { left.and(left.and(right))                                   }
-  let(:object)     { klass.new(connective)                                       }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  it { should be_kind_of(Logic::Connective::Conjunction) }
-
-  its(:left) { should eql(attribute.eq(1)) }
-
-  its(:right) { should eql(attribute.ne(2)) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/right_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary#right' do
-  subject { object.right }
-
-  let(:klass)           { Optimizer::Logic::Connective::Binary               }
-  let(:optimized_left)  { mock('Optimized Left')                             }
-  let(:optimized_right) { mock('Optimized Right')                            }
-  let(:left)            { mock('Left',  :optimize => optimized_left)         }
-  let(:right)           { mock('Right', :optimize => optimized_right)        }
-  let(:connective)      { mock('Connective', :left => left, :right => right) }
-  let(:object)          { klass.new(connective)                              }
-
-  it { should equal(optimized_right) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/unoptimized_operand/optimizable_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::UnoptimizedOperand#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::UnoptimizedOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                              }
-  let(:connective) { left.and(right)                                          }
-  let(:object)     { klass.new(connective)                                    }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  context 'when left is optimizable' do
-    let(:left)  { attribute.include([ 1 ]) }
-    let(:right) { attribute.ne(2)          }
-
-    it { should be(true) }
-  end
-
-  context 'when right is optimizable' do
-    let(:left)  { attribute.eq(1)          }
-    let(:right) { attribute.exclude([ 2 ]) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are not optimizable' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(2) }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/unoptimized_operand/optimize_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Binary::UnoptimizedOperand#optimize' do
-  subject { object.optimize }
-
-  let(:klass)      { Optimizer::Logic::Connective::Binary::UnoptimizedOperand }
-  let(:attribute)  { Attribute::Integer.new(:id)                              }
-  let(:left)       { attribute.include([ 1 ])                                 }
-  let(:right)      { attribute.exclude([ 2 ])                                 }
-  let(:connective) { left.and(right)                                          }
-  let(:object)     { klass.new(connective)                                    }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  it { should be_kind_of(Logic::Connective::Conjunction) }
-
-  its(:left) { should eql(attribute.eq(1)) }
-
-  its(:right) { should eql(attribute.ne(2)) }
-end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/always_false/optimizable_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe 'Veritas::Optimizer::Logic::Connective::Conjunction::AlwaysFalse#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:klass)      { Optimizer::Logic::Connective::Conjunction::AlwaysFalse }
-  let(:attribute)  { Attribute::Integer.new(:id)                            }
-  let(:connective) { Logic::Connective::Conjunction.new(left, right)        }
-  let(:object)     { klass.new(connective)                                  }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Conjunction)
-  end
-
-  context 'when left is false' do
-    let(:left)  { Logic::Proposition::False.instance }
-    let(:right) { attribute.eq(1)                    }
-
-    it { should be(true) }
-  end
-
-  context 'when right is false' do
-    let(:left)  { attribute.eq(1)                    }
-    let(:right) { Logic::Proposition::False.instance }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are equality predicates with the same attribute and constant values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(2) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are inverses' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-
-    it { should be(true) }
-  end
-end