veritas 0.0.4 → 0.0.5

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Order::DirectionSet, '.new' do
+  subject { object.new(argument) }
+
+  let(:id)     { Attribute::Integer.new(:id)  }
+  let(:name)   { Attribute::String.new(:name) }
+  let(:age)    { Attribute::Integer.new(:age) }
+  let(:object) { described_class              }
+
+  context 'with an argument that responds to #to_ary and do not contain duplicates' do
+    let(:argument) { [ id, name ] }
+
+    it { should be_instance_of(object) }
+
+    it { should == argument }
+  end
+
+  context 'with an argument that responds to #to_ary and contain duplicates' do
+    let(:argument) { [ id, id, name, name, age ] }
+
+    specify { expect { subject }.to raise_error(DuplicateAttributeError, 'duplicate attributes: id, name') }
+  end
+
+  context 'with an argument that does not respond to #to_ary' do
+    let(:argument) { { :id => Integer } }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

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

@@ -14,7 +14,7 @@ describe Relation::Operation::Order::DirectionSet, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -24,7 +24,7 @@ describe Relation::Operation::Order::DirectionSet, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -34,7 +34,7 @@ describe Relation::Operation::Order::DirectionSet, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -45,7 +45,7 @@ describe Relation::Operation::Order::DirectionSet, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -14,7 +14,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -24,7 +24,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -34,7 +34,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -45,7 +45,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -55,7 +55,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -65,7 +65,7 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 end

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

@@ -11,7 +11,7 @@ describe Relation::Operation::Order::DirectionSet, '#project' do
 
   it { should_not equal(object) }
 
-  it { should be_kind_of(described_class) }
+  it { should be_instance_of(described_class) }
 
   it { should == [ header[:id] ] }
 end

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

@@ -12,7 +12,7 @@ describe Relation::Operation::Order::DirectionSet, '#rename' do
 
   it { should_not equal(object) }
 
-  it { should be_kind_of(described_class) }
+  it { should be_instance_of(described_class) }
 
   it { should == [ Attribute::Integer.new(:other_id) ] }
 end

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

@@ -11,13 +11,13 @@ describe Relation::Operation::Order::DirectionSet, '#reverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(described_class) }
+  it { should be_instance_of(described_class) }
 
   it 'reverses each direction' do
     should == [ attribute1.desc, attribute2.desc ]
   end
 
   it 'does not reverse the attribute order' do
-    subject.attributes.should == [ attribute1, attribute2 ]
+    subject.attributes.should eql([ attribute1, attribute2 ])
   end
 end

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

@@ -13,7 +13,7 @@ describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
   context 'sorted with ascending id and descending name' do
     let(:object) { described_class.new([ relation[:id].asc, relation[:name].desc ]) }
 
-    it { should be_kind_of(Array) }
+    it { should be_instance_of(Array) }
 
     it { should == [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ] }
   end
@@ -21,7 +21,7 @@ describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
   context 'sorted with ascending id and ascending name' do
     let(:object) { described_class.new([ relation[:id].asc, relation[:name].asc ]) }
 
-    it { should be_kind_of(Array) }
+    it { should be_instance_of(Array) }
 
     it { should == [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ] ] }
   end
@@ -29,7 +29,7 @@ describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
   context 'sorted with descending id and ascending name' do
     let(:object) { described_class.new([ relation[:id].desc, relation[:name].asc ]) }
 
-    it { should be_kind_of(Array) }
+    it { should be_instance_of(Array) }
 
     it { should == [ [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ], [ 1, 'Dan Kubb' ] ] }
   end
@@ -37,7 +37,7 @@ describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
   context 'sorted with descending id and descending name' do
     let(:object) { described_class.new([ relation[:id].desc, relation[:name].desc ]) }
 
-    it { should be_kind_of(Array) }
+    it { should be_instance_of(Array) }
 
     it { should == [ [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 1, 'Dan Kubb' ] ] }
   end

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

@@ -8,7 +8,7 @@ describe Relation::Operation::Order::DirectionSet, '#to_ary' do
   let(:attribute) { Attribute::Integer.new(:id)        }
   let(:object)    { described_class.new([ attribute ]) }
 
-  it { should be_kind_of(Array) }
+  it { should be_instance_of(Array) }
 
   it { should == [ attribute.asc ] }
 end

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

@@ -11,7 +11,7 @@ require 'spec_helper'
     let(:object)     { described_class.new([ attribute1 ]) }
     let(:other)      { described_class.new([ attribute2 ]) }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     it { should == [ attribute1.asc, attribute2.asc ] }
   end

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

