veritas 0.0.1 → 0.0.2

data/spec/unit/veritas/optimizer/relation/operation/offset/unoptimized_operand/optimizable_spec.rb

@@ -14,7 +14,7 @@ describe 'Veritas::Optimizer::Relation::Operation::Offset::UnoptimizedOperand#op
   end
 
   context 'when the operand is optimizable' do
-    let(:operand) { base.project(header) }
+    let(:operand) { base.rename({}) }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/relation/operation/offset/unoptimized_operand/optimize_spec.rb

@@ -6,14 +6,16 @@ describe 'Veritas::Optimizer::Relation::Operation::Offset::UnoptimizedOperand#op
   let(:klass)    { Optimizer::Relation::Operation::Offset::UnoptimizedOperand }
   let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                 }
   let(:order)    { Relation.new(header, [ [ 1 ] ].each).order                 }
-  let(:relation) { order.project(header).drop(1)                              }
+  let(:relation) { order.rename({}).drop(1)                                   }
   let(:object)   { klass.new(relation)                                        }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Offset)
   end
 
-  it { should eql(order.drop(1)) }
+  it { should be_kind_of(Relation::Operation::Offset) }
 
   its(:operand) { should equal(order) }
+
+  its(:offset) { should == 1 }
 end

data/spec/unit/veritas/optimizer/relation/operation/order/order_operand/optimize_spec.rb

@@ -13,7 +13,9 @@ describe 'Veritas::Optimizer::Relation::Operation::Order::OrderOperand#optimize'
     object.operation.should be_kind_of(Relation::Operation::Order)
   end
 
-  it { should eql(base.order(order.directions.reverse)) }
+  it { should be_kind_of(Relation::Operation::Order) }
 
   its(:operand) { should equal(base) }
+
+  its(:directions) { should eql(order.directions.reverse) }
 end

data/spec/unit/veritas/optimizer/relation/operation/order/unoptimized_operand/optimizable_spec.rb

@@ -14,7 +14,7 @@ describe 'Veritas::Optimizer::Relation::Operation::Order::UnoptimizedOperand#opt
   end
 
   context 'when the operand is optimizable' do
-    let(:operand) { base.project(header) }
+    let(:operand) { base.rename({}) }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/relation/operation/order/unoptimized_operand/optimize_spec.rb

@@ -12,9 +12,11 @@ describe 'Veritas::Optimizer::Relation::Operation::Order::UnoptimizedOperand#opt
     object.operation.should be_kind_of(Relation::Operation::Order)
   end
 
-  it { should_not equal(relation) }
+  it { should be_kind_of(Relation::Operation::Order) }
 
-  it { should eql(relation) }
+  it { should_not equal(relation) }
 
   its(:operand) { should equal(base) }
+
+  its(:directions) { should equal(relation.directions) }
 end

data/spec/unit/veritas/optimizer/relation/operation/reverse/order_operand/optimize_spec.rb

@@ -13,5 +13,9 @@ describe 'Veritas::Optimizer::Relation::Operation::Reverse::OrderOperand#optimiz
     object.operation.should be_kind_of(Relation::Operation::Reverse)
   end
 
-  it { should eql(base.order(relation.directions)) }
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  its(:operand) { should equal(base) }
+
+  its(:directions) { should equal(relation.directions) }
 end

data/spec/unit/veritas/optimizer/relation/operation/reverse/unoptimized_operand/optimize_spec.rb

@@ -4,7 +4,8 @@ describe 'Veritas::Optimizer::Relation::Operation::Reverse::UnoptimizedOperand#o
   subject { object.optimize }
 
   let(:klass)    { Optimizer::Relation::Operation::Reverse::UnoptimizedOperand }
-  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order    }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each)          }
+  let(:order)    { base.order                                                  }
   let(:relation) { order.reverse                                               }
   let(:object)   { klass.new(relation)                                         }
 
@@ -12,9 +13,11 @@ describe 'Veritas::Optimizer::Relation::Operation::Reverse::UnoptimizedOperand#o
     object.operation.should be_kind_of(Relation::Operation::Reverse)
   end
 
+  it { should be_kind_of(Relation::Operation::Order) }
+
   it { should_not equal(relation) }
 
-  it { should eql(relation) }
+  its(:operand) { should equal(base) }
 
-  its(:operand) { should equal(order) }
+  its(:directions) { should eql(relation.directions) }
 end

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

@@ -1,36 +1,32 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation.new' do
-  subject { Relation.new(header, tuples) }
+  subject { object.new(header, body) }
 
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:object) { Relation                                   }
 
   context 'with an Enumerable responding to #size' do
-    let(:tuples) { [ [ 1 ] ] }
+    let(:body) { [ [ 1 ] ] }
 
     before do
