RubyGems - veritas - Versions diffs - 0.0.2 → 0.0.3 - Mend

veritas 0.0.2 → 0.0.3

Files changed (669) hide show

data/spec/integration/veritas/algebra/union/optimize_spec.rb DELETED Viewed

@@ -1,193 +0,0 @@
-require 'spec_helper'
-describe 'Veritas::Algebra::Union#optimize' do
-  subject { object.optimize }
-  let(:klass)          { Algebra::Union                   }
-  let(:header)         { [ [ :id, Integer ] ]             }
-  let(:left_body)      { [ [ 1 ] ].each                   }
-  let(:right_body)     { [ [ 2 ] ].each                   }
-  let(:original_left)  { Relation.new(header, left_body)  }
-  let(:original_right) { Relation.new(header, right_body) }
-  let(:object)         { klass.new(left, right)           }
-  context 'left is an empty relation' do
-    let(:left)  { Relation::Empty.new(header) }
-    let(:right) { original_right              }
-    it { should equal(right) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'does not execute left_body#each' do
-      left_body.should_not_receive(:each)
-      subject
-    end
-    it 'does not execute right_body#each' do
-      right_body.should_not_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is an empty relation' do
-    let(:left)  { original_left               }
-    let(:right) { Relation::Empty.new(header) }
-    it { should equal(left) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'does not execute left_body#each' do
-      left_body.should_not_receive(:each)
-      subject
-    end
-    it 'does not execute right_body#each' do
-      right_body.should_not_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an empty relation when optimized' do
-    let(:left)  { Algebra::Restriction.new(original_left, Logic::Proposition::False.instance) }
-    let(:right) { original_right                                                              }
-    it { should equal(right) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'does not execute left_body#each' do
-      left_body.should_not_receive(:each)
-      subject
-    end
-    it 'does not execute right_body#each' do
-      right_body.should_not_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is an empty relation when optimized' do
-    let(:left)  { original_left                                                                }
-    let(:right) { Algebra::Restriction.new(original_right, Logic::Proposition::False.instance) }
-    it { should equal(left) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'does not execute left_body#each' do
-      left_body.should_not_receive(:each)
-      subject
-    end
-    it 'does not execute right_body#each' do
-      right_body.should_not_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are equivalent relations' do
-    let(:left_body)  { [ [ 1 ] ].each }
-    let(:right_body) { [ [ 1 ] ].each }
-    let(:left)       { original_left  }
-    let(:right)      { original_right }
-    it { should equal(left) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'does not execute left_body#each' do
-      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
-        left_body.should_not_receive(:each)
-        subject
-      end
-    end
-    it 'does not execute right_body#each' do
-      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
-        right_body.should_not_receive(:each)
-        subject
-      end
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are equivalent materialized relations' do
-    let(:left_body)  { [ [ 1 ] ]      }
-    let(:right_body) { [ [ 1 ] ]      }
-    let(:left)       { original_left  }
-    let(:right)      { original_right }
-    it { should equal(left) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it 'executes left_body#each' do
-      pending 'only receive #each once'
-      left_body.should_receive(:each)
-      subject
-    end
-    it 'executes right_body#each' do
-      pending 'only receive #each once'
-      right_body.should_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are not empty relations' do
-    let(:left)  { original_left  }
-    let(:right) { original_right }
-    it { should equal(object) }
-    it 'executes left_body#each' do
-      left_body.should_receive(:each)
-      subject
-    end
-    it 'executes right_body#each' do
-      right_body.should_receive(:each)
-      subject
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are materialized relations' do
-    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-    let(:right) { Relation.new(header, [ [ 1 ] ])        }
-    it { should eql(Relation::Materialized.new(header, [ [ 1 ], [ 2 ] ])) }
-    it 'returns an equivalent relation to the unoptimized operation' do
-      should == object
-    end
-    it_should_behave_like 'an optimize method'
-  end
-end

data/spec/integration/veritas/logic/connective/conjunction/optimize_spec.rb DELETED Viewed

@@ -1,235 +0,0 @@
-require 'spec_helper'
-describe 'Veritas::Logic::Connective::Conjunction#optimize' do
-  subject { object.optimize }
-  let(:klass)     { Logic::Connective::Conjunction }
-  let(:attribute) { Attribute::Integer.new(:id)    }
-  let(:object)    { klass.new(left, right)         }
-  it_should_behave_like 'Logic::Connective::Binary#optimize'
-  context 'left and right are predicates' do
-    let(:left)  { attribute.gt(1) }
-    let(:right) { attribute.lt(3) }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are inverse predicates' do
-    let(:left)  { Logic::Connective::Negation.new(attribute.gt(1)) }
-    let(:right) { Logic::Connective::Negation.new(attribute.lt(3)) }
-    it { should_not equal(object) }
-    it 'reverses the operands' do
-      should eql(klass.new(attribute.lte(1), attribute.gte(3)))
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are the same' do
-    let(:left)  { attribute.gt(1) }
-    let(:right) { attribute.gt(1) }
-    it { should eql(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are true propositions' do
-    let(:left)  { Logic::Proposition::True.instance }
-    let(:right) { Logic::Proposition::True.instance }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are false propositions' do
-    let(:left)  { Logic::Proposition::False.instance }
-    let(:right) { Logic::Proposition::False.instance }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is a true proposition' do
-    let(:left)  { attribute.gt(1)                   }
-    let(:right) { Logic::Proposition::True.instance }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a true proposition' do
-    let(:left)  { Logic::Proposition::True.instance }
-    let(:right) { attribute.lt(3)                   }
-    it { should equal(right) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is a false proposition' do
-    let(:left)  { attribute.gt(1)                    }
-    let(:right) { Logic::Proposition::False.instance }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a false proposition' do
-    let(:left)  { Logic::Proposition::False.instance }
-    let(:right) { attribute.lt(3)                    }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are Equality predicates for the same attribute and different values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(3) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are Inequality predicates for the same attribute and different values' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.ne(3) }
-    it { should eql(attribute.exclude([ 1, 3 ])) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Equality and right is an Inequality predicate for the same attribute and value' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Inequality and right is an Equality predicate for the same attribute and value' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.eq(1) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.include([ 1, 2 ]) }
-    let(:right) { attribute.exclude([ 1, 2 ]) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.exclude([ 1, 2 ]) }
-    let(:right) { attribute.include([ 1, 2 ]) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a GreaterThan and right is a LessThanOrEqualTo predicate for the same attribute and value' do
-    let(:left)  { attribute.gt(1)  }
-    let(:right) { attribute.lte(1) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an LessThanOrEqualTo and right is an GreaterThan predicate for the same attribute and value' do
-    let(:left)  { attribute.lte(1) }
-    let(:right) { attribute.gt(1)  }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a GreaterThanOrEqualTo and right is a LessThan predicate for the same attribute and value' do
-    let(:left)  { attribute.gte(1) }
-    let(:right) { attribute.lt(1)  }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an LessThan and right is an GreaterThanOrEqualTo predicate for the same attribute and value' do
-    let(:left)  { attribute.lt(1)  }
-    let(:right) { attribute.gte(1) }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a Match and right is a NoMatch predicate for the same attribute and value' do
-    let(:attribute)   { Attribute::String.new(:name) }
-    let(:left)  { attribute.match(/Dan Kubb/)        }
-    let(:right) { attribute.no_match(/Dan Kubb/)     }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an NoMatch and right is an Match predicate for the same attribute and value' do
-    let(:attribute)   { Attribute::String.new(:name) }
-    let(:left)  { attribute.no_match(/Dan Kubb/)     }
-    let(:right) { attribute.match(/Dan Kubb/)        }
-    it { should equal(Logic::Proposition::False.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute and the same values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(1) }
-    it { should eql(attribute.eq(1)) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute, but left.right is an attribute' do
-    let(:other) { Attribute::Integer.new(:other_id) }
-    let(:left)  { attribute.eq(other)               }
-    let(:right) { attribute.eq(1)                   }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute, but right.right is an attribute' do
-    let(:other) { Attribute::Integer.new(:other_id) }
-    let(:left)  { attribute.eq(1)                   }
-    let(:right) { attribute.eq(other)               }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-end

data/spec/integration/veritas/logic/connective/disjunction/optimize_spec.rb DELETED Viewed

@@ -1,236 +0,0 @@
-require 'spec_helper'
-describe 'Veritas::Logic::Connective::Disjunction#optimize' do
-  subject { object.optimize }
-  let(:klass)     { Logic::Connective::Disjunction }
-  let(:attribute) { Attribute::Integer.new(:id)    }
-  let(:object)    { klass.new(left, right)         }
-  it_should_behave_like 'Logic::Connective::Binary#optimize'
-  context 'left and right are predicates' do
-    let(:left)  { attribute.gt(1) }
-    let(:right) { attribute.lt(3) }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are inverse predicates' do
-    let(:left)  { Logic::Connective::Negation.new(attribute.gt(1)) }
-    let(:right) { Logic::Connective::Negation.new(attribute.lt(3)) }
-    it { should_not equal(object) }
-    it 'reverses the operands' do
-      should eql(Logic::Connective::Disjunction.new(attribute.lte(1), attribute.gte(3)))
-    end
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are the same' do
-    let(:left)  { attribute.gt(1) }
-    let(:right) { attribute.gt(1) }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are true propositions' do
-    let(:left)  { Logic::Proposition::True.instance }
-    let(:right) { Logic::Proposition::True.instance }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are false propositions' do
-    let(:left)  { Logic::Proposition::False.instance }
-    let(:right) { Logic::Proposition::False.instance }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is a true proposition' do
-    let(:left)  { attribute.gt(1)                   }
-    let(:right) { Logic::Proposition::True.instance }
-    it { should equal(right) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a true proposition' do
-    let(:left)  { Logic::Proposition::True.instance }
-    let(:right) { attribute.lt(3)                   }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'right is a false proposition' do
-    let(:left)  { attribute.gt(1)                    }
-    let(:right) { Logic::Proposition::False.instance }
-    it { should equal(left) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a false proposition' do
-    let(:left)  { Logic::Proposition::False.instance }
-    let(:right) { attribute.lt(3)                    }
-    it { should equal(right) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are Equality predicates for the same attribute and different values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(3) }
-    it { should eql(attribute.include([ 1, 3 ])) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are Inequality predicates for the same attribute and different values' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.ne(3) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Equality and right is an Inequality predicate for the same attribute and value' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Inequality and right is an Equality predicate for the same attribute and value' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.eq(1) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Inclusion and right is an Exclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.include([ 1, 2 ]) }
-    let(:right) { attribute.exclude([ 1, 2 ]) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an Exclusion and right is an Inclusion predicate for the same attribute and value' do
-    let(:left)  { attribute.exclude([ 1, 2 ]) }
-    let(:right) { attribute.include([ 1, 2 ]) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a GreaterThan and right is a LessThanOrEqualTo predicate for the same attribute and value' do
-    let(:left)  { attribute.gt(1)  }
-    let(:right) { attribute.lte(1) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an LessThanOrEqualTo and right is an GreaterThan predicate for the same attribute and value' do
-    let(:left)  { attribute.lte(1) }
-    let(:right) { attribute.gt(1)  }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a GreaterThanOrEqualTo and right is a LessThan predicate for the same attribute and value' do
-    let(:left)  { attribute.gte(1) }
-    let(:right) { attribute.lt(1)  }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an LessThan and right is an GreaterThanOrEqualTo predicate for the same attribute and value' do
-    let(:left)  { attribute.lt(1)  }
-    let(:right) { attribute.gte(1) }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is a Match and right is a NoMatch predicate for the same attribute and value' do
-    let(:attribute)   { Attribute::String.new(:name) }
-    let(:left)  { attribute.match(/Dan Kubb/)        }
-    let(:right) { attribute.no_match(/Dan Kubb/)     }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left is an NoMatch and right is an Match predicate for the same attribute and value' do
-    let(:attribute) { Attribute::String.new(:name)   }
-    let(:left)      { attribute.no_match(/Dan Kubb/) }
-    let(:right)     { attribute.match(/Dan Kubb/)    }
-    it { should equal(Logic::Proposition::True.instance) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute and the same values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(1) }
-    it { should eql(attribute.eq(1)) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute, but left.right is an attribute' do
-    let(:other) { Attribute::Integer.new(:other_id) }
-    let(:left)  { attribute.eq(other)               }
-    let(:right) { attribute.eq(1)                   }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-  context 'left and right are predicates for the same attribute, but right.right is an attribute' do
-    let(:other) { Attribute::Integer.new(:other_id) }
-    let(:left)  { attribute.eq(1)                   }
-    let(:right) { attribute.eq(other)               }
-    it { should equal(object) }
-    it_should_behave_like 'an optimize method'
-  end
-end