veritas-optimizer 0.0.3 → 0.0.4

data/spec/unit/veritas/optimizer/function/connective/disjunction/tautology/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/function/connective/negation/constant_operand/optimize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Negation::ConstantOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:negation) { Function::Connective::Negation.new(false) }
+  let(:object)   { described_class.new(negation)             }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(Function::Proposition::Tautology.instance) }
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Negation::InvertibleOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute) { Attribute::Integer.new(:id)                 }
+  let(:negation)  { Function::Connective::Negation.new(operand) }
+  let(:object)    { described_class.new(negation)               }
+
+  before do
+    object.operation.should be_kind_of(Function::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/function/connective/negation/invertible_operand/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/{logic → function}/connective/negation/operand_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Negation, '#operand' do
+describe Optimizer::Function::Connective::Negation, '#operand' do
   subject { object.operand }
 
   let(:optimized_operand) { mock('Optimized Operand')                       }

data/spec/unit/veritas/optimizer/{logic → function}/predicate/comparable/never_comparable/optimizable_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Comparable::NeverComparable, '#optimizable?' do
+describe Optimizer::Function::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)              }
+  let(:described_class) { Class.new(Optimizer::Function::Predicate)      }
+  let(:attribute)       { Attribute::Integer.new(:id)                    }
+  let(:predicate)       { Function::Predicate::Equality.new(left, right) }
+  let(:object)          { described_class.new(predicate)                 }
 
   before do
-    described_class.class_eval { include Optimizer::Logic::Predicate::Comparable::NeverComparable }
+    described_class.class_eval { include Optimizer::Function::Predicate::Comparable::NeverComparable }
 
-    predicate.should be_kind_of(Logic::Predicate::Comparable)
+    predicate.should be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left is a constant and is valid' do
@@ -55,4 +57,18 @@ describe Optimizer::Logic::Predicate::Comparable::NeverComparable, '#optimizable
 
     it { should be(true) }
   end
+
+  context 'when left is nil' do
+    let(:left)  { nil       }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when right is nil' do
+    let(:left)  { attribute }
+    let(:right) { nil       }
+
+    it { should be(true) }
+  end
 end

data/spec/unit/veritas/optimizer/{logic → function}/predicate/comparable/never_equivalent/optimizable_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Comparable::NeverEquivalent, '#optimizable?' do
+describe Optimizer::Function::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)              }
+  let(:described_class) { Class.new(Optimizer::Function::Predicate)      }
+  let(:attribute)       { Attribute::Integer.new(:id, :size => 1..10)    }
+  let(:predicate)       { Function::Predicate::Equality.new(left, right) }
+  let(:object)          { described_class.new(predicate)                 }
 
   before do
-    described_class.class_eval { include Optimizer::Logic::Predicate::Comparable::NeverEquivalent }
+    described_class.class_eval { include Optimizer::Function::Predicate::Comparable::NeverEquivalent }
 
-    predicate.should be_kind_of(Logic::Predicate::Comparable)
+    predicate.should be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left is a constant and is valid' do
@@ -55,4 +57,18 @@ describe Optimizer::Logic::Predicate::Comparable::NeverEquivalent, '#optimizable
 
     it { should be(true) }
   end
+
+  context 'when left is nil' do
+    let(:left)  { nil       }
+    let(:right) { attribute }
+
+    it { should be(true) }
+  end
+
+  context 'when right is nil' do
+    let(:left)  { attribute }
+    let(:right) { nil       }
+
+    it { should be(true) }
+  end
 end

data/spec/unit/veritas/optimizer/{logic → function}/predicate/comparable/normalizable_operands/optimizable_spec.rb

@@ -1,14 +1,16 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Comparable::NormalizableOperands, '#optimizable?' do
+describe Optimizer::Function::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)              }
+  let(:attribute) { Attribute::Integer.new(:id)                    }
+  let(:predicate) { Function::Predicate::Equality.new(left, right) }
+  let(:object)    { described_class.new(predicate)                 }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::Comparable)
+    predicate.should be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left and right is a constant' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/comparable/normalizable_operands/optimize_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Comparable::NormalizableOperands, '#optimize' do
+describe Optimizer::Function::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)               }
+  let(:attribute) { Attribute::Integer.new(:id)                     }
+  let(:predicate) { Function::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) }
+  it { should be_kind_of(Function::Predicate::Equality) }
 
   its(:left) { should equal(attribute) }
 

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

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

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

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

data/spec/unit/veritas/optimizer/function/predicate/enumerable/class_methods/sort_by_value_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Predicate::Enumerable, '.sort_by_value' do
+  subject { object.sort_by_value(value) }
+
+  let(:object) { self.class.described_type }
+
+  context 'when the value is true' do
+    let(:value) { true }
+
+    it { should eql(1) }
+  end
+
+  context 'when the value is false' do
+    let(:value) { false }
+
+    it { should eql(0) }
+  end
+
+  context 'when the value is an object' do
+    let(:value) { Object.new }
+
+    it { should equal(value) }
+  end
+end

data/spec/unit/veritas/optimizer/{logic → function}/predicate/enumerable/empty_right_operand/optimizable_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Enumerable::EmptyRightOperand, '#optimizable?' do
+describe Optimizer::Function::Predicate::Enumerable::EmptyRightOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:described_class) { Class.new(Optimizer::Logic::Predicate)     }
+  let(:described_class) { Class.new(Optimizer::Function::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 }
+    described_class.class_eval { include Optimizer::Function::Predicate::Enumerable::EmptyRightOperand }
 
-    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+    predicate.should be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains a nil' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/enumerable/one_right_operand/optimizable_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Enumerable::OneRightOperand, '#optimizable?' do
+describe Optimizer::Function::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)         }
+  let(:described_class) { Class.new(Optimizer::Function::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 }
+    described_class.class_eval { include Optimizer::Function::Predicate::Enumerable::OneRightOperand }
 
-    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+    predicate.should be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains a one entry Enumerable' do

data/spec/unit/veritas/optimizer/{logic/predicate/enumerable/unoptimized_operand → function/predicate/enumerable/unoptimized_operands}/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimizable?' do
+describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimiza
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::Enumerable)
+    predicate.should be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains an unsorted Enumerable' do

data/spec/unit/veritas/optimizer/{logic/predicate/enumerable/unoptimized_operand → function/predicate/enumerable/unoptimized_operands}/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimize' do
+describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -14,17 +16,28 @@ describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimize
   context 'when the operand contains an unsorted Enumerable' do
     let(:operand) { [ 2, 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Inclusion) }
+    it { should be_kind_of(Function::Predicate::Inclusion) }
 
     its(:left) { should equal(attribute) }
 
     its(:right) { should == [ 1, 2 ] }
   end
 
+  context 'when the operand contains an Enumerable with boolean values' do
+    let(:attribute) { Attribute::Boolean.new(:status) }
+    let(:operand)   { [ true, false ]                 }
+
+    it { should be_kind_of(Function::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ false, true ] }
+  end
+
   context 'when the operand contains an exclusive Range' do
     let(:operand) { 1...3 }
 
-    it { should be_kind_of(Logic::Predicate::Inclusion) }
+    it { should be_kind_of(Function::Predicate::Inclusion) }
 
     its(:left) { should equal(attribute) }
 
@@ -34,7 +47,7 @@ describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimize
   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) }
+    it { should be_kind_of(Function::Predicate::Inclusion) }
 
     its(:left) { should equal(attribute) }
 
@@ -44,7 +57,7 @@ describe Optimizer::Logic::Predicate::Enumerable::UnoptimizedOperand, '#optimize
   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) }
+    it { should be_kind_of(Function::Predicate::Inclusion) }
 
     its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/optimizer/{logic → function}/predicate/equality/tautology/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Equality::Tautology, '#optimizable?' do
+describe Optimizer::Function::Predicate::Equality::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::Equality::Tautology, '#optimizable?' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::Equality)
+    predicate.should be_kind_of(Function::Predicate::Equality)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/exclusion/empty_right_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Exclusion::EmptyRightOperand, '#optimize' do
+describe Optimizer::Function::Predicate::Exclusion::EmptyRightOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -14,30 +16,30 @@ describe Optimizer::Logic::Predicate::Exclusion::EmptyRightOperand, '#optimize'
   context 'when the operand contains a nil' do
     let(:operand) { nil }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
   end
 
   context 'when the operand contains an empty Enumerable' do
     let(:operand) { [] }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::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) }
+    it { should equal(Function::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) }
+    it { should equal(Function::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) }
+    it { should equal(Function::Proposition::Tautology.instance) }
   end
 end

data/spec/unit/veritas/optimizer/{logic → function}/predicate/exclusion/one_right_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
+describe Optimizer::Function::Predicate::Exclusion::OneRightOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -14,7 +16,7 @@ describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry Enumerable' do
     let(:operand) { [ 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Inequality) }
+    it { should be_kind_of(Function::Predicate::Inequality) }
 
     its(:left) { should equal(attribute) }
 
@@ -24,7 +26,7 @@ describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry inclusive Range' do
     let(:operand) { 1..1 }
 
-    it { should be_kind_of(Logic::Predicate::Inequality) }
+    it { should be_kind_of(Function::Predicate::Inequality) }
 
     its(:left) { should equal(attribute) }
 
@@ -34,7 +36,7 @@ describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry exclusive Range' do
     let(:operand) { 1...2 }
 
-    it { should be_kind_of(Logic::Predicate::Inequality) }
+    it { should be_kind_of(Function::Predicate::Inequality) }
 
     its(:left) { should equal(attribute) }
 
@@ -44,7 +46,7 @@ describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains one entry after filtering invalid entries' do
     let(:operand) { [ 'a', 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Inequality) }
+    it { should be_kind_of(Function::Predicate::Inequality) }
 
     its(:left) { should equal(attribute) }
 
@@ -54,7 +56,7 @@ describe Optimizer::Logic::Predicate::Exclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains one entry after filtering duplicate entries' do
     let(:operand) { [ 1, 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Inequality) }
+    it { should be_kind_of(Function::Predicate::Inequality) }
 
     its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/optimizer/{logic → function}/predicate/greater_than/contradiction/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::GreaterThan::Contradiction, '#optimizable?' do
+describe Optimizer::Function::Predicate::GreaterThan::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::GreaterThan::Contradiction, '#optimizable?
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::GreaterThan)
+    predicate.should be_kind_of(Function::Predicate::GreaterThan)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/greater_than/tautology/optimizable_spec.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::GreaterThan::Tautology, '#optimizable?' do
+describe Optimizer::Function::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)
+    predicate.should be_kind_of(Function::Predicate::GreaterThan)
   end
 
   context 'when left is always greater than right' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/greater_than_or_equal_to/contradiction/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Contradiction, '#optimizable?' do
+describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Contradiction, '#opt
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::GreaterThanOrEqualTo)
+    predicate.should be_kind_of(Function::Predicate::GreaterThanOrEqualTo)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/greater_than_or_equal_to/tautology/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Tautology, '#optimizable?' do
+describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::GreaterThanOrEqualTo::Tautology, '#optimiz
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::GreaterThan)
+    predicate.should be_kind_of(Function::Predicate::GreaterThan)
   end
 
   context 'when left and right are equal' do