veritas 0.0.1

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/logic_connective_binary_optimize_behavior.rb

@@ -0,0 +1,100 @@
+shared_examples_for 'Logic::Connective::Binary#optimize' do
+  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 the same, after optimizing the left' do
+    let(:original_left) { attribute.gt(1)                                      }
+    let(:left)          { original_left.and(Logic::Proposition::True.instance) }
+    let(:right)         { attribute.gt(1)                                      }
+
+    it { should equal(original_left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are the same, after optimizing the right' do
+    let(:left)  { attribute.gt(1)                                        }
+    let(:right) { attribute.gt(1).and(Logic::Proposition::True.instance) }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.lt(1) }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different, after optimizing the left' do
+    let(:original_left) { attribute.gt(1)                                      }
+    let(:left)          { original_left.and(Logic::Proposition::True.instance) }
+    let(:right)         { attribute.lt(1)                                      }
+
+    add_method_missing
+
+    it { should_not equal(object) }
+
+    it { should be_instance_of(klass) }
+
+    its(:left) { should equal(original_left) }
+
+    its(:right) { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different, after optimizing the right' do
+    let(:original_right) { attribute.lt(1)                                       }
+    let(:left)           { attribute.gt(1)                                       }
+    let(:right)          { original_right.and(Logic::Proposition::True.instance) }
+
+    add_method_missing
+
+    it { should_not equal(object) }
+
+    it { should be_instance_of(klass) }
+
+    its(:left) { should equal(left) }
+
+    its(:right) { should equal(original_right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'self and right are the same, and left and right.left are the same' do
+    let(:left)  { attribute.eq(1)                                                     }
+    let(:right) { mock('Binary', :class => klass, :left => left, :optimized? => true) }
+
+    before do
+      right.stub!(:optimize => right, :frozen? => true, :memoize => right, :memoized => right)
+    end
+
+    it { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'self and left are the same, and right and left.right are the same' do
+    let(:left)  { mock('Binary', :class => klass, :right => right, :optimized? => true) }
+    let(:right) { attribute.eq(1)                                                       }
+
+    before do
+      left.stub!(:optimize => left, :frozen? => true, :memoize => left, :memoized => left)
+    end
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/shared/optimize_method_behavior.rb

@@ -0,0 +1,13 @@
+shared_examples_for 'an optimize method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'does not optimize further' do
+    optimized = subject
+    optimized.optimize.should equal(optimized)
+  end
+
+  it 'it memoizes itself for #optimize' do
+    optimized = subject
+    optimized.memoized('optimize').should equal(optimized)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'backports'
+require 'veritas'
+require 'spec'
+require 'spec/autorun'
+
+include Veritas
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+  config.extend AddMethodMissing
+end

data/spec/support/add_method_missing.rb

@@ -0,0 +1,13 @@
+module AddMethodMissing
+  def add_method_missing(name = :klass)
+    before do
+      # when #optimize delegates to super, it would normally
+      # explode, so define method_missing to return self
+      send(name).class_eval do
+        def method_missing(*)
+          self
+        end
+      end
+    end
+  end
+end

data/spec/unit/date/pred_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'Date#pred' do
+  subject { date.pred }
+
+  let(:date) { Date.today }
+
+  it 'returns the date 1 day ago' do
+    should == (date - 1)
+  end
+
+  it 'is the inverse of #succ' do
+    subject.succ.should == date
+  end
+end

data/spec/unit/range/overlaps_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+# Definitions and ascii art from ruby mailing list:
+#   http://www.ruby-forum.com/topic/98359
+
+describe 'Range#overlaps?' do
+  subject { range.overlaps?(other) }
+
+  # self:   |---|
+  # other:         |---|
+  context 'before' do
+    let(:range) { 1..4  }
+    let(:other) { 5..10 }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:          |---|
+  # other:  |---|
+  context 'after' do
+    let(:range) { 5..10 }
+    let(:other) { 1..4  }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |---|
+  # other:     |---|
+  context 'meets' do
+    let(:range) { 1..5  }
+    let(:other) { 5..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:      |---|
+  # other: |---|
+  context 'met_by' do
+    let(:range) { 5..10 }
+    let(:other) { 1..5  }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |---|
+  # other:   |---|
+  context 'overlaps' do
+    let(:range) { 1..6  }
+    let(:other) { 5..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:    |---|
+  # other: |---|
+  context 'overlapped_by' do
+    let(:range) { 5..10 }
+    let(:other) { 1..6  }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |---|
+  # other: |-----|
+  context 'starts' do
+    let(:range) { 1..5 }
+    let(:other) { 1..6 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |-----|
+  # other: |---|
+  context 'started_by' do
+    let(:range) { 1..6 }
+    let(:other) { 1..5 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:     |---|
+  # other:  |-------|
+  context 'during' do
+    let(:range) { 5..7  }
+    let(:other) { 1..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |-------|
+  # other:   |---|
+  context 'contains' do
+    let(:range) { 1..10 }
+    let(:other) { 5..7  }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:    |---|
+  # other: |-----|
+  context 'finishes' do
+    let(:range) { 5..10 }
+    let(:other) { 1..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:  |-----|
+  # other:   |---|
+  context 'finished_by' do
+    let(:range) { 1..10 }
+    let(:other) { 5..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:   |---|
+  # other:  |---|
+  context 'equals' do
+    let(:range) { 1..10 }
+    let(:other) { 1..10 }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+
+  # self:   |---|
+  # other:         |---|
+  context 'disjoint' do
+    let(:range) { 5..10 }
+    let(:other) { 1..4  }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.overlaps?(range)
+    end
+  end
+end

data/spec/unit/range/to_inclusive_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Range#to_inclusive' do
+  subject { range.to_inclusive }
+
+  context 'on an exclusive Range' do
+    context 'with values that responds to #pred' do
+      let(:range) { 1...3 }
+
+      it 'returns an inclusive Range' do
+        should == (1..2)
+      end
+    end
+
+    context 'with values that do not respond to #pred' do
+      let(:range) { 'a'...'z' }
+
+      specify { expect { subject }.to raise_error(NoMethodError) }
+    end
+  end
+
+  context 'on an inclusive Range' do
+    let(:range) { 1..2 }
+
+    it 'returns self' do
+      should equal(range)
+    end
+  end
+end

data/spec/unit/time/pred_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'Time#pred' do
+  subject { time.pred }
+
+  let(:time) { Time.now }
+
+  it 'returns the time 1 second ago' do
+    should == (time - 1)
+  end
+
+  it 'is the inverse of #succ' do
+    subject.succ.should == time
+  end
+end

data/spec/unit/veritas/abstract_class/class_methods/new_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::AbstractClass::ClassMethods#new' do
+  subject { klass.new }
+
+  context 'called on class' do
+    let(:klass) { AbstractClassSpecs::Object }
+
+    specify { expect { subject }.to raise_error(NotImplementedError, 'AbstractClassSpecs::Object is an abstract class') }
+  end
+
+  context 'called on subclass' do
+    let(:klass) { AbstractClassSpecs::Subclass }
+
+    it { should be_kind_of(AbstractClassSpecs::Subclass) }
+  end
+end

data/spec/unit/veritas/abstract_class/fixtures/classes.rb

@@ -0,0 +1,7 @@
+module AbstractClassSpecs
+  class Object
+    include AbstractClass
+  end # class Object
+
+  class Subclass < Object; end
+end # module AbstractClassSpecs

data/spec/unit/veritas/algebra/difference/each_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Difference#each' do
+  subject { difference.each { |tuple| yields << tuple } }
+
+  let(:header) { [ [ :id, Integer ] ]            }
+  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+  let(:yields) { []                              }
+
+  context 'with relations having similar bodies' do
+    let(:difference) { Algebra::Difference.new(left, left.dup) }
+
+    it { should equal(difference) }
+
+    it 'yields the difference' do
+      expect { subject }.to_not change { yields.dup }
+    end
+  end
+
+  context 'with relations having different bodies' do
+    let(:right)      { Relation.new(header, [ [ 2 ] ])      }
+    let(:difference) { Algebra::Difference.new(left, right) }
+
+    it { should equal(difference) }
+
+    it 'yields the difference' do
+      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+    end
+  end
+end

data/spec/unit/veritas/algebra/difference/methods/difference_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+[ :difference, :- ].each do |method|
+  describe "Veritas::Algebra::Difference::Methods##{method}" do
+    subject { relation.send(method, other) }
+
+    let(:header)   { [ [ :id, Integer ] ]            }
+    let(:relation) { Relation.new(header, [ [ 1 ] ]) }
+    let(:other)    { Relation.new(header, [ [ 2 ] ]) }
+
+    it { should be_kind_of(Algebra::Difference) }
+
+    it 'behaves the same as Array#-' do
+      should == (relation.to_a - other.to_a)
+    end
+  end
+end

data/spec/unit/veritas/algebra/extension/class_methods/new_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension.new' do
+  subject { object.new(operand, extensions) }
+
+  let(:operand) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ]) }
+  let(:object)  { Algebra::Extension                                   }
+
+  context 'with a duplicate attribute name provided' do
+    let(:extensions) { { :id => proc {}, :name => proc {} } }
+
+    specify { expect { subject }.to raise_error(DuplicateHeaderName, 'extensions with duplicate header names: id, name') }
+  end
+
+  context 'with a unique attribute name provided' do
+    let(:extensions) { { :unique => lambda { |tuple| 1 } } }
+
+    it { should be_kind_of(object) }
+  end
+end

data/spec/unit/veritas/algebra/extension/each_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:klass)      { Algebra::Extension                                   }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
+  let(:object)     { klass.new(operand, extensions)                       }
+  let(:yields)     { []                                                   }
+
+  it { should equal(object) }
+
+  it 'yields each tuple' do
+    expect { subject }.to change { yields.dup }.from([]).to([ [ 1, 1 ], [ 2, 1 ] ])
+  end
+end

data/spec/unit/veritas/algebra/extension/extensions_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension#extensions' do
+  subject { object.extensions }
+
+  let(:klass)      { Algebra::Extension                                   }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
+  let(:object)     { klass.new(operand, extensions)                       }
+
+  it { should equal(extensions) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/extension/header_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension#header' do
+  subject { object.header }
+
+  let(:klass)      { Algebra::Extension                                   }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
+  let(:object)     { klass.new(operand, extensions)                       }
+
+  it { should be_kind_of(Relation::Header) }
+
+  it { should == [ [ :id, Integer ], [ :test, Object ] ] }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/extension/methods/extend_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension::Methods#extend' do
+  subject { object.extend(&block) }
+
+  let(:klass)      { Relation                                   }
+  let(:extensions) { [ :test, lambda { |tuple| 1 } ]            }
+  let(:block)      { lambda { |r| r.add(*extensions) }          }
+  let(:object)     { klass.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  it { should be_kind_of(Algebra::Extension) }
+
+  its(:operand) { should equal(object) }
+end

data/spec/unit/veritas/algebra/extension/operand_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Extension#operand' do
+  subject { object.operand }
+
+  let(:klass)      { Algebra::Extension                                   }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
+  let(:object)     { klass.new(operand, extensions)                       }
+
+  it { should equal(operand) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/intersection/each_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Intersection#each' do
+  subject { intersection.each { |tuple| yields << tuple } }
+
+  let(:header) { [ [ :id, Integer ] ]            }
+  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+  let(:yields) { []                              }
+
+  context 'with relations having similar bodies' do
+    let(:intersection) { Algebra::Intersection.new(left, left.dup) }
+
+    it { should equal(intersection) }
+
+    it 'yields the intersection' do
+      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+    end
+  end
+
+  context 'with relations having different bodies' do
+    let(:right)        { Relation.new(header, [ [ 2 ] ])        }
+    let(:intersection) { Algebra::Intersection.new(left, right) }
+
+    it { should equal(intersection) }
+
+    it 'yields the intersection' do
+      expect { subject }.to_not change { yields.dup }
+    end
+  end
+end

data/spec/unit/veritas/algebra/intersection/methods/intersect_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+[ :intersect, :& ].each do |method|
+  describe "Veritas::Algebra::Intersection::Methods##{method}" do
+    subject { relation.send(method, other) }
+
+    let(:header)   { [ [ :id, Integer ] ]            }
+    let(:relation) { Relation.new(header, [ [ 1 ] ]) }
+    let(:other)    { Relation.new(header, [ [ 2 ] ]) }
+
+    it { should be_kind_of(Algebra::Intersection) }
+
+    it 'behaves the same as Array#&' do
+      should == (relation.to_a & other.to_a)
+    end
+  end
+end

data/spec/unit/veritas/algebra/join/class_methods/new_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Join.new' do
+  subject { Algebra::Join.new(left, right) }
+
+  let(:header) { [ [ :id, Integer ] ]                   }
+  let(:left)   { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
+
+  context 'with relations having headers with common attributes' do
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+
+    specify { expect { subject }.to_not raise_error }
+  end
+
+  context 'with relations having equivalent headers' do
+    let(:right) { left.dup }
+
+    specify { expect { subject }.to_not raise_error }
+  end
+
+  context 'with relations having different headers' do
+    let(:right) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must have common attributes for Veritas::Algebra::Join.new') }
+  end
+end

data/spec/unit/veritas/algebra/join/each_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Join#each' do
+  subject { join.each { |tuple| yields << tuple } }
+
+  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                         }
+  let(:right)  { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+  let(:join)   { Algebra::Join.new(left, right)                                               }
+  let(:yields) { []                                                                           }
+
+  it { should equal(join) }
+
+  it 'yields the join' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 2, 'Dan Kubb' ] ])
+  end
+end