veritas 0.0.1 → 0.0.2

data/spec/unit/veritas/relation/operation/order/direction_set/rename_spec.rb

@@ -1,16 +1,17 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#rename' do
-  subject { directions.rename(aliases) }
+  subject { object.rename(aliases) }
 
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:header)     { Relation::Header.new([ attribute ])                         }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute ]) }
-  let(:aliases)    { Algebra::Rename::Aliases.coerce(header, :id => :other_id)   }
+  let(:klass)     { Relation::Operation::Order::DirectionSet                  }
+  let(:attribute) { Attribute::Integer.new(:id)                               }
+  let(:header)    { Relation::Header.new([ attribute ])                       }
+  let(:aliases)   { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
+  let(:object)    { klass.new([ attribute ])                                  }
 
-  it { should_not equal(directions) }
+  it { should_not equal(object) }
 
-  it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+  it { should be_kind_of(klass) }
 
   it { should == [ Attribute::Integer.new(:other_id) ] }
 end

data/spec/unit/veritas/relation/operation/order/direction_set/reverse_spec.rb

@@ -1,13 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#reverse' do
-  subject { directions.reverse }
+  subject { object.reverse }
 
-  let(:attribute1) { Attribute::Integer.new(:id)                                              }
-  let(:attribute2) { Attribute::String.new(:name)                                             }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute1, attribute2 ]) }
+  let(:klass)      { Relation::Operation::Order::DirectionSet }
+  let(:attribute1) { Attribute::Integer.new(:id)              }
+  let(:attribute2) { Attribute::String.new(:name)             }
+  let(:object)     { klass.new([ attribute1, attribute2 ])    }
 
-  it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+  it { should be_kind_of(klass) }
 
   it 'reverses each direction' do
     should == [ attribute1.desc, attribute2.desc ]

data/spec/unit/veritas/relation/operation/order/direction_set/sort_tuples_spec.rb

@@ -1,23 +1,16 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#sort_tuples' do
-  subject { directions.sort_tuples(relation) }
+  subject { object.sort_tuples(relation) }
 
-  let(:relation) do
-    Relation.new(
-      [ [ :id, Integer ], [ :name, String ] ],
-      [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ] ]
-    )
-  end
-
-  let(:directions) { Relation::Operation::Order::DirectionSet.new(relation.header) }
+  let(:klass)    { Relation::Operation::Order::DirectionSet                     }
+  let(:header)   { [ [ :id, Integer ], [ :name, String ] ]                      }
+  let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ] ] }
+  let(:relation) { Relation.new(header, body)                                   }
+  let(:object)   { klass.new(header)                                            }
 
   context 'sorted with ascending id and descending name' do
-    let(:directions) do
-      Relation::Operation::Order::DirectionSet.new(
-        [ relation[:id].asc, relation[:name].desc ]
-      )
-    end
+    let(:object) { klass.new([ relation[:id].asc, relation[:name].desc ]) }
 
     it { should be_kind_of(Array) }
 
@@ -25,11 +18,7 @@ describe 'Veritas::Relation::Operation::Order::DirectionSet#sort_tuples' do
   end
 
   context 'sorted with ascending id and ascending name' do
-    let(:directions) do
-      Relation::Operation::Order::DirectionSet.new(
-        [ relation[:id].asc, relation[:name].asc ]
-      )
-    end
+    let(:object) { klass.new([ relation[:id].asc, relation[:name].asc ]) }
 
     it { should be_kind_of(Array) }
 
@@ -37,11 +26,7 @@ describe 'Veritas::Relation::Operation::Order::DirectionSet#sort_tuples' do
   end
 
   context 'sorted with descending id and ascending name' do
-    let(:directions) do
-      Relation::Operation::Order::DirectionSet.new(
-        [ relation[:id].desc, relation[:name].asc ]
-      )
-    end
+    let(:object) { klass.new([ relation[:id].desc, relation[:name].asc ]) }
 
     it { should be_kind_of(Array) }
 
