veritas-optimizer 0.0.3

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Disjunction::Tautology, '#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 left is a tautology' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { attribute.eq(1)                        }
+
+    it { should be(true) }
+  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 left and right are inequality predicates with the same attribute and constant values' do
+    let(:left)  { attribute.ne(1) }
+    let(:right) { attribute.ne(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/disjunction/tautology/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/logic/connective/negation/invertible_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Negation::InvertibleOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:negation)  { Logic::Connective::Negation.new(operand) }
+  let(:object)    { described_class.new(negation)            }
+
+  before do
+    object.operation.should be_kind_of(Logic::Connective::Negation)
+  end
+
+  context 'when operand is invertible' do
+    let(:operand) { attribute.eq(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when operand is not invertible' do
+    let(:operand) { proc { true } }
+
+    it { should be(false) }
+  end
+
+end

data/spec/unit/veritas/optimizer/logic/connective/negation/invertible_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Negation::InvertibleOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:operand)   { attribute.eq(1)                          }
+  let(:negation)  { Logic::Connective::Negation.new(operand) }
+  let(:object)    { described_class.new(negation)            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Logic::Predicate::Inequality) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should == 1 }
+end

data/spec/unit/veritas/optimizer/logic/connective/negation/operand_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Connective::Negation, '#operand' do
+  subject { object.operand }
+
+  let(:optimized_operand) { mock('Optimized Operand')                       }
+  let(:operand)           { mock('Operand', :optimize => optimized_operand) }
+  let(:negation)          { mock('Negation', :operand => operand)           }
+  let(:object)            { described_class.new(negation)                   }
+
+  it { should equal(optimized_operand) }
+end

data/spec/unit/veritas/optimizer/logic/predicate/class_methods/optimize_operand_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate, '.optimize_operand' do
+  subject { object.optimize_operand(predicate) }
+
+  let(:object) { Optimizer::Logic::Predicate }
+
+  context 'when optimizable' do
+    let(:optimized) { mock('Optimized')                           }
+    let(:predicate) { mock('Optimizable', :optimize => optimized) }
+
+    it { should equal(optimized) }
+  end
+
+  context 'when not optimizable' do
+    let(:predicate) { mock('Not Optimizable') }
+
+    it { should equal(predicate) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/comparable/never_comparable/optimizable_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Comparable::NeverComparable, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Logic::Predicate)      }
+  let(:attribute)       { Attribute::Integer.new(:id)                 }
+  let(:predicate)       { Logic::Predicate::Equality.new(left, right) }
+  let(:object)          { described_class.new(predicate)              }
+
+  before do
+    described_class.class_eval { include Optimizer::Logic::Predicate::Comparable::NeverComparable }
+
+    predicate.should be_kind_of(Logic::Predicate::Comparable)
+  end
+
+  context 'when left is a constant and is valid' do
+    let(:left)  { 1         }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left is a constand and is not valid' do
+    let(:left)  { 'a'       }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when right is a constant and is valid' do
+    let(:left)  { attribute }
+    let(:right) { 1         }
+
+    it { should be(false) }
+  end
+
+  context 'when right is a constant and is not valid' do
+    let(:left)  { attribute }
+    let(:right) { 'a'       }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are comparable' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left and right are not comparable' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/comparable/never_equivalent/optimizable_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Comparable::NeverEquivalent, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Logic::Predicate)      }
+  let(:attribute)       { Attribute::Integer.new(:id, :size => 1..10) }
+  let(:predicate)       { Logic::Predicate::Equality.new(left, right) }
+  let(:object)          { described_class.new(predicate)              }
+
+  before do
+    described_class.class_eval { include Optimizer::Logic::Predicate::Comparable::NeverEquivalent }
+
+    predicate.should be_kind_of(Logic::Predicate::Comparable)
+  end
+
+  context 'when left is a constant and is valid' do
+    let(:left)  { 1         }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left is a constand and is not valid' do
+    let(:left)  { 0         }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when right is a constant and is valid' do
+    let(:left)  { attribute }
+    let(:right) { 1         }
+
+    it { should be(false) }
+  end
+
+  context 'when right is a constant and is not valid' do
+    let(:left)  { attribute }
+    let(:right) { 0         }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are joinable' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left and right are not joinable' do
+    let(:left)  { attribute                                    }
+    let(:right) { Attribute::Integer.new(:id, :size => -10..0) }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/comparable/normalizable_operands/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Comparable::NormalizableOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)                 }
+  let(:predicate) { Logic::Predicate::Equality.new(left, right) }
+  let(:object)    { described_class.new(predicate)              }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::Comparable)
+  end
+
+  context 'when left and right is a constant' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(false) }
+  end
+
+  context 'when left and right is an attribute' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left is a constant and right is an attribute' do
+    let(:left)  { 1         }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when left is an attribute and right is a constant' do
+    let(:left)  { attribute }
+    let(:right) { 1         }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/comparable/normalizable_operands/optimize_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Comparable::NormalizableOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)                  }
+  let(:predicate) { Logic::Predicate::Equality.new(1, attribute) }
+  let(:object)    { described_class.new(predicate)               }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Logic::Predicate::Equality) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should == 1 }
+end