-      tuples.should respond_to(:size)
+      body.should respond_to(:size)
     end
 
-    it { should be_instance_of(Relation::Materialized) }
+    it { should be_kind_of(Relation::Materialized) }
 
-    it { should == tuples }
+    it { should == body }
   end
 
   context 'with an Enumerable that does not respond to #size' do
-    let(:range) { 1..5 }
-    let(:tuples) do
-      Enumerator.new do |yielder|
-        range.each { |n| yielder.yield [ n ] }
-      end
-    end
+    let(:body) { [ [ 1 ] ].each }  # use an Enumerator
 
     before do
-      tuples.should_not respond_to(:size)
+      body.should_not respond_to(:size)
     end
 
-    it { should be_instance_of(Relation) }
+    it { should be_kind_of(object) }
 
-    it { should == range.map { |n| [ n ] } }
+    it { should == [ [ 1 ] ] }
   end
 end

data/spec/unit/veritas/relation/directions_spec.rb

@@ -1,13 +1,19 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#directions' do
-  subject { relation.directions }
+  subject { object.directions }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:klass)  { Relation                              }
+  let(:body)   { [ [ 1 ] ].each                        }  # use an Enumerator
+  let(:object) { klass.new([ [ :id, Integer ] ], body) }
+
+  before do
+    object.should be_instance_of(klass)
+  end
+
+  it_should_behave_like 'an idempotent method'
 
   it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
 
   it { should be_empty }
-
-  it_should_behave_like 'an idempotent method'
 end

data/spec/unit/veritas/relation/each_spec.rb

@@ -1,26 +1,41 @@
 require 'spec_helper'
 
-describe 'Veritas::Relation' do
-  subject { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+describe 'Veritas::Relation#each' do
+  subject { object.each { |tuple| yields << tuple } }
 
-  it { should be_kind_of(Enumerable) }
+  let(:klass)  { Relation                                   }
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:body)   { [ [ 1 ], [ 2 ], [ 2 ] ].each               }  # use an Enumerator
+  let(:object) { klass.new(header, body)                    }
+  let(:yields) { []                                         }
 
-  it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
+  before do
+    object.should be_instance_of(klass)
+  end
+
+  it_should_behave_like 'a command method'
+
+  it 'yields each tuple' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 1 ], [ 2 ] ])
   end
 end
 
-describe 'Veritas::Relation#each' do
-  subject { relation.each { |tuple| yields << tuple } }
+describe 'Veritas::Relation' do
+  subject { object.new(header, body) }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuples)   { [ [ 1 ], [ 2 ], [ 2 ] ]                    }
-  let(:relation) { Relation.new(header, tuples)               }
-  let(:yields)   { []                                         }
+  let(:header) { [ [ :id, Integer ] ] }
+  let(:body)   { [ [ 1 ] ].each       }
+  let(:object) { Relation             }
 
-  it { should equal(relation) }
+  before do
+    subject.should be_instance_of(object)
+  end
 
-  it 'yields each tuple only once' do
-    expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ], [ 2 ] ])
+  it { should be_kind_of(Enumerable) }
+
+  it 'case matches Enumerable' do
+    (Enumerable === subject).should be(true)
   end
 end

data/spec/unit/veritas/relation/element_reference_spec.rb

@@ -1,12 +1,16 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#[]' do
-  subject { relation[:id] }
+  subject { object[name] }
 
-  let(:header)   { [ [ :id, Integer ] ]     }
-  let(:relation) { Relation.new(header, []) }
+  let(:klass)     { Relation                          }
+  let(:name)      { :id                               }
+  let(:attribute) { Attribute::Integer.new(name)      }
+  let(:object)    { klass.new([ attribute ], [].each) }
 
-  it { should be_kind_of(Attribute::Integer) }
+  before do
+    object.should be_instance_of(klass)
+  end
 
-  it { should == [ :id, Integer ] }
+  it { should equal(attribute) }
 end

data/spec/unit/veritas/relation/empty/each_spec.rb

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Empty#each' do
-  subject { empty.each { |tuple| yields << tuple } }
+  subject { object.each { |tuple| yields << tuple } }
 
-  let(:empty)  { Relation::Empty.new([ [ :id, Integer ] ]) }
-  let(:yields) { []                                        }
+  let(:klass)  { Relation::Empty                 }
+  let(:object) { klass.new([ [ :id, Integer ] ]) }
+  let(:yields) { []                              }
 
-  it { should equal(empty) }
+  it_should_behave_like 'a command method'
 
-  it 'does not yield any tuples' do
+  it 'yields no tuples' do
     expect { subject }.to_not change { yields.dup }
   end
 end

data/spec/unit/veritas/relation/empty/empty_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Empty#empty?' do
-  subject { empty.empty? }
+  subject { object.empty? }
 
