axiom-optimizer 0.1.0

data/spec/unit/axiom/optimizer/function/util/class_methods/max_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Util, '.max' do
+  subject { object.max(operand) }
+
+  let(:object) { Optimizer::Function::Util }
+
+  context 'with an Integer attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 10 }
+  end
+
+  context 'with a String attribute' do
+    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+
+    it { should == 10 }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end

data/spec/unit/axiom/optimizer/function/util/class_methods/min_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Util, '.min' do
+  subject { object.min(operand) }
+
+  let(:object) { Optimizer::Function::Util }
+
+  context 'with an Integer attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 1 }
+  end
+
+  context 'with a String attribute' do
+    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+
+    it { should == 1 }
+  end
+
+  context 'with a constat' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end

data/spec/unit/axiom/optimizer/operation_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer, '#operation' do
+  subject { object.operation }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  it { should equal(operation) }
+end

data/spec/unit/axiom/optimizer/optimizable/class_methods/optimizer_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Optimizable::ClassMethods, '#optimizer' do
+  subject { object.optimizer }
+
+  let(:object) { Class.new { include Optimizer::Optimizable, Adamantium } }
+
+  context 'when the optimizer is not set' do
+    it { should be_nil }
+  end
+
+  context 'when the optimizer is set' do
+    let(:optimizer) { mock('Optimizer') }
+
+    before do
+      object.optimizer = optimizer
+    end
+
+    it { should equal(optimizer) }
+  end
+end
+
+describe Optimizer::Optimizable::ClassMethods, '#optimizer=' do
+  subject { object.optimizer = optimizer }
+
+  let(:optimizer) { mock('Optimizer')                                        }
+  let(:object)    { Class.new { include Optimizer::Optimizable, Adamantium } }
+
+  it 'sets the optimizer' do
+    expect { subject }.to change { object.optimizer }.from(nil).to(optimizer)
+  end
+end

data/spec/unit/axiom/optimizer/optimizable/optimize_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Optimizable, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new { include Optimizer::Optimizable, Adamantium } }
+  let(:object)          { described_class.new                                      }
+
+  context 'when there is no optimizer for the class' do
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'when there is an optimizer for the class' do
+    let(:optimized) { mock('Optimized', :frozen? => true)   }
+    let(:optimizer) { mock('Optimizer', :call => optimized) }
+
+    before do
+      described_class.optimizer = optimizer
+      optimized.stub!(:optimize).and_return(optimized)
+    end
+
+    it { should equal(optimized) }
+
+    it 'calls the optimizer with the object' do
+      optimizer.should_receive(:call).with(object).and_return(optimized)
+      should equal(optimized)
+    end
+
+    it '#optimize the optimized object' do
+      optimized.should_receive(:optimize).with(no_args).and_return(optimized)
+      should equal(optimized)
+    end
+  end
+end

data/spec/unit/axiom/optimizer/optimizable_predicate_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  before do
+    described_class.stub!(:to_s).and_return('Optimizer')
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimizable? must be implemented') }
+end

data/spec/unit/axiom/optimizer/optimize_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  before do
+    described_class.stub!(:to_s).and_return('Optimizer')
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimize must be implemented') }
+end

data/spec/unit/axiom/optimizer/predicate_partition/left_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::PredicatePartition, '#left' do
+  subject { object.left }
+
+  let(:left_header)  { Relation::Header.coerce([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
+  let(:right_header) { Relation::Header.coerce([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                            }
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it 'partitions the predicate to the left' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it 'partitions the predicate to the left' do
+      should equal(Function::Proposition::Contradiction.instance)
+    end
+  end
+
+  context 'when the predicate is an attribute' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:active_user] }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:active_employee] }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:active] }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a binary predicate' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:id].eq(1) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left header, and an attribute from the left and right header' do
+      let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, and an attribute from the left and right header' do
+      let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with disjoint attributes from the left and right header' do
+      let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a negation' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a conjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.and(right_predicate)         }
+
+    it 'partitions the predicate to the left that reference the left header' do
+      should equal(left_predicate)
+    end
+  end
+
+  context 'when the predicate is a disjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.or(right_predicate)          }
+
+    it 'partitions the predicate to the left that reference the left header, transforming it with De Morgan\'s Law' do
+      should eql(left_header[:user_name].ne('Dan Kubb'))
+    end
+  end
+end

data/spec/unit/axiom/optimizer/predicate_partition/remainder_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::PredicatePartition, '#remainder' do
+  subject { object.remainder }
+
+  let(:left_header)  { Relation::Header.coerce([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
+  let(:right_header) { Relation::Header.coerce([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                            }
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it 'partitions the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it 'partitions the predicate to the remainder' do
+      should equal(Function::Proposition::Contradiction.instance)
+    end
+  end
+
+  context 'when the predicate is an attribute' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:active_user] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:active_employee] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:active] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a binary predicate' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:id].eq(1) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left header, and an attribute from the left and right header' do
+      let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, and an attribute from the left and right header' do
+      let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with disjoint attributes from the left and right header' do
+      let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
+
+      it 'partitions the predicate to the remainder' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a negation' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a conjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.and(right_predicate)         }
+
+    it 'does not partition the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a disjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.or(right_predicate)          }
+
+    it 'does not partition the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+end