veritas-optimizer 0.0.3

data/spec/unit/veritas/optimizer/logic/predicate/exclusion/empty_right_operand/optimize_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Exclusion::EmptyRightOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { attribute.exclude(operand)     }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'when the operand contains a nil' do
+    let(:operand) { nil }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+  end
+
+  context 'when the operand contains an empty Enumerable' do
+    let(:operand) { [] }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+  end
+
+  context 'when the operand contains an empty inclusive Range' do
+    let(:operand) { 1..0 }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+  end
+
+  context 'when the operand contains an empty exclusive Range' do
+    let(:operand) { 1...1 }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+  end
+
+  context 'when the operand is empty after filtering invalid entries' do
+    let(:operand) { [ 'a' ] }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/exclusion/one_right_operand/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/logic/predicate/greater_than/contradiction/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::GreaterThan::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.gt(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::GreaterThan)
+  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 different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is always less than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 1..9)   }
+    let(:right) { Attribute::Integer.new(:id, :size => 10..20) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::GreaterThan::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:predicate) { left.gt(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::GreaterThan)
+  end
+
+  context 'when left is always greater than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 10..20) }
+    let(:right) { Attribute::Integer.new(:id, :size => 1..9)   }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/greater_than_or_equal_to/contradiction/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.gte(right)                }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::GreaterThanOrEqualTo)
+  end
+
+  context 'when left and right are equal' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left and right are different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is always less than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 1..9)   }
+    let(:right) { Attribute::Integer.new(:id, :size => 10..20) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.gt(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::GreaterThan)
+  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 different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+  end
+
+  context 'when left is always greater than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 10..20) }
+    let(:right) { Attribute::Integer.new(:id, :size => 1..9)   }
+
+    it { should be(true) }
+  end
+
+  context 'when left is not equivalent to the right' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/inclusion/empty_right_operand/optimize_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Inclusion::EmptyRightOperand, '#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 a nil' do
+    let(:operand) { nil }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+  end
+
+  context 'when the operand contains an empty Enumerable' do
+    let(:operand) { [] }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+  end
+
+  context 'when the operand contains an empty inclusive Range' do
+    let(:operand) { 1..0 }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+  end
+
+  context 'when the operand contains an empty exclusive Range' do
+    let(:operand) { 1...1 }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+  end
+
+  context 'when the operand is empty after filtering invalid entries' do
+    let(:operand) { [ 'a' ] }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/inclusion/one_right_operand/optimize_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#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 a one entry Enumerable' do
+    let(:operand) { [ 1 ] }
+
+    it { should be_kind_of(Logic::Predicate::Equality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+
+  end
+
+  context 'when the operand contains a one entry inclusive Range' do
+    let(:operand) { 1..1 }
+
+    it { should be_kind_of(Logic::Predicate::Equality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+  end
+
+  context 'when the operand contains a one entry exclusive Range' do
+    let(:operand) { 1...2 }
+
+    it { should be_kind_of(Logic::Predicate::Equality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+  end
+
+  context 'when the operand contains one entry after filtering invalid entries' do
+    let(:operand) { [ 'a', 1 ] }
+
+    it { should be_kind_of(Logic::Predicate::Equality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+  end
+
+  context 'when the operand contains one entry after filtering duplicate entries' do
+    let(:operand) { [ 1, 1 ] }
+
+    it { should be_kind_of(Logic::Predicate::Equality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/inequality/contradiction/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Inequality::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.ne(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::Inequality)
+  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

data/spec/unit/veritas/optimizer/logic/predicate/left_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate, '#left' do
+  subject { object.left }
+
+  let(:right)     { 'Right'                                      }
+  let(:predicate) { Class.new(Logic::Predicate).new(left, right) }
+  let(:object)    { described_class.new(predicate)               }
+
+  context 'when left operand is frozen' do
+    let(:left) { 'Left'.freeze }
+
+    it { should equal(left) }
+  end
+
+  context 'when left operand is not frozen' do
+    let(:left) { 'Left' }
+
+    it { should_not equal(left) }
+
+    it { should be_frozen }
+
+    it { should == left }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/less_than/contradiction/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::LessThan::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.lt(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::LessThan)
+  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 different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is always greater than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 10..20) }
+    let(:right) { Attribute::Integer.new(:id, :size => 1..9)   }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::LessThan::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:predicate) { left.lt(right)                 }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::LessThan)
+  end
+
+  context 'when left is always less than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 1..9)   }
+    let(:right) { Attribute::Integer.new(:id, :size => 10..20) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/less_than_or_equal_to/contradiction/optimizable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.lte(right)                }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::LessThanOrEqualTo)
+  end
+
+  context 'when left and right are equal' do
+    let(:left)  { attribute }
+    let(:right) { attribute }
+
+    it { should be(false) }
+  end
+
+  context 'when left and right are different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is always greater than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 10..20) }
+    let(:right) { Attribute::Integer.new(:id, :size => 1..9)   }
+
+    it { should be(true) }
+  end
+
+  context 'when left is equivalent to the right' do
+    let(:left)  { Attribute::Integer.new(:id) }
+    let(:right) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:predicate) { left.lte(right)                }
+  let(:object)    { described_class.new(predicate) }
+
+  before do
+    predicate.should be_kind_of(Logic::Predicate::LessThanOrEqualTo)
+  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 different types' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+  end
+
+  context 'when left is always less than right' do
+    let(:left)  { Attribute::Integer.new(:id, :size => 1..9)   }
+    let(:right) { Attribute::Integer.new(:id, :size => 10..20) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is not equivalent to the right' do
+    let(:left)  { attribute                    }
+    let(:right) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/right_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate, '#right' do
+  subject { object.right }
+
+  let(:left)      { 'Left'                                       }
+  let(:predicate) { Class.new(Logic::Predicate).new(left, right) }
+  let(:object)    { described_class.new(predicate)               }
+
+  context 'when right operand is frozen' do
+    let(:right) { 'Right'.freeze }
+
+    it { should equal(right) }
+  end
+
+  context 'when right operand is not frozen' do
+    let(:right) { 'Right' }
+
+    it { should_not equal(right) }
+
+    it { should be_frozen }
+
+    it { should == right }
+  end
+end

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

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

data/spec/unit/veritas/optimizer/logic/predicate/util/class_methods/attribute_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Util, '.attribute?' do
+  subject { object.attribute?(operand) }
+
+  let(:object) { Optimizer::Logic::Predicate::Util }
+
+  context 'with an attribute' do
+    let(:operand) { Attribute::Integer.new(:id) }
+
+    it { should be(true) }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/util/class_methods/constant_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Util, '.constant?' do
+  subject { object.constant?(operand) }
+
+  let(:object) { Optimizer::Logic::Predicate::Util }
+
+  context 'with an attribute' do
+    let(:operand) { Attribute::Integer.new(:id) }
+
+    it { should be(false) }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/veritas/optimizer/logic/predicate/util/class_methods/max_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Util, '.max' do
+  subject { object.max(operand) }
+
+  let(:object) { Optimizer::Logic::Predicate::Util }
+
+  context 'with an attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 10 }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end