-  let(:empty) { Relation::Empty.new([ [ :id, Integer ] ]) }
+  let(:klass)  { Relation::Empty                 }
+  let(:object) { klass.new([ [ :id, Integer ] ]) }
 
   it { should be(true) }
 end

data/spec/unit/veritas/relation/empty/header_spec.rb

@@ -1,11 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Empty#header' do
-  subject { empty.header }
+  subject { object.header }
 
-  let(:empty) { Relation::Empty.new([ [ :id, Integer ] ]) }
-
-  it { should == [ [ :id, Integer ] ] }
+  let(:klass)  { Relation::Empty                            }
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:object) { klass.new(header)                          }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
 end

data/spec/unit/veritas/relation/empty_spec.rb

@@ -1,10 +1,15 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#empty?' do
-  subject { relation.empty? }
+  subject { object.empty? }
 
-  let(:header)   { [ [ :id, Integer ] ]       }
-  let(:relation) { Relation.new(header, body) }
+  let(:klass)  { Relation                }
+  let(:header) { [ [ :id, Integer ] ]    }
+  let(:object) { klass.new(header, body) }
+
+  before do
+    object.should be_instance_of(klass)
+  end
 
   context 'with a body containing no entries' do
     let(:body) { [].each }  # use an Enumerator

data/spec/unit/veritas/relation/eql_spec.rb

@@ -1,49 +1,83 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#eql?' do
-  subject { relation.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:header)   { [ [ :id, Integer ] ]         }
-  let(:tuples)   { [ [ 1 ] ]                    }
-  let(:relation) { Relation.new(header, tuples) }
+  let(:klass)  { Relation                }
+  let(:header) { [ [ :id, Integer ] ]    }
+  let(:body)   { [ [ 1 ] ].each          }  # use an Enumerator
+  let(:object) { klass.new(header, body) }
 
