veritas-optimizer 0.0.3

data/spec/integration/veritas/logic/expression/optimize_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Logic::Expression, '#optimize' do
+  subject { object.optimize(*args) }
+
+  let(:described_class) { Class.new(Logic::Expression) }
+  let(:object)          { described_class.new          }
+
+  before do
+    described_class.class_eval do
+      def eql?(other)
+        instance_of?(other.class)
+      end
+    end
+  end
+
+  context 'with no optimizer' do
+    let(:args) { [] }
+
+    it 'calls self.class.optimizer' do
+      described_class.should_receive(:optimizer).and_return(nil)
+      subject
+    end
+
+    it 'returns self' do
+      should equal(object)
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an optimizer' do
+    let(:optimized) { described_class.new                 }
+    let(:args)      { [ lambda { |relation| optimized } ] }
+
+    it 'returns an optimized expression' do
+      should equal(optimized)
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/predicate/equality/optimize_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Logic::Predicate::Equality, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:left)      { attribute                        }
+  let(:right)     { attribute                        }
+  let(:object)    { described_class.new(left, right) }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not joinable' do
+      let(:right) { Attribute::String.new(:other) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are joinable' do
+      let(:right) { Attribute::Numeric.new(:other) }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid value' do
+      let(:right) { 'a' }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(described_class.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid value' do
+      let(:left) { 'a' }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 1 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 1 }
+      let(:right) { 2 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end

data/spec/integration/veritas/logic/predicate/exclusion/optimize_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Logic::Predicate::Exclusion, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)   { Attribute::Integer.new(:id)      }
+  let(:object) { described_class.new(left, right) }
+
+  context 'right is a Range' do
+    context 'that is inclusive' do
+      context 'and empty' do
+        let(:right) { 1..0 }
+
+        it { should equal(Logic::Proposition::Tautology.instance) }
+
+        it_should_behave_like 'an optimize method'
+      end
+
+      context 'and not empty' do
+        let(:right) { 1..10 }
+
+        it { should equal(object) }
+
+        it_should_behave_like 'an optimize method'
+      end
+    end
+
+    context 'that is exclusive' do
+      context 'and empty' do
+        let(:right) { 1...1 }
+
+        it { should equal(Logic::Proposition::Tautology.instance) }
+
+        it_should_behave_like 'an optimize method'
+      end
+
+      context 'and not empty' do
+        let(:right) { 1...10 }
+
+        it 'changes the Range to be inclusive' do
+          should eql(left.exclude(1..9))
+        end
+
+        it_should_behave_like 'an optimize method'
+      end
+    end
+
+    context 'using an attribute that is not comparable' do
+      let(:left)  { Attribute::String.new(:string) }
+      let(:right) { 'a'..'z'                       }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is greater than the left range' do
+      let(:right) { 2**31..2**31 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is less than the left range' do
+      let(:right) { -1..-1 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an Enumerable' do
+    context 'that is empty' do
+      let(:right) { [] }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is empty after filtering invalid entries' do
+      let(:right) { [ 'a' ] }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is not empty after filtering invalid entries' do
+      let(:right) { [ 'a', 1, 2 ] }
+
+      it { should eql(left.exclude([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has duplicate entries' do
+      let(:right) { [ 1, 2, 2 ] }
+
+      it { should eql(left.exclude([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has one entry' do
+      let(:right) { [ 1 ] }
+
+      it { should eql(left.ne(1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has unsorted entries' do
+      let(:right) { [ 2, 1 ] }
+
+      it { should eql(left.exclude([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is a nil' do
+    let(:right) { nil }
+
+    it { should equal(Logic::Proposition::Tautology.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/predicate/greater_than/optimize_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Logic::Predicate::GreaterThan, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+  let(:left)      { attribute                                       }
+  let(:right)     { attribute                                       }
+  let(:object)    { described_class.new(left, right)                }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not comparable' do
+      let(:right) { Attribute::Float.new(:float) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always less than or equal to right' do
+      let(:left)  { attribute                                                 }
+      let(:right) { Attribute::Integer.new(:right, :size => 2**31-1..2**31-1) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always greater than right' do
+      let(:left)  { attribute                                       }
+      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid primitive' do
+      let(:right) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(Logic::Predicate::LessThan.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid primitive' do
+      let(:left) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 2 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 1 }
+      let(:right) { 2 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end

data/spec/integration/veritas/logic/predicate/greater_than_or_equal_to/optimize_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+  let(:left)      { attribute                                       }
+  let(:right)     { attribute                                       }
+  let(:object)    { described_class.new(left, right)                }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not comparable' do
+      let(:right) { Attribute::Float.new(:float) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always less than right' do
+      let(:left)  { attribute                                             }
+      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always greater than right' do
+      let(:left)  { attribute                                       }
+      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid primitive' do
+      let(:right) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(Logic::Predicate::LessThanOrEqualTo.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid primitive' do
+      let(:left) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 1 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 1 }
+      let(:right) { 2 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end

data/spec/integration/veritas/logic/predicate/inclusion/optimize_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Logic::Predicate::Inclusion, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)   { Attribute::Integer.new(:id)      }
+  let(:object) { described_class.new(left, right) }
+
+  context 'right is a Range' do
+    context 'that is inclusive' do
+      context 'and empty' do
+        let(:right) { 1..0 }
+
+        it { should equal(Logic::Proposition::Contradiction.instance) }
+
+        it_should_behave_like 'an optimize method'
+      end
+
+      context 'and not empty' do
+        let(:right) { 1..10 }
+
+        it { should equal(object) }
+
+        it_should_behave_like 'an optimize method'
+      end
+    end
+
+    context 'that is exclusive' do
+      context 'and empty' do
+        let(:right) { 1...1 }
+
+        it { should equal(Logic::Proposition::Contradiction.instance) }
+
+        it_should_behave_like 'an optimize method'
+      end
+
+      context 'and not empty' do
+        let(:right) { 1...10 }
+
+        it 'changes the Range to be inclusive' do
+          should eql(left.include(1..9))
+        end
+
+        it_should_behave_like 'an optimize method'
+      end
+    end
+
+    context 'using an attribute that is not comparable' do
+      let(:left)  { Attribute::String.new(:string) }
+      let(:right) { 'a'..'z'                       }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is greater than the left range' do
+      let(:right) { 2**31..2**31 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is less than the left range' do
+      let(:right) { -1..-1 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an Enumerable' do
+    context 'that is empty' do
+      let(:right) { [] }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is empty after filtering invalid entries' do
+      let(:right) { [ 'a' ] }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that is not empty after filtering invalid entries' do
+      let(:right) { [ 'a', 1, 2 ] }
+
+      it { should eql(left.include([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has duplicate entries' do
+      let(:right) { [ 1, 2, 2 ] }
+
+      it { should eql(left.include([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has one entry' do
+      let(:right) { [ 1 ] }
+
+      it { should eql(left.eq(1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that has unsorted entries' do
+      let(:right) { [ 2, 1 ] }
+
+      it { should eql(left.include([ 1, 2 ])) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is a nil' do
+    let(:right) { nil }
+
+    it { should equal(Logic::Proposition::Contradiction.instance) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/logic/predicate/inequality/optimize_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Logic::Predicate::Inequality, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:left)      { attribute                        }
+  let(:right)     { attribute                        }
+  let(:object)    { described_class.new(left, right) }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not joinable' do
+      let(:right) { Attribute::String.new(:other) }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are joinable' do
+      let(:right) { Attribute::Numeric.new(:other) }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid value' do
+      let(:right) { 'a' }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(described_class.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid value' do
+      let(:left) { 'a' }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 1 }
+      let(:right) { 2 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 1 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end