data/spec/unit/veritas/optimizer/logic/predicate/constant_operands/optimizable_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::ConstantOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:predicate) { Logic::Predicate::Equality.new(left, right) }
+  let(:object)    { described_class.new(predicate)              }
+
+  context 'when left and right are constants' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when left is a constant, and right is not a constant' do
+    let(:left)  { 1                                      }
+    let(:right) { Logic::Proposition::Tautology.instance }
+
+    it { should be(false) }
+  end
+
+  context 'when left is not a constant, and right is a constant' do
+    let(:left)  { Logic::Proposition::Tautology.instance }
+    let(:right) { 1                                      }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/constant_operands/optimize_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::ConstantOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:predicate) { Logic::Predicate::Equality.new(1, 1) }
+  let(:object)    { described_class.new(predicate)       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(Logic::Proposition::Tautology.instance) }
+end

data/spec/unit/veritas/optimizer/logic/predicate/contradiction/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Contradiction, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer::Logic::Predicate)                 }
+  let(:attribute)       { Attribute::Integer.new(:id)                            }
+  let(:predicate)       { Logic::Predicate::Inequality.new(attribute, attribute) }
+  let(:object)          { described_class.new(predicate)                         }
+
+  before do
+    described_class.class_eval { include Optimizer::Logic::Predicate::Contradiction }
+  end
+
+  it { should equal(Logic::Proposition::Contradiction.instance) }
+end

data/spec/unit/veritas/optimizer/logic/predicate/enumerable/empty_right_operand/optimizable_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Enumerable::EmptyRightOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Logic::Predicate)     }
+  let(:attribute)       { Attribute::Integer.new(:id, :size => 1..9) }
+  let(:predicate)       { attribute.include(operand)                 }
+  let(:object)          { described_class.new(predicate)             }
+
+  before do
+    described_class.class_eval { include Optimizer::Logic::Predicate::Enumerable::EmptyRightOperand }
+
+    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+  end
+
+  context 'when the operand contains a nil' do
+    let(:operand) { nil }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an empty Enumerable' do
+    let(:operand) { [] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an empty inclusive Range' do
+    let(:operand) { 1..0 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an empty exclusive Range' do
+    let(:operand) { 1...1 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is empty after filtering invalid entries' do
+    let(:operand) { [ 'a' ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an not empty Enumerable' do
+    let(:operand) { [ 1 ] }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains an not empty inclusive Range' do
+    let(:operand) { 1..1 }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains an not empty exclusive Range' do
+    let(:operand) { 1...2 }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is not empty after filtering invalid entries' do
+    let(:operand) { [ 'a', 1 ] }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains a Range outside of the allowed values' do
+    let(:operand) { 10..100 }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/enumerable/one_right_operand/optimizable_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Enumerable::OneRightOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Logic::Predicate) }
+  let(:attribute)       { Attribute::Integer.new(:id)            }
+  let(:predicate)       { attribute.include(operand)             }
+  let(:object)          { described_class.new(predicate)         }
+
+  before do
+    described_class.class_eval { include Optimizer::Logic::Predicate::Enumerable::OneRightOperand }
+
+    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+  end
+
+  context 'when the operand contains a one entry Enumerable' do
+    let(:operand) { [ 1 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains a one entry inclusive Range' do
+    let(:operand) { 1..1 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains a one entry exclusive Range' do
+    let(:operand) { 1...2 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains one entry after filtering invalid entries' do
+    let(:operand) { [ 'a', 1 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains one entry after filtering duplicate entries' do
+    let(:operand) { [ 1, 1 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains a more than one entry Enumerable' do
+    let(:operand) { [ 2, 1 ] }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains a more than one entry inclusive Range' do
+    let(:operand) { 1..2 }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains a more than one entry exclusive Range' do
+    let(:operand) { 1...3 }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains more than one entry after filtering invalid entries' do
+    let(:operand) { [ 'a', 1, 2 ] }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains more than one entry after filtering duplicate entries' do
+    let(:operand) { [ 2, 1, 2, 1 ] }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/enumerable/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { attribute.include(operand)     }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+  end
+
+  context 'when the operand contains an unsorted Enumerable' do
+    let(:operand) { [ 2, 1 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an exclusive Range' do
+    let(:operand) { 1...3 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an Enumerable after filtering invalid entries' do
+    let(:operand) { [ 'a', 1, 2 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains an Enumerable after filtering duplicate entries' do
+    let(:operand) { [ 1, 1, 2, 2 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand contains a sorted Enumerable' do
+    let(:operand) { [ 1, 2 ] }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand contains an inclusive Range' do
+    let(:operand) { 1..2 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/enumerable/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { attribute.include(operand)     }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'when the operand contains an unsorted Enumerable' do
+    let(:operand) { [ 2, 1 ] }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+
+  context 'when the operand contains an exclusive Range' do
+    let(:operand) { 1...3 }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == (1..2) }
+  end
+
+  context 'when the operand contains an Enumerable after filtering invalid entries' do
+    let(:operand) { [ 'a', 1, 2 ] }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+
+  context 'when the operand contains an Enumerable after filtering duplicate entries' do
+    let(:operand) { [ 1, 1, 2, 2 ] }
+
+    it { should be_kind_of(Logic::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/equality/tautology/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Equality::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.eq(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::Equality)
+  end
+
+  context 'when left and right are equal' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are not equal' do
+    let(:left)  { attribute }
+    let(:right) { 1         }
+
+    it { should be(false) }
+  end
+end