@@ -49,11 +34,7 @@ describe 'Veritas::Relation::Operation::Order::DirectionSet#sort_tuples' do
   end
 
   context 'sorted with descending id and descending name' do
-    let(:directions) do
-      Relation::Operation::Order::DirectionSet.new(
-        [ relation[:id].desc, relation[:name].desc ]
-      )
-    end
+    let(:object) { klass.new([ relation[:id].desc, relation[:name].desc ]) }
 
     it { should be_kind_of(Array) }
 

data/spec/unit/veritas/relation/operation/order/direction_set/to_ary_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#to_ary' do
-  subject { directions.to_ary }
+  subject { object.to_ary }
 
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute ]) }
+  let(:klass)     { Relation::Operation::Order::DirectionSet }
+  let(:attribute) { Attribute::Integer.new(:id)              }
+  let(:object)    { klass.new([ attribute ])                 }
 
-  it { should be_instance_of(Array) }
+  it { should be_kind_of(Array) }
 
   it { should == [ attribute.asc ] }
 end

data/spec/unit/veritas/relation/operation/order/direction_set/union_spec.rb

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

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

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order#directions' do
-  subject { order.directions }
+  subject { object.directions }
 
+  let(:klass)      { Relation::Operation::Order                           }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:directions) { [ relation[:id].asc ]                                }
-  let(:order)      { Relation::Operation::Order.new(relation, directions) }
-
-  it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
-
-  it { should == directions }
+  let(:directions) { klass::DirectionSet.new(relation.header)             }
+  let(:object)     { klass.new(relation, directions)                      }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(directions) }
 end

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

@@ -1,16 +1,19 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order#each' do
-  subject { order.each { |tuple| yields << tuple } }
+  subject { object.each { |tuple| yields << tuple } }
 
+  let(:klass)      { Relation::Operation::Order                                  }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
   let(:directions) { [ relation[:id].desc ]                                      }
-  let(:order)      { Relation::Operation::Order.new(relation, directions)        }
+  let(:object)     { klass.new(relation, directions)                             }
   let(:yields)     { []                                                          }
 
-  it { should equal(order) }
+  it_should_behave_like 'a command method'
 
   it 'yields each tuple in order' do
-    expect { subject }.to change { yields.dup }.from([]).to([ [ 3 ], [ 2 ], [ 1 ] ])
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 3 ], [ 2 ], [ 1 ] ])
   end
 end

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

@@ -1,50 +1,64 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order#eql?' do
-  subject { order.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:directions) { [ relation[:id] ]                                    }
-  let(:order)      { relation.order(directions)                           }
+  let(:klass)      { Relation::Operation::Order                           }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:directions) { operand.header                                       }
+  let(:object)     { klass.new(operand, directions)                       }
 