-  context 'with the same relation' do
-    let(:other) { relation }
+  before do
+    object.should be_instance_of(klass)
+  end
+
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(relation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent relation' do
-    let(:other) { relation.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(relation)
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(Relation).new(header, body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different relation' do
-    let(:other) { Relation.new(header, [ [ 2 ] ]) }
+  context 'with an object having a different header' do
+    let(:other_header) { [ [ :id, Numeric ] ]                   }
+    let(:other_body)   { body                                   }
+    let(:other)        { Relation.new(other_header, other_body) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(relation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent relation of a different class' do
-    let(:other) { Class.new(Relation).new(header, tuples) }
+  context 'with an object having a different body' do
+    let(:other_header) { header                                 }
+    let(:other_body)   { [ [ 2 ] ].each                         }
+    let(:other)        { Relation.new(other_header, other_body) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(relation)
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an object having an equivalent header in a different order' do
+    let(:attribute1) { [ :id,   Integer ]                               }
+    let(:attribute2) { [ :name, String  ]                               }
+    let(:header1)    { Relation::Header.new([ attribute1, attribute2 ]) }
+    let(:header2)    { Relation::Header.new([ attribute2, attribute1 ]) }
+    let(:object)     { klass.new(header1, [ [ 1, 'Dan Kubb' ] ].each)   }
+    let(:other)      { klass.new(header2, [ [ 'Dan Kubb', 1 ] ].each)   }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
     end
   end
 end

data/spec/unit/veritas/relation/equal_value_spec.rb

@@ -1,96 +1,105 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#==' do
-  subject { relation == other }
+  subject { object == other }
 
-  let(:header)   { [ [ :id, Integer ] ]         }
-  let(:tuples)   { [ [ 1 ] ]                    }
-  let(:relation) { Relation.new(header, tuples) }
+  let(:klass)  { Relation                }
+  let(:header) { [ [ :id, Integer ] ]    }
+  let(:body)   { [ [ 1 ] ].each          }  # use an Enumerator
+  let(:object) { klass.new(header, body) }
 
-  context 'with the same relation' do
-    let(:other) { relation }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should == (other == relation)
-    end
+  before do
+    object.should be_instance_of(klass)
   end
 
-  context 'with an equivalent relation' do
-    let(:other) { relation.dup }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent header and different tuples' do
-    let(:other) { Relation.new(header, [ [ 2 ] ]) }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
-    it { should be(false) }
+    it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      should == (other == object)
     end
   end
 
-  context 'with a different header' do
-    let(:other) { Relation.new([ [ :name, String ] ], relation) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(header, body) }
 
-    it { should be(false) }
+    it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent object responding to #to_set' do
-    let(:other) { Set[ [ 1 ] ] }
+  context 'with an object having a different header' do
+    let(:other_header) { [ [ :id, Numeric ] ]                   }
+    let(:other_body)   { body                                   }
+    let(:other)        { Relation.new(other_header, other_body) }
 
-    it { should be(true) }
+    it { should be(false) }
 
     it 'is symmetric' do
-      pending 'Set#== should call to_set on other' do
-        should == (other == relation)
-      end
+      should == (other == object)
     end
   end
 
-  context 'with a different object responding to #to_set' do
-    let(:other) { Set[ [ 2 ] ] }
+  context 'with an object having a different body' do
+    let(:other_header) { header                                 }
+    let(:other_body)   { [ [ 2 ] ].each                         }
+    let(:other)        { Relation.new(other_header, other_body) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent header and equivalent tuples with attributes in a different order' do
+  context 'with an object having an equivalent header in a different order' do
     let(:attribute1) { [ :id,   Integer ]                               }
     let(:attribute2) { [ :name, String  ]                               }
     let(:header1)    { Relation::Header.new([ attribute1, attribute2 ]) }
     let(:header2)    { Relation::Header.new([ attribute2, attribute1 ]) }
-    let(:relation)   { Relation.new(header1, [ [ 1, 'Dan Kubb' ] ])     }
-    let(:other)      { Relation.new(header2, [ [ 'Dan Kubb', 1 ] ])     }
+    let(:object)     { klass.new(header1, [ [ 1, 'Dan Kubb' ] ].each)   }
+    let(:other)      { klass.new(header2, [ [ 'Dan Kubb', 1 ] ].each)   }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent relation of a different class' do
-    let(:other) { Class.new(Relation).new(header, tuples) }
+  context 'with an equivalent object responding to #to_set' do
+    let(:other) { Set[ [ 1 ] ] }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == relation)
+      pending 'Set#== should call to_set on other' do
+        should == (other == object)
+      end
+    end
+  end
+
+  context 'with a different object responding to #to_set' do
+    let(:other) { Set[ [ 2 ] ] }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
     end
   end
 end

data/spec/unit/veritas/relation/hash_spec.rb

@@ -1,13 +1,18 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation#hash' do
-  subject { relation.hash }
+  subject { object.hash }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], []) }
+  let(:klass)  { Relation                                   }
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:body)   { [].each                                    }
+  let(:object) { klass.new(header, body)                    }
 
-  it { should be_kind_of(Integer) }
+  before do
+    object.should be_instance_of(klass)
+  end
 
-  it { should == relation.header.hash ^ relation.to_set.hash }
+  it_should_behave_like 'a hash method'
 
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ header.hash ^ body.to_set.hash }
 end

data/spec/unit/veritas/relation/header/class_methods/coerce_spec.rb

@@ -1,22 +1,26 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Header.coerce' do
-  subject { Relation::Header.coerce(object) }
+  subject { object.coerce(argument) }
 
-  context 'when the object is a Header' do
-    let(:object) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:object) { Relation::Header }
 
-    it { should equal(object) }
+  context 'when the argument is a Header' do
+    let(:argument) { object.new([ [ :id, Integer ] ]) }
+
+    it { should equal(argument) }
   end
 
-  context 'when the object responds to #to_ary' do
-    let(:object) { [ [ :id, Integer ] ] }
+  context 'when the argument responds to #to_ary' do
+    let(:argument) { [ [ :id, Integer ] ] }
+
+    it { should be_kind_of(object) }
 
-    it { should eql(Relation::Header.new([ Attribute::Integer.new(:id) ])) }
+    it { should == argument }
   end
 
-  context 'when the object is not a Header and does not respond to #to_ary' do
-    let(:object) { { :id => Integer } }
+  context 'when the argument is not a Header and does not respond to #to_ary' do
+    let(:argument) { { :id => Integer } }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/veritas/relation/header/difference_spec.rb

@@ -2,14 +2,15 @@ require 'spec_helper'
 
 [ :difference, :- ].each do |method|
   describe "Veritas::Relation::Header##{method}" do
-    subject { header.send(method, other) }
+    subject { object.send(method, other) }
 
-    let(:attribute1) { [ :id,   Integer ]                   }
-    let(:attribute2) { [ :name, String  ]                   }
-    let(:header)     { Relation::Header.new([ attribute1 ]) }
-    let(:other)      { Relation::Header.new([ attribute2 ]) }
+    let(:klass)      { Relation::Header          }
+    let(:attribute1) { [ :id,   Integer ]        }
+    let(:attribute2) { [ :name, String  ]        }
+    let(:object)     { klass.new([ attribute1 ]) }
+    let(:other)      { klass.new([ attribute2 ]) }
 
-    it { should be_kind_of(Relation::Header) }
+    it { should be_kind_of(klass) }
 
     it { should == [ attribute1 ] }
   end