axiom-optimizer 0.1.0

data/spec/unit/axiom/optimizer/function/connective/conjunction/tautology_left/optimizable_predicate_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::TautologyLeft, '#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 right is a tautology' do
+    let(:left)  { Function::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/axiom/optimizer/function/connective/conjunction/tautology_left/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::TautologyLeft, '#optimize' do
+  subject { object.optimize }
+
+  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
+  end
+
+  it { should equal(right) }
+end

data/spec/unit/axiom/optimizer/function/connective/conjunction/tautology_right/optimizable_predicate_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::TautologyRight, '#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(Function::Connective::Conjunction)
+  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 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/axiom/optimizer/function/connective/conjunction/tautology_right/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Conjunction::TautologyRight, '#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/axiom/optimizer/function/connective/disjunction/contradiction_left/optimizable_predicate_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Disjunction::ContradictionLeft, '#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 right is a tautology' do
+    let(:left)  { Function::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/axiom/optimizer/function/connective/disjunction/contradiction_left/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Disjunction::ContradictionLeft, '#optimize' do
+  subject { object.optimize }
+
+  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
+  end
+
+  it { should equal(right) }
+end

data/spec/unit/axiom/optimizer/function/connective/disjunction/contradiction_right/optimizable_predicate_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Disjunction::ContradictionRight, '#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(Function::Connective::Disjunction)
+  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 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/axiom/optimizer/function/connective/disjunction/contradiction_right/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Connective::Disjunction::ContradictionRight, '#optimize' do
+  subject { object.optimize }
+
+  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
+  end
+
+  it { should equal(left) }
+end

data/spec/unit/axiom/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimizable_predicate_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::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(Function::Connective::Disjunction)
+  end
+
+  context 'when the operands are optimizable' do
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.eq(2) }
+      let(:right) { attribute.eq(1) }
+
+      it { should be(true) }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.eq(2)             }
+      let(:right) { attribute.include([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.include([ 2, 3 ]) }
+      let(:right) { attribute.eq(1)             }
+
+      it { should be(true) }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.include([ 2, 3 ]) }
+      let(:right) { attribute.include([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
+  end
+
+  context 'when the operands are not optimizable' do
+    context 'when the left is an inequality predicate and the right is an equality predicate' do
+      let(:left)  { attribute.ne(1) }
+      let(:right) { attribute.eq(2) }
+
+      it { should be(false) }
+    end
+
+    context 'when the left is an exclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.exclude([ 1, 3 ]) }
+      let(:right) { attribute.eq(2)             }
+
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/axiom/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimize_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::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
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.eq(2) }
+      let(:right) { attribute.eq(1) }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.eq(2)          }
+      let(:right) { attribute.include([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.include([ 2 ]) }
+      let(:right) { attribute.eq(1)          }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.include([ 2 ]) }
+      let(:right) { attribute.include([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+  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(Function::Predicate::Inclusion) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == [ 1, 2 ] }
+  end
+end

data/spec/unit/axiom/optimizer/function/connective/disjunction/tautology/optimizable_predicate_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

data/spec/unit/axiom/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/axiom/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