-  context 'with the same order' do
-    let(:other) { order }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(order)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent order' do
-    let(:other) { order.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(order)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different order' do
-    let(:other) { order.order([ relation[:id].desc ]) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(object, directions) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(order)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent order of a different class' do
-    let(:other) { Class.new(Relation::Operation::Order).new(order, directions) }
+  context 'with an object having a different operand' do
+    let(:other_operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+    let(:other_directions) { directions                                    }
+    let(:other)            { klass.new(other_operand, other_directions)    }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(order)
+      should == other.eql?(object)
     end
   end
 
+  context 'with an object having different directions' do
+    let(:other_operand)    { operand                                    }
+    let(:other_directions) { [ operand[:id].desc ]                      }
+    let(:other)            { klass.new(other_operand, other_directions) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
 end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Relation::Operation::Order#hash' do
+  subject { object.hash }
+
+  let(:klass)      { Relation::Operation::Order                           }
+  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:directions) { klass::DirectionSet.new(operand.header)              }
+  let(:object)     { klass.new(operand, directions)                       }
+
+  it_should_behave_like 'a hash method'
+
+  it { should == klass.hash ^ operand.hash ^ directions.hash }
+end

data/spec/unit/veritas/relation/operation/order/header_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order#header' do
-  subject { order.header }
+  subject { object.header }
 
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:directions) { [ relation[:id] ]                                    }
-  let(:order)      { Relation::Operation::Order.new(relation, directions) }
-
-  it { should be_kind_of(Relation::Header) }
-
-  it { should equal(relation.header) }
+  let(:klass)    { Relation::Operation::Order                 }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:relation) { Relation.new(header, [ [ 1 ], [ 2 ] ])     }
+  let(:object)   { klass.new(relation, header)                }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
 end

data/spec/unit/veritas/relation/operation/order/methods/order_spec.rb

@@ -1,44 +1,46 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Methods#order' do
-  subject { relation.order(*args, &block) }
-
-  let(:args)     { []                                                   }
-  let(:block)    { nil                                                  }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:klass)  { Relation                                               }
+  let(:object) { klass.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
 
   context 'with no arguments' do
+    subject { object.order }
+
     it { should be_kind_of(Relation::Operation::Order) }
 
-    its(:directions) { should == relation.header }
+    its(:directions) { should == object.header }
 
     it 'behaves the same as Array#sort_by' do
-      subject.to_a.should == relation.to_a.sort_by { |tuple| tuple[:id] }
+      subject.to_a.should == object.to_a.sort_by { |tuple| tuple[:id] }
     end
   end
 
   context 'with direction arguments' do
-    let(:directions) { [ relation[:id].desc ] }
-    let(:args)       { [ directions ]         }
+    subject { object.order(directions) }
+
+    let(:directions) { [ object[:id].desc ] }
 
     it { should be_kind_of(Relation::Operation::Order) }
 
     its(:directions) { should == directions }
 
     it 'behaves the same as Array#sort_by' do
-      subject.to_a.should == relation.to_a.sort_by { |tuple| tuple[:id] }.reverse
+      subject.to_a.should == object.to_a.sort_by { |tuple| tuple[:id] }.reverse
     end
   end
 
   context 'with a block' do
+    subject { object.order(&block) }
+
     let(:block) { lambda { |relation| [ relation[:id].desc ] } }
 
     it { should be_kind_of(Relation::Operation::Order) }
 
-    its(:directions) { should == block.call(relation) }
+    its(:directions) { should == block.call(object) }
 
     it 'behaves the same as Array#sort_by' do
-      subject.to_a.should == relation.to_a.sort_by { |tuple| tuple[:id] }.reverse
+      subject.to_a.should == object.to_a.sort_by { |tuple| tuple[:id] }.reverse
     end
   end
 end

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

@@ -1,14 +1,25 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Reverse.new' do
-  subject { Relation::Operation::Reverse.new(relation) }
+  subject { object.new(relation) }
 
   let(:original_relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:object)            { Relation::Operation::Reverse                         }
 
   context 'with an ordered relation' do
     let(:relation) { original_relation.order { |r| r[:id] } }
 
-    it { should be_kind_of(Relation::Operation::Reverse) }
+    it { should be_kind_of(object) }
+
+    it 'reverses the directions' do
+      subject.directions.should == relation.directions.reverse
+    end
+  end
+
+  context 'with an ordered relation having an empty header' do
+    let(:relation) { original_relation.order { |r| r[:id] }.project([]) }
+
+    it { should be_kind_of(object) }
 
     it 'reverses the directions' do
       subject.directions.should == relation.directions.reverse

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

@@ -1,17 +1,19 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Reverse#each' do
-  subject { reverse.each { |tuple| yields << tuple } }
+  subject { object.each { |tuple| yields << tuple } }
 
-  let(:klass)      { Relation::Operation::Reverse                                }
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)      { relation.order                                              }
-  let(:reverse)    { klass.new(order)                                            }
-  let(:yields)     { []                                                          }
+  let(:klass)    { Relation::Operation::Reverse                                }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+  let(:order)    { relation.order                                              }
+  let(:object)   { klass.new(order)                                            }
+  let(:yields)   { []                                                          }
 
-  it { should equal(reverse) }
+  it_should_behave_like 'a command method'
 
   it 'yields each tuple in reverse order' do
-    expect { subject }.to change { yields.dup }.from([]).to([ [ 3 ], [ 2 ], [ 1 ] ])
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 3 ], [ 2 ], [ 1 ] ])
   end
 end

data/spec/unit/veritas/relation/operation/reverse/methods/reverse_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Reverse::Methods#reverse' do
-  subject { ordered.reverse }
+  subject { object.reverse }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:ordered)  { relation.order { |r| r[:id] }                        }
+  let(:klass)    { Relation                                               }
+  let(:relation) { klass.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
+  let(:object)   { relation.order                                         }
 
   it { should be_kind_of(Relation::Operation::Reverse) }
 

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

@@ -2,26 +2,27 @@ require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
 describe 'Veritas::Relation::Operation::Set::ClassMethods#new' do
-  subject { SetOperationSpecs::Object.new(left, right) }
+  subject { object.new(left, right) }
 
   let(:header) { [ [ :id, Integer ] ]            }
   let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+  let(:object) { SetOperationSpecs::Object       }
 
-  context 'with relations having headers with common attributes' do
-    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+  context 'with relations having equivalent headers' do
+    let(:right) { Relation.new(header, [ [ 2 ] ]) }
 
-    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent for SetOperationSpecs::Object.new') }
+    it { should be_kind_of(object) }
   end
 
-  context 'with relations having equivalent headers' do
-    let(:right) { Relation.new(header, [ [ 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 }
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent') }
   end
 
   context 'with relations having different headers' do
     let(:right) { Relation.new([ [ :number, Integer ] ], [ [ 2 ] ]) }
 
-    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent for SetOperationSpecs::Object.new') }
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent') }
   end
 end

data/spec/unit/veritas/relation/operation/set/header_spec.rb

@@ -9,7 +9,7 @@ describe 'Veritas::Relation::Operation::Set#header' do
   let(:right)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
   let(:object) { klass.new(left, right)                        }
 
-  it { should equal(left.header) }
-
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(left.header) }
 end

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

@@ -2,14 +2,15 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Relation::Operation::Unary#directions' do
-  subject { unary_operation.directions }
+  subject { object.directions }
 
-  let(:relation)        { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:unary_operation) { UnaryOperationSpecs::Object.new(relation)     }
-
-  it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
-
-  it { should equal(relation.directions) }
+  let(:klass)      { UnaryOperationSpecs::Object                                   }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])                 }
+  let(:directions) { Relation::Operation::Order::DirectionSet.new(relation.header) }
+  let(:order)      { relation.order(directions)                                    }
+  let(:object)     { klass.new(order)                                              }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(directions) }
 end

data/spec/unit/veritas/relation/operation/unary/header_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Relation::Operation::Unary#header' do
-  subject { unary_operation.header }
+  subject { object.header }
 
-  let(:relation)        { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:unary_operation) { UnaryOperationSpecs::Object.new(relation)     }
-
-  it { should be_kind_of(Relation::Header) }
-
-  it { should equal(relation.header) }
+  let(:klass)    { UnaryOperationSpecs::Object                }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:relation) { Relation.new(header, [ [ 1 ] ])            }
+  let(:object)   { klass.new(relation)                        }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
 end

data/spec/unit/veritas/tuple/class_methods/coerce_spec.rb

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

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

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#[]' do
-  subject { tuple[attribute] }
+  subject { object[attribute] }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:object) { klass.new(header, [ 1 ])                   }
 
   context 'with a known attribute' do
     let(:attribute) { header[:id] }