@@ -15,7 +15,7 @@ describe Relation::Operation::Order, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Relation::Operation::Order, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,7 +35,7 @@ describe Relation::Operation::Order, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -47,7 +47,7 @@ describe Relation::Operation::Order, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -59,7 +59,7 @@ describe Relation::Operation::Order, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -6,15 +6,29 @@ describe Relation::Operation::Order::Methods, '#order' do
   let(:described_class) { Relation                                                         }
   let(:object)          { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
 
+  before do
+    @original, $stderr = $stderr, StringIO.new
+  end
+
+  after do
+    $stderr = @original
+  end
+
   context 'with no arguments' do
     subject { object.order }
 
-    it { should be_kind_of(Relation::Operation::Order) }
+    it { should be_instance_of(Relation::Operation::Order) }
 
     its(:directions) { should == object.header }
 
     it 'behaves the same as Array#sort_by' do
-      subject.to_a.should == object.to_a.sort_by { |tuple| tuple[:id] }
+      subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+    end
+
+    it 'warns with a deprecation message' do
+      expect { subject }.to change { $stderr.string.chomp }.
+        from(nil).
+        to('Veritas::Relation#order is deprecated and will be removed from Veritas 0.0.6')
     end
   end
 
@@ -23,12 +37,18 @@ describe Relation::Operation::Order::Methods, '#order' do
 
     let(:block) { lambda { |relation| [ relation[:id].desc ] } }
 
-    it { should be_kind_of(Relation::Operation::Order) }
+    it { should be_instance_of(Relation::Operation::Order) }
 
     its(:directions) { should == block.call(object) }
 
     it 'behaves the same as Array#sort_by' do
-      subject.to_a.should == object.to_a.sort_by { |tuple| tuple[:id] }.reverse
+      subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] }.reverse)
+    end
+
+    it 'warns with a deprecation message' do
+      expect { subject }.to change { $stderr.string.chomp }.
+        from(nil).
+        to('Veritas::Relation#order is deprecated and will be removed from Veritas 0.0.6')
     end
   end
 end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Order::Methods, '#sort_by' do
+  let(:described_class) { Relation                                                         }
+  let(:object)          { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
+
+  context 'with no block' do
+    subject { object.sort_by }
+
+    specify { expect { subject }.to raise_error(LocalJumpError) }
+  end
+
+  context 'with a block' do
+    subject { object.sort_by(&block) }
+
+    let(:block) { lambda { |relation| [ relation[:id].desc ] } }
+
+    it { should be_instance_of(Relation::Operation::Order) }
+
+    its(:directions) { should == block.call(object) }
+
+    it 'behaves the same as Array#sort_by' do
+      subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] }.reverse)
+    end
+  end
+end

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

@@ -9,22 +9,22 @@ describe Relation::Operation::Reverse, '.new' do
   let(:object)            { described_class                                      }
 
   context 'with an ordered relation' do
-    let(:relation) { original_relation.order { |r| r[:id] } }
+    let(:relation) { original_relation.sort_by { |r| r.id } }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     it 'reverses the directions' do
-      subject.directions.should == relation.directions.reverse
+      subject.directions.should eql(relation.directions.reverse)
     end
   end
 
   context 'with an ordered relation having an empty header' do
-    let(:relation) { original_relation.order { |r| r[:id] }.project([]) }
+    let(:relation) { original_relation.sort_by { |r| r.id }.project([]) }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     it 'reverses the directions' do
-      subject.directions.should == relation.directions.reverse
+      subject.directions.should eql(relation.directions.reverse)
     end
   end
 

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

@@ -7,7 +7,7 @@ describe Relation::Operation::Reverse, '#directions' do
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [].each) }
   let(:object)   { described_class.new(ordered)                }
-  let(:ordered)  { relation.order                              }
+  let(:ordered)  { relation.sort_by { |r| r.id }               }
 
   it_should_behave_like 'an idempotent method'
 

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

@@ -6,7 +6,7 @@ describe Relation::Operation::Reverse, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.order                                              }
+  let(:order)    { relation.sort_by { |r| r.id }                               }
   let(:object)   { described_class.new(order)                                  }
   let(:yields)   { []                                                          }
 

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

@@ -7,9 +7,9 @@ describe Relation::Operation::Reverse::Methods, '#reverse' do
 
   let(:described_class) { Relation                                                         }
   let(:relation)        { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
-  let(:object)          { relation.order                                                   }
+  let(:object)          { relation.sort_by { |r| r.id }                                    }
 
-  it { should be_kind_of(Relation::Operation::Reverse) }
+  it { should be_instance_of(Relation::Operation::Reverse) }
 
   it 'behaves the same as Array#reverse' do
     should == relation.to_a.reverse

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

@@ -13,7 +13,7 @@ describe Relation::Operation::Set::ClassMethods, '#new' do
   context 'with relations having equivalent headers' do
     let(:right) { Relation.new(header, [ [ 2 ] ]) }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'with relations having headers with common attributes' do

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

@@ -18,7 +18,7 @@ describe Tuple, '.coerce' do
   context 'when the argument responds to #to_ary' do
     let(:argument) { [ 1 ] }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     it { should == tuple }
   end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#data' do
+  subject { object.data }
+
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:object) { described_class.new(header, [ 1 ])         }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Hash) }
+
+  it { should eql(header[:id] => 1) }
+end

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

@@ -17,6 +17,6 @@ describe Tuple, '#[]' do
   context 'with an unknown attribute' do
     let(:attribute) { Attribute::Integer.new(:other_id) }
 
-    it { should be_nil }
+    specify { expect { subject }.to raise_error(IndexError) }
   end
 end

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

@@ -15,7 +15,7 @@ describe Tuple, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Tuple, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,7 +35,7 @@ describe Tuple, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -47,7 +47,7 @@ describe Tuple, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -59,7 +59,7 @@ describe Tuple, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -15,7 +15,7 @@ describe Tuple, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -25,7 +25,7 @@ describe Tuple, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -35,7 +35,7 @@ describe Tuple, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -47,7 +47,7 @@ describe Tuple, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -59,7 +59,7 @@ describe Tuple, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -69,7 +69,7 @@ describe Tuple, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -79,7 +79,7 @@ describe Tuple, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 end

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

@@ -12,7 +12,7 @@ describe Tuple, '#extend' do
   context 'when the extension is a Proc' do
     let(:extensions) { [ lambda { |tuple| 1 } ] }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     its(:header) { should equal(new_header) }
 
@@ -22,7 +22,7 @@ describe Tuple, '#extend' do
   context 'when the extension is a Function' do
     let(:extensions) { [ header[:id].abs ] }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     its(:header) { should equal(new_header) }
 
@@ -32,7 +32,7 @@ describe Tuple, '#extend' do
   context 'when the extension is a value' do
     let(:extensions) { [ 1 ] }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     its(:header) { should equal(new_header) }
 

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

@@ -11,5 +11,5 @@ describe Tuple, '#hash' do
 
   it_should_behave_like 'a hash method'
 
-  it { should == described_class.hash ^ header.hash ^ Hash[header.zip(data)].hash }
+  it { should == described_class.hash ^ Hash[header.zip(data)].hash }
 end

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

@@ -8,7 +8,7 @@ describe Tuple, '#inspect' do
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:object) { described_class.new(header, [ 1 ])         }
 
-  it { should be_kind_of(String) }
+  it { should be_instance_of(String) }
 
-  it { should == '[1]' }
+  it { should == '{<Attribute::Integer name: id>=>1}' }
 end

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

@@ -10,7 +10,7 @@ describe Tuple, '#join' do
   let(:values)     { [ 'Dan Kubb' ]                             }
   let(:object)     { described_class.new(header, [ 1 ])         }
 
-  it { should be_kind_of(described_class) }
+  it { should be_instance_of(described_class) }
 
   its(:header) { should equal(new_header) }
 

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#predicate' do
+  subject { object.predicate }
+
+  context 'when the header is empty' do
+    let(:header) { Relation::Header.new([])        }
+    let(:object) { described_class.new(header, []) }
+
+    it_should_behave_like 'an idempotent method'
+
+    it 'returns a tautology' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the header contains one attribute' do
+    let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+    let(:object) { described_class.new(header, [ 1 ])         }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_kind_of(Function) }
+
+    it 'returns an equality match' do
+      should eql(header[:id].eq(1))
+    end
+  end
+
+  context 'when the header contains two or more attribute' do
+    let(:header) { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+    let(:object) { described_class.new(header, [ 1, 'Dan Kubb' ])                }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_kind_of(Function) }
+
+    it 'returns a conjunction of equality matches' do
+      should eql(header[:id].eq(1).and(header[:name].eq('Dan Kubb')))
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ describe Tuple, '#project' do
   let(:reversed_header) { Relation::Header.new(header.to_a.reverse)                     }
   let(:object)          { described_class.new(header, [ 'Dan Kubb', 1 ])                }
 
-  it { should be_kind_of(described_class) }
+  it { should be_instance_of(described_class) }
 
   its(:header) { should equal(reversed_header) }