veritas 0.0.1 → 0.0.2

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

@@ -1,21 +1,36 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order.new' do
-  subject { Relation::Operation::Order.new(relation, directions) }
+  subject { object.new(relation, directions) }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:header)   { [ [ :id, Integer ], [ :name, String ] ]   }
+  let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ] }
+  let(:relation) { Relation.new(header, body)                }
+  let(:object)   { Relation::Operation::Order                }
 
   context 'with all attributes specified in the directions' do
-    let(:directions) { [ relation[:id] ] }
+    let(:directions) { [ relation[:id], relation[:name] ] }
+
+    it { should be_kind_of(object) }
 
     its(:operand) { should equal(relation) }
 
-    its(:directions) { should == [ relation[:id].asc ] }
+    its(:directions) { should == [ relation[:id].asc, relation[:name].asc ] }
   end
 
-  context 'without all attributes specified in the directions' do
+  context 'without no attributes specified in the directions' do
     let(:directions) { [] }
 
+    it { should be_kind_of(object) }
+
+    its(:operand) { should equal(relation) }
+
+    its(:directions) { should == [ relation[:id].asc, relation[:name].asc ] }
+  end
+
+  context 'without all attributes specified in the directions' do
+    let(:directions) { [ :id ] }
+
     specify { expect { subject }.to raise_error(InvalidDirectionsError, 'directions must include every attribute in the header') }
   end
 end

data/spec/unit/veritas/relation/operation/order/descending/class_methods/call_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Descending.call' do
-  subject { Relation::Operation::Order::Descending.call(left, right) }
+  subject { object.call(left, right) }
+
+  let(:object) { Relation::Operation::Order::Descending }
 
   context 'when left is equal to right' do
     let(:left)  { 1 }

data/spec/unit/veritas/relation/operation/order/descending/class_methods/reverse_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Descending.reverse' do
-  subject { Relation::Operation::Order::Descending.reverse }
+  subject { object.reverse }
+
+  let(:object) { Relation::Operation::Order::Descending }
 
   it { should equal(Relation::Operation::Order::Ascending) }
 end

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

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Descending#reverse' do
-  subject { descending.reverse }
+  subject { object.reverse }
 
-  let(:attribute)  { Attribute::Integer.new(:id)                           }
-  let(:descending) { Relation::Operation::Order::Descending.new(attribute) }
+  let(:klass)     { Relation::Operation::Order::Descending }
+  let(:attribute) { Attribute::Integer.new(:id)            }
+  let(:object)    { klass.new(attribute)                   }
 
   it { should be_kind_of(Relation::Operation::Order::Ascending) }
 

data/spec/unit/veritas/relation/operation/order/direction/attribute_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction#attribute' do
-  subject { direction.attribute }
+  subject { object.attribute }
 
-  let(:attribute) { Attribute::Integer.new(:id)                      }
   let(:klass)     { Class.new(Relation::Operation::Order::Direction) }
-  let(:direction) { klass.new(attribute)                             }
+  let(:attribute) { Attribute::Integer.new(:id)                      }
+  let(:object)    { klass.new(attribute)                             }
 
   it { should equal(attribute) }
 end

data/spec/unit/veritas/relation/operation/order/direction/call_spec.rb

@@ -1,18 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction#call' do
-  subject { direction.call(left, right) }
+  subject { object.call(left, right) }
 
-  let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:left)   { Tuple.new(header, [ 1 ])                   }
-  let(:right)  { Tuple.new(header, [ 2 ])                   }
-  let(:klass) do
-    Class.new(Relation::Operation::Order::Direction) do
-      def self.call(*)
-      end
-    end
-  end
-  let(:direction) { klass.new(header[:id]) }
+  let(:klass)  { Class.new(Relation::Operation::Order::Direction) }
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ])       }
+  let(:left)   { Tuple.new(header, [ 1 ])                         }
+  let(:right)  { Tuple.new(header, [ 2 ])                         }
+  let(:object) { klass.new(header[:id])                           }
 
   it 'sends the tuple value to self.class.call' do
     response = mock('#call response')

data/spec/unit/veritas/relation/operation/order/direction/class_methods/coerce_spec.rb

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction.coerce' do
-  subject { klass.coerce(object) }
+  subject { object.coerce(argument) }
 
   let(:attribute) { Attribute::Integer.new(:id)                      }
-  let(:klass)     { Class.new(Relation::Operation::Order::Direction) }
+  let(:object)    { Class.new(Relation::Operation::Order::Direction) }
 
-  context 'when the object is a Direction' do
-    let(:object) { Relation::Operation::Order::Ascending.new(attribute) }
+  context 'when the argument is a Direction' do
+    let(:argument) { Relation::Operation::Order::Ascending.new(attribute) }
 
-    it { should equal(object) }
+    it { should equal(argument) }
   end
 
-  context 'when the object is an Attribute' do
-    let(:object) { attribute }
+  context 'when the argument is an Attribute' do
+    let(:argument) { attribute }
 
-    it { should eql(klass.new(attribute)) }
+    it { should be_kind_of(object) }
+
+    its(:attribute) { should equal(attribute) }
   end
 end

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

@@ -2,50 +2,50 @@ require 'spec_helper'
 
 [ :eql?, :== ].each do |method|
   describe "Veritas::Relation::Operation::Order::Direction##{method}" do
-    subject { direction.send(method, other) }
+    subject { object.send(method, other) }
 
-    let(:attribute) { Attribute::Integer.new(:id)                      }
     let(:klass)     { Class.new(Relation::Operation::Order::Direction) }
-    let(:direction) { klass.new(attribute)                             }
+    let(:attribute) { Attribute::Integer.new(:id)                      }
+    let(:object)    { klass.new(attribute)                             }
 
-    context 'with the same direction' do
-      let(:other) { direction }
+    context 'with the same object' do
+      let(:other) { object }
 
       it { should be(true) }
 
       it 'is symmetric' do
-        should == other.send(method, direction)
+        should == other.send(method, object)
       end
     end
 
-    context 'with an equivalent direction' do
-      let(:other) { direction.dup }
+    context 'with an equivalent object' do
+      let(:other) { object.dup }
 
       it { should be(true) }
 
       it 'is symmetric' do
-        should == other.send(method, direction)
+        should == other.send(method, object)
       end
     end
 
-    context 'with a different direction' do
-      let(:other_attribute) { Attribute::String.new(:name) }
-      let(:other)           { klass.new(other_attribute)   }
+    context 'with an equivalent object of a subclass' do
+      let(:other) { Class.new(klass).new(attribute) }
 
       it { should be(false) }
 
       it 'is symmetric' do
-        should == other.send(method, direction)
+        should == other.send(method, object)
       end
     end
 
-    context 'with an equivalent direction of a different class' do
-      let(:other) { Class.new(klass).new(attribute) }
+    context 'with an object having a different attribute' do
+      let(:other_attribute) { Attribute::String.new(:name) }
+      let(:other)           { klass.new(other_attribute)   }
 
       it { should be(false) }
 
       it 'is symmetric' do
-        should == other.send(method, direction)
+        should == other.send(method, object)
       end
     end
   end

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

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction#hash' do
-  subject { direction.hash }
+  subject { object.hash }
 
-  let(:attribute) { Attribute::Integer.new(:id)                      }
   let(:klass)     { Class.new(Relation::Operation::Order::Direction) }
-  let(:direction) { klass.new(attribute)                             }
-
-  it { should be_kind_of(Integer) }
+  let(:attribute) { Attribute::Integer.new(:id)                      }
+  let(:object)    { klass.new(attribute)                             }
 
-  it { should == direction.attribute.hash }
+  it_should_behave_like 'a hash method'
 
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ attribute.hash }
 end

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

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction#rename' do
-  subject { direction.rename(aliases) }
+  subject { object.rename(aliases) }
 
   let(:attribute) { Attribute::Integer.new(:id)                      }
   let(:header)    { Relation::Header.new([ attribute ])              }
   let(:klass)     { Class.new(Relation::Operation::Order::Direction) }
-  let(:direction) { klass.new(attribute)                             }
+  let(:object)    { klass.new(attribute)                             }
 
   context 'with aliases matching the attribute' do
     let(:aliases) { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
 
     it { should be_kind_of(klass) }
 
-    it { should eql(klass.new(Attribute::Integer.new(:other_id))) }
+    its(:attribute) { should == attribute.rename(:other_id) }
   end
 
   context 'with aliases not matching the attribute' do
@@ -21,8 +21,6 @@ describe 'Veritas::Relation::Operation::Order::Direction#rename' do
     let(:other_header)    { Relation::Header.new([ other_attribute ])                           }
     let(:aliases)         { Algebra::Rename::Aliases.coerce(other_header, :name => :other_name) }
 
-    it { should be_kind_of(klass) }
-
-    it { should equal(direction) }
+    it { should equal(object) }
   end
 end

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

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::Direction#reverse' do
-  subject { direction.reverse }
+  subject { object.reverse }
 
-  let(:attribute)        { Attribute::Integer.new(:id)                      }
-  let(:klass)            { Class.new(Relation::Operation::Order::Direction) }
-  let(:direction)        { klass.new(attribute)                             }
-  let(:reverse_class)    { mock('Reverse Class', :new => reverse_instance)  }
-  let(:reverse_instance) { mock('Reverse Instance')                         }
+  let(:klass)         { Class.new(Relation::Operation::Order::Direction) }
+  let(:attribute)     { Attribute::Integer.new(:id)                      }
+  let(:reverse_class) { mock('Reverse Class', :new => reverse)           }
+  let(:reverse)       { mock('Reverse Instance')                         }
+  let(:object)        { klass.new(attribute)                             }
 
   before do
     klass.stub!(:reverse).and_return(reverse_class)
@@ -23,5 +23,5 @@ describe 'Veritas::Relation::Operation::Order::Direction#reverse' do
     subject
   end
 
-  it { should equal(reverse_instance) }
+  it { should equal(reverse) }
 end

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

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#attributes' do
-  subject { directions.attributes }
+  subject { object.attributes }
 
-  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_kind_of(Array) }
 

data/spec/unit/veritas/relation/operation/order/direction_set/class_methods/coerce_spec.rb

@@ -1,25 +1,28 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet.coerce' do
-  subject { Relation::Operation::Order::DirectionSet.coerce(object) }
+  subject { object.coerce(argument) }
 
-  let(:directions)    { [ :id ]                                                  }
-  let(:direction_set) { Relation::Operation::Order::DirectionSet.new(directions) }
+  let(:directions)    { [ :id ]                                  }
+  let(:object)        { Relation::Operation::Order::DirectionSet }
+  let(:direction_set) { object.new(directions)                   }
 
-  context 'when the object is a DirectionSet' do
-    let(:object) { direction_set }
+  context 'when the argument is a DirectionSet' do
+    let(:argument) { direction_set }
 
-    it { should equal(object) }
+    it { should equal(argument) }
   end
 
-  context 'when the object responds to #to_ary' do
-    let(:object) { directions }
+  context 'when the argument responds to #to_ary' do
+    let(:argument) { directions }
 
-    it { should eql(direction_set) }
+    it { should be_kind_of(object) }
+
+    it { should == direction_set }
   end
 
-  context 'when the object is not a DirectionSet and does not respond to #to_ary' do
-    let(:object) { { :id => Integer } }
+  context 'when the argument is not a DirectionSet 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/operation/order/direction_set/each_spec.rb

@@ -1,27 +1,31 @@
 require 'spec_helper'
 
-describe 'Veritas::Relation::Operation::Order::DirectionSet' do
-  subject { Relation::Operation::Order::DirectionSet.new(attributes) }
+describe 'Veritas::Relation::Operation::Order::DirectionSet#each' do
+  subject { object.each { |direction| yields << direction } }
 
-  let(:attributes) { [ Attribute::Integer.new(:id) ] }
+  let(:klass)      { Relation::Operation::Order::DirectionSet                      }
+  let(:attributes) { [ Attribute::Integer.new(:id), Attribute::String.new(:name) ] }
+  let(:object)     { klass.new(attributes)                                         }
+  let(:yields)     { []                                                            }
 
-  it { should be_kind_of(Enumerable) }
+  it_should_behave_like 'a command method'
 
-  it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
+  it 'yields each direction' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to(attributes.map { |attribute| attribute.asc })
   end
 end
 
-describe 'Veritas::Relation::Operation::Order::DirectionSet#each' do
-  subject { directions.each { |direction| yields << direction } }
+describe 'Veritas::Relation::Operation::Order::DirectionSet' do
+  subject { object.new(attributes) }
 
-  let(:attributes) { [ Attribute::Integer.new(:id), Attribute::String.new(:name) ] }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new(attributes)      }
-  let(:yields)     { []                                                            }
+  let(:attributes) { [ Attribute::Integer.new(:id) ]          }
+  let(:object)     { Relation::Operation::Order::DirectionSet }
 
-  it { should equal(directions) }
+  it { should be_kind_of(Enumerable) }
 
-  it 'yields each direction' do
-    expect { subject }.to change { yields.dup }.from([]).to(directions.to_ary)
+  it 'case matches Enumerable' do
+    (Enumerable === subject).should be(true)
   end
 end

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

@@ -1,17 +1,19 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#empty?' do
-  subject { directions.empty? }
+  subject { object.empty? }
+
+  let(:klass)  { Relation::Operation::Order::DirectionSet }
+  let(:object) { klass.new(attributes)                    }
 
   context 'with an empty set' do
-    let(:directions) { Relation::Operation::Order::DirectionSet.new([]) }
+    let(:attributes) { [] }
 
     it { should be(true) }
   end
 
   context 'with directions' do
-    let(:attribute)  { Attribute::Integer.new(:id)                                 }
-    let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute ]) }
+    let(:attributes) { [ Attribute::Integer.new(:id) ] }
 
     it { should be(false) }
   end

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

@@ -1,49 +1,50 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#eql?' do
-  subject { directions.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute ]) }
+  let(:klass)      { Relation::Operation::Order::DirectionSet }
+  let(:attributes) { [ Attribute::Integer.new(:id) ]          }
+  let(:object)     { klass.new(attributes)                    }
 
-  context 'with the same direction' do
-    let(:other) { directions }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(directions)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent directions' do
-    let(:other) { directions.dup }
+  context 'with equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(directions)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different directions' do
-    let(:other_attribute) { Attribute::Integer.new(:name)                                     }
-    let(:other)           { Relation::Operation::Order::DirectionSet.new([ other_attribute ]) }
+  context 'with equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(attributes) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(directions)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent directions of a different class' do
-    let(:other) { Class.new(Relation::Operation::Order::DirectionSet).new([ attribute ]) }
+  context 'with an object having different attributes' do
+    let(:other_attributes) { [ Attribute::Integer.new(:other_id) ] }
+    let(:other)            { klass.new(other_attributes)           }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(directions)
+      should == other.eql?(object)
     end
   end
 end

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

@@ -1,49 +1,70 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#==' do
-  subject { directions == other }
+  subject { object == other }
 
-  let(:attribute)  { Attribute::Integer.new(:id)                                 }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new([ attribute ]) }
+  let(:klass)      { Relation::Operation::Order::DirectionSet }
+  let(:attributes) { [ Attribute::Integer.new(:id) ]          }
+  let(:object)     { klass.new(attributes)                    }
 
-  context 'with the same direction' do
-    let(:other) { directions }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == directions)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent directions' do
-    let(:other) { directions.dup }
+  context 'with equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == directions)
+      should == (other == object)
     end
   end
 
-  context 'with a different directions' do
-    let(:other_attribute) { Attribute::Integer.new(:name)                                     }
-    let(:other)           { Relation::Operation::Order::DirectionSet.new([ other_attribute ]) }
+  context 'with equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(attributes) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an object having different attributes' do
+    let(:other_attributes) { [ Attribute::Integer.new(:other_id) ] }
+    let(:other)            { klass.new(other_attributes)           }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == directions)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent directions of a different class' do
-    let(:other) { Class.new(Relation::Operation::Order::DirectionSet).new([ attribute ]) }
+  context 'with an equivalent object responding to #to_ary' do
+    let(:other) { attributes }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == directions)
+      should == (other == object)
+    end
+  end
+
+  context 'with a different object responding to #to_ary' do
+    let(:other) { [ Attribute::String.new(:name) ] }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
     end
   end
 end

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#hash' do
-  subject { directions.hash }
+  subject { object.hash }
 
-  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(:directions) { [ attribute.asc ]                        }
+  let(:object)     { klass.new(directions)                    }
 
-  it { should be_kind_of(Integer) }
+  it_should_behave_like 'a hash method'
 
-  it { should == [ attribute.asc ].hash }
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ directions.hash }
 end

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

@@ -1,14 +1,16 @@
 require 'spec_helper'
 
 describe 'Veritas::Relation::Operation::Order::DirectionSet#project' do
-  subject { directions.project([ header[:id] ]) }
+  subject { object.project(attributes) }
 
+  let(:klass)      { Relation::Operation::Order::DirectionSet                      }
   let(:header)     { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:directions) { Relation::Operation::Order::DirectionSet.new(header)          }
+  let(:attributes) { [ header[:id] ]                                               }
+  let(:object)     { klass.new(header)                                             }
 
-  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 == [ header[:id] ] }
 end