veritas-optimizer 0.0.3 → 0.0.4

data/spec/unit/veritas/optimizer/function/class_methods/optimize_functions_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function, '.optimize_functions' do
+  subject { object.optimize_functions(functions) }
+
+  let(:object)    { self.class.described_type }
+  let(:attribute) { mock('Attribute')         }
+  let(:functions) { { attribute => function } }
+
+  context 'when optimizable' do
+    let(:optimized) { mock('Optimized')                           }
+    let(:function)  { mock('Optimizable', :optimize => optimized) }
+
+    it { should be_frozen }
+
+    it { should == { attribute => optimized } }
+  end
+
+  context 'when not optimizable' do
+    let(:function) { mock('Not Optimizable') }
+
+    it { should == functions }
+  end
+end

data/spec/unit/veritas/optimizer/function/class_methods/optimize_operand_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function, '.optimize_operand' do
+  subject { object.optimize_operand(function) }
+
+  let(:object) { self.class.described_type }
+
+  context 'when optimizable' do
+    let(:optimized) { mock('Optimized')                           }
+    let(:function)  { mock('Optimizable', :optimize => optimized) }
+
+    it { should equal(optimized) }
+  end
+
+  context 'when not optimizable' do
+    let(:function) { mock('Not Optimizable') }
+
+    it { should equal(function) }
+  end
+end

data/spec/unit/veritas/optimizer/function/connective/binary/constant_operands/optimize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Binary::ConstantOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:connective) { Function::Connective::Conjunction.new(true, true) }
+  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/{logic → function}/connective/binary/equal_operands/optimizable_spec.rb

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

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/equal_operands/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary::EqualOperands, '#optimize' do
+describe Optimizer::Function::Connective::Binary::EqualOperands, '#optimize' do
   subject { object.optimize }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/left_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary, '#left' do
+describe Optimizer::Function::Connective::Binary, '#left' do
   subject { object.left }
 
   let(:optimized_left)  { mock('Optimized Left')                             }

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/redundant_left_operand/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimizable?' do
+describe Optimizer::Function::Connective::Binary::RedundantLeftOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -9,7 +11,7 @@ describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimizab
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
+    object.operation.should be_kind_of(Function::Connective::Binary)
   end
 
   context 'when the left operand is redundant' do

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/redundant_left_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimize' do
+describe Optimizer::Function::Connective::Binary::RedundantLeftOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -13,7 +15,7 @@ describe Optimizer::Logic::Connective::Binary::RedundantLeftOperand, '#optimize'
     object.should be_optimizable
   end
 
-  it { should be_kind_of(Logic::Connective::Conjunction) }
+  it { should be_kind_of(Function::Connective::Conjunction) }
 
   its(:left) { should eql(attribute.eq(1)) }
 

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/redundant_right_operand/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimizable?' do
+describe Optimizer::Function::Connective::Binary::RedundantRightOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)     }
@@ -9,7 +11,7 @@ describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimiza
   let(:object)    { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
+    object.operation.should be_kind_of(Function::Connective::Binary)
   end
 
   context 'when the right operand is redundant' do

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/redundant_right_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimize' do
+describe Optimizer::Function::Connective::Binary::RedundantRightOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -13,7 +15,7 @@ describe Optimizer::Logic::Connective::Binary::RedundantRightOperand, '#optimize
     object.should be_optimizable
   end
 
-  it { should be_kind_of(Logic::Connective::Conjunction) }
+  it { should be_kind_of(Function::Connective::Conjunction) }
 
   its(:left) { should eql(attribute.eq(1)) }
 

data/spec/unit/veritas/optimizer/{logic → function}/connective/binary/right_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Binary, '#right' do
+describe Optimizer::Function::Connective::Binary, '#right' do
   subject { object.right }
 
   let(:optimized_left)  { mock('Optimized Left')                             }

data/spec/unit/veritas/optimizer/function/connective/conjunction/contradiction/optimizable_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:connective) { Function::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
+
+  before do
+    object.operation.should be_kind_of(Function::Connective::Conjunction)
+  end
+
+  context 'when left is a contradiction' do
+    let(:left)  { Function::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) { Function::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
+
+  context 'when left and right are procs' do
+    let(:left)  { proc {} }
+    let(:right) { proc {} }
+
+    it { should be(false) }
+  end
+
+  context 'when left is a proc' do
+    let(:left)  { proc {}         }
+    let(:right) { attribute.ne(1) }
+
+    it { should be(false) }
+  end
+
+  context 'when right is a proc' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { proc {}         }
+
+    it { should be(false) }
+  end
+end

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

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

data/spec/unit/veritas/optimizer/{logic/connective/disjunction/contradiction_left_operand → function/connective/conjunction/left_operand_tautology}/optimizable_spec.rb

@@ -1,19 +1,21 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Disjunction::ContradictionLeftOperand, '#optimizable?' do
+describe Optimizer::Function::Connective::Conjunction::LeftOperandTautology, '#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)                 }
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:connective) { Function::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Disjunction)
+    object.operation.should be_kind_of(Function::Connective::Conjunction)
   end
 
   context 'when right is a tautology' do
-    let(:left)  { Logic::Proposition::Contradiction.instance }
-    let(:right) { attribute.eq(1)                            }
+    let(:left)  { Function::Proposition::Tautology.instance }
+    let(:right) { attribute.eq(1)                           }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/{logic → function}/connective/conjunction/left_operand_tautology/optimize_spec.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Conjunction::LeftOperandTautology, '#optimize' do
+describe Optimizer::Function::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)                 }
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:left)       { Function::Proposition::Tautology.instance          }
+  let(:right)      { attribute.eq(1)                                    }
+  let(:connective) { Function::Connective::Conjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/{logic → function}/connective/conjunction/optimizable_to_exclusion/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#optimizable?' do
+describe Optimizer::Function::Connective::Conjunction::OptimizableToExclusion, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#op
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+    object.operation.should be_kind_of(Function::Connective::Conjunction)
   end
 
   context 'when the operands are optimizable' do

data/spec/unit/veritas/optimizer/{logic → function}/connective/conjunction/optimizable_to_exclusion/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#optimize' do
+describe Optimizer::Function::Connective::Conjunction::OptimizableToExclusion, '#optimize' do
   subject { object.optimize }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -15,7 +17,7 @@ describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#op
     let(:left)  { attribute.ne(2) }
     let(:right) { attribute.ne(1) }
 
-    it { should be_kind_of(Logic::Predicate::Exclusion) }
+    it { should be_kind_of(Function::Predicate::Exclusion) }
 
     its(:left) { should equal(attribute) }
 
@@ -27,7 +29,7 @@ describe Optimizer::Logic::Connective::Conjunction::OptimizableToExclusion, '#op
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.ne(2) }
 
-    it { should be_kind_of(Logic::Predicate::Exclusion) }
+    it { should be_kind_of(Function::Predicate::Exclusion) }
 
     its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/optimizer/{logic → function}/connective/conjunction/right_operand_tautology/optimizable_spec.rb

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

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::RightOperandTautology, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute)  { Attribute::Integer.new(:id)               }
+  let(:left)       { attribute.eq(1)                           }
+  let(:right)      { Function::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/conjunction/left_operand_tautology → function/connective/disjunction/contradiction_left_operand}/optimizable_spec.rb

@@ -1,19 +1,21 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Conjunction::LeftOperandTautology, '#optimizable?' do
+describe Optimizer::Function::Connective::Disjunction::ContradictionLeftOperand, '#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)                 }
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:connective) { Function::Connective::Disjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Conjunction)
+    object.operation.should be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when right is a tautology' do
-    let(:left)  { Logic::Proposition::Tautology.instance }
-    let(:right) { attribute.eq(1)                        }
+    let(:left)  { Function::Proposition::Contradiction.instance }
+    let(:right) { attribute.eq(1)                               }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/{logic → function}/connective/disjunction/contradiction_left_operand/optimize_spec.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Disjunction::ContradictionLeftOperand, '#optimize' do
+describe Optimizer::Function::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)                 }
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:left)       { Function::Proposition::Contradiction.instance      }
+  let(:right)      { attribute.eq(1)                                    }
+  let(:connective) { Function::Connective::Disjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/{logic → function}/connective/disjunction/contradiction_right_operand/optimizable_spec.rb

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

data/spec/unit/veritas/optimizer/{logic → function}/connective/disjunction/contradiction_right_operand/optimize_spec.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Disjunction::ContradictionRightOperand, '#optimize' do
+describe Optimizer::Function::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)            }
+  let(:attribute)  { Attribute::Integer.new(:id)                   }
+  let(:left)       { attribute.eq(1)                               }
+  let(:right)      { Function::Proposition::Contradiction.instance }
+  let(:connective) { left.or(right)                                }
+  let(:object)     { described_class.new(connective)               }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/{logic → function}/connective/disjunction/optimizable_to_inclusion/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#optimizable?' do
+describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#op
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Logic::Connective::Disjunction)
+    object.operation.should be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when the operands are optimizable' do

data/spec/unit/veritas/optimizer/{logic → function}/connective/disjunction/optimizable_to_inclusion/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#optimize' do
+describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '#optimize' do
   subject { object.optimize }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
@@ -15,7 +17,7 @@ describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#op
     let(:left)  { attribute.eq(2) }
     let(:right) { attribute.eq(1) }
 
-    it { should be_kind_of(Logic::Predicate::Inclusion) }
+    it { should be_kind_of(Function::Predicate::Inclusion) }
 
     its(:left) { should equal(attribute) }
 
@@ -27,7 +29,7 @@ describe Optimizer::Logic::Connective::Disjunction::OptimizableToInclusion, '#op
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.eq(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/function/connective/disjunction/tautology/optimizable_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Disjunction::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                        }
+  let(:connective) { Function::Connective::Disjunction.new(left, right) }
+  let(:object)     { described_class.new(connective)                    }
+
+  before do
+    object.operation.should be_kind_of(Function::Connective::Disjunction)
+  end
+
+  context 'when left is a tautology' do
+    let(:left)  { Function::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) { Function::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
+
+  context 'when left and right are procs' do
+    let(:left)  { proc {} }
+    let(:right) { proc {} }
+
+    it { should be(false) }
+  end
+
+  context 'when left is a proc' do
+    let(:left)  { proc {}         }
+    let(:right) { attribute.ne(1) }
+
+    it { should be(false) }
+  end
+
+  context 'when right is a proc' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { proc {}         }
+
+    it { should be(false) }
+  end
+end