veritas-optimizer 0.0.3

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe 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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::EqualOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.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

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

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary, '#left' do
+  subject { object.left }
+
+  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)          { described_class.new(connective)                    }
+
+  it { should equal(optimized_left) }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:left)       { attribute.include([ 1 ])        }
+  let(:right)      { attribute.exclude([ 2 ])        }
+  let(:object)     { described_class.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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimize' do
+  subject { object.optimize }
+
+  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)     { described_class.new(connective) }
+
+  before do
+    object.should be_optimizable
+  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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)     }
+  let(:left)      { attribute.include([ 1 ])        }
+  let(:right)     { attribute.exclude([ 2 ])        }
+  let(:object)    { described_class.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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimize' do
+  subject { object.optimize }
+
+  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)     { described_class.new(connective) }
+
+  before do
+    object.should be_optimizable
+  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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary, '#right' do
+  subject { object.right }
+
+  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)          { described_class.new(connective)                    }
+
+  it { should equal(optimized_right) }
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Binary::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:left)       { attribute.include([ 1 ])        }
+  let(:right)      { attribute.exclude([ 2 ])        }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.should be_optimizable
+  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/contradiction/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+  end
+
+  context 'when left is a contradiction' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { attribute.eq(1)                            }
+
+    it { should be(true) }
+  end
+
+  context 'when right is a contradiction' do
+    let(:left)  { attribute.eq(1)                            }
+    let(:right) { Logic::Proposition::Contradiction.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

data/spec/unit/veritas/optimizer/logic/connective/conjunction/contradiction/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::Contradiction, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:left)       { Logic::Proposition::Contradiction.instance      }
+  let(:right)      { Logic::Proposition::Contradiction.instance      }
+  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(Logic::Proposition::Contradiction.instance) }
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::LeftOperandTautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+  end
+
+  context 'when right is a tautology' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { attribute.eq(1)                        }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not a tautology' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/left_operand_tautology/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::LeftOperandTautology, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:left)       { Logic::Proposition::Tautology.instance          }
+  let(:right)      { attribute.eq(1)                                 }
+  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(right) }
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+  end
+
+  context 'when the operands are optimizable' do
+    let(:left)  { attribute.ne(2) }
+    let(:right) { attribute.ne(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operands are not optimizable' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.eq(2) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/optimizable_to_exclusion/optimize_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'when the right operands are optimizable' do
+    let(:left)  { attribute.ne(2) }
+    let(:right) { attribute.ne(1) }
+
+    it { should be_kind_of(Logic::Predicate::Exclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    # enumerable order is normalized
+    its(:right) { should == [ 1, 2 ] }
+  end
+
+  context 'when the right operands are not optimizable' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.ne(2) }
+
+    it { should be_kind_of(Logic::Predicate::Exclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::RightOperandTautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.and(right)                 }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+  end
+
+  context 'when right is a tautology' do
+    let(:left)  { attribute.eq(1)                        }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not a tautology' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/right_operand_tautology/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Conjunction::RightOperandTautology, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)            }
+  let(:left)       { attribute.eq(1)                        }
+  let(:right)      { Logic::Proposition::Tautology.instance }
+  let(:connective) { left.and(right)                        }
+  let(:object)     { described_class.new(connective)        }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(left) }
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/contradiction_left_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::ContradictionLeftOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:connective) { Logic::Connective::Disjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Disjunction)
+  end
+
+  context 'when right is a tautology' do
+    let(:left)  { Logic::Proposition::Contradiction.instance }
+    let(:right) { attribute.eq(1)                            }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not a tautology' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/contradiction_left_operand/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::ContradictionLeftOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                     }
+  let(:left)       { Logic::Proposition::Contradiction.instance      }
+  let(:right)      { attribute.eq(1)                                 }
+  let(:connective) { Logic::Connective::Disjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(right) }
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/contradiction_right_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::ContradictionRightOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.or(right)                  }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Disjunction)
+  end
+
+  context 'when right is a contradiction' do
+    let(:left)  { attribute.eq(1)                            }
+    let(:right) { Logic::Proposition::Contradiction.instance }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not a contradiction' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/contradiction_right_operand/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::ContradictionRightOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                }
+  let(:left)       { attribute.eq(1)                            }
+  let(:right)      { Logic::Proposition::Contradiction.instance }
+  let(:connective) { left.or(right)                             }
+  let(:object)     { described_class.new(connective)            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(left) }
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/optimizable_to_inclusion/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.or(right)                  }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Disjunction)
+  end
+
+  context 'when the operands are optimizable' do
+    let(:left)  { attribute.eq(2) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operands are not optimizable' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.eq(2) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/optimizable_to_inclusion/optimize_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)     }
+  let(:connective) { left.or(right)                  }
+  let(:object)     { described_class.new(connective) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'when the right operands are optimizable' do
+    let(:left)  { attribute.eq(2) }
+    let(:right) { attribute.eq(1) }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    # enumerable order is normalized
+    its(:right) { should == [ 1, 2 ] }
+  end
+
+  context 'when the right operands are not optimizable' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(2) }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+end