axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/relation/operation/limit/methods/one_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Limit::Methods, '#one' do
+  subject { object.one }
+
+  let(:object) { Relation.new(header, body).sort           }
+  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
+
+  context 'with a relation having no tuples without a block' do
+    let(:body) { LazyEnumerable.new }
+
+    specify do
+      expect { subject }
+        .to raise_error(
+          NoTuplesError,
+          'one tuple expected, but was an empty set'
+        )
+    end
+
+    specify { expect { subject }.to raise_error(SetSizeError) }
+  end
+
+  context 'with a relation having no tuples with a block' do
+    subject { object.one { tuple } }
+
+    let(:body)  { LazyEnumerable.new }
+    let(:tuple) { double('tuple')    }
+
+    it 'returns the block return value' do
+      expect(subject).to be(tuple)
+    end
+
+    it 'yields the block' do
+      expect { |block| object.one(&block) }.to yield_with_no_args
+    end
+  end
+
+  context 'with a relation having one tuple' do
+    let(:body) { LazyEnumerable.new([[1]]) }
+
+    it { should be_instance_of(Tuple) }
+
+    it 'returns the expected tuple' do
+      should == [1]
+    end
+  end
+
+  context 'with a relation having many tuples' do
+    let(:body) { LazyEnumerable.new([[1], [2]]) }
+
+    specify do
+      expect { subject }
+        .to raise_error(
+          ManyTuplesError,
+          'one tuple expected, but set contained 2 tuples'
+        )
+    end
+
+    specify { expect { subject }.to raise_error(SetSizeError) }
+  end
+end

data/spec/unit/axiom/relation/operation/limit/methods/take_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Limit::Methods, '#take' do
   subject { object.take(limit) }
 
-  let(:described_class) { Relation                                                                        }
-  let(:limit)           { 1                                                                               }
-  let(:relation)        { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:object)          { relation.sort_by { |r| r.id }                                                   }
+  let(:described_class) { Relation                                                              }
+  let(:limit)           { 1                                                                     }
+  let(:relation)        { described_class.new([[:id, Integer]], LazyEnumerable.new([[1], [2]])) }
+  let(:object)          { relation.sort_by { |r| r.id }                                         }
 
   it { should be_instance_of(Relation::Operation::Limit) }
 

data/spec/unit/axiom/relation/operation/offset/class_methods/new_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '.new' do
   subject { object.new(relation, offset) }
 
-  let(:original_relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:object)            { described_class                                      }
+  let(:original_relation) { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:object)            { described_class                            }
 
   context 'with an ordered relation' do
     let(:relation) { original_relation.sort_by { |r| r.id } }

data/spec/unit/axiom/relation/operation/offset/delete_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)  { described_class.new(operand, 1)                 }
-  let(:other)   { stub('other')                                   }
-  let(:operand) { Relation.new(header, [ [ 1 ] ]).sort_by(header) }
-  let(:header)  { Relation::Header.coerce([ [ :id, Integer ] ])   }
+  let(:object)  { described_class.new(operand, 1)             }
+  let(:other)   { double('other')                             }
+  let(:operand) { Relation.new(header, [[1]]).sort_by(header) }
+  let(:header)  { Relation::Header.coerce([[:id, Integer]])   }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'deleting from an offset is impossible') }
 end

data/spec/unit/axiom/relation/operation/offset/directions_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#directions' do
   subject { object.directions }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:object)   { described_class.new(ordered, 0)                        }
-  let(:ordered)  { relation.sort_by { |r| r.id }                          }
+  let(:relation) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:object)   { described_class.new(ordered, 0)                    }
+  let(:ordered)  { relation.sort_by { |r| r.id }                      }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(ordered.directions) }
+  it { should be(ordered.directions) }
 end

data/spec/unit/axiom/relation/operation/offset/each_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(order, 1)                               }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.sort_by { |r| r.id }                               }
-  let(:yields)   { []                                                          }
+  let(:object)   { described_class.new(order, 1)                   }
+  let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
+  let(:order)    { relation.sort_by { |r| r.id }                   }
+  let(:yields)   { []                                              }
 
   it_should_behave_like 'an #each method'
 
@@ -23,8 +23,8 @@ describe Relation::Operation::Offset, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 2 ], [ 3 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[2], [3]])
   end
 end

data/spec/unit/axiom/relation/operation/offset/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).sort_by { |r| r.id } }
-  let(:offset)  { 1                                                                                }
-  let(:object)  { described_class.new(operand, offset)                                             }
+  let(:operand) { Relation.new([[:id, Integer]], [[1], [2], [3]]).sort_by { |r| r.id } }
+  let(:offset)  { 1                                                                    }
+  let(:object)  { described_class.new(operand, offset)                                 }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,9 +40,9 @@ describe Relation::Operation::Offset, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]).sort_by { |r| r.id } }
-    let(:other_offset)  { offset                                                                    }
-    let(:other)         { described_class.new(other_operand, other_offset)                          }
+    let(:other_operand) { Relation.new([[:id, Integer]], [[1], [2]]).sort_by { |r| r.id } }
+    let(:other_offset)  { offset                                                          }
+    let(:other)         { described_class.new(other_operand, other_offset)                }
 
     it { should be(false) }
 

data/spec/unit/axiom/relation/operation/offset/hash_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#hash' do
   subject { object.hash }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:operand)  { relation.sort_by { |r| r.id }                               }
-  let(:offset)   { 1                                                           }
-  let(:object)   { described_class.new(operand, offset)                        }
+  let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
+  let(:operand)  { relation.sort_by { |r| r.id }                   }
+  let(:offset)   { 1                                               }
+  let(:object)   { described_class.new(operand, offset)            }
 
   it_should_behave_like 'a hash method'
 

data/spec/unit/axiom/relation/operation/offset/insert_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)  { described_class.new(operand, 1)                 }
-  let(:other)   { stub('other')                                   }
-  let(:operand) { Relation.new(header, [ [ 1 ] ]).sort_by(header) }
-  let(:header)  { Relation::Header.coerce([ [ :id, Integer ] ])   }
+  let(:object)  { described_class.new(operand, 1)             }
+  let(:other)   { double('other')                             }
+  let(:operand) { Relation.new(header, [[1]]).sort_by(header) }
+  let(:header)  { Relation::Header.coerce([[:id, Integer]])   }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'inserting into an offset is impossible') }
 end

data/spec/unit/axiom/relation/operation/offset/methods/drop_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset::Methods, '#drop' do
   subject { object.drop(offset) }
 
-  let(:described_class) { Relation                                                                        }
-  let(:offset)          { 1                                                                               }
-  let(:relation)        { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:object)          { relation.sort_by { |r| r.id }                                                   }
+  let(:described_class) { Relation                                                              }
+  let(:offset)          { 1                                                                     }
+  let(:relation)        { described_class.new([[:id, Integer]], LazyEnumerable.new([[1], [2]])) }
+  let(:object)          { relation.sort_by { |r| r.id }                                         }
 
   it { should be_instance_of(Relation::Operation::Offset) }
 

data/spec/unit/axiom/relation/operation/offset/offset_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#offset' do
   subject { object.offset }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.sort_by { |r| r.id }                               }
-  let(:offset)   { 1                                                           }
-  let(:object)   { described_class.new(order, offset)                          }
+  let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
+  let(:order)    { relation.sort_by { |r| r.id }                   }
+  let(:offset)   { 1                                               }
+  let(:object)   { described_class.new(order, offset)              }
 
   it { should == offset }
 end

data/spec/unit/axiom/relation/operation/order/ascending/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Relation::Operation::Order::Ascending, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Relation::Operation::Order::Descending) }
+  it { should be(Relation::Operation::Order::Descending) }
 end

data/spec/unit/axiom/relation/operation/order/ascending/reverse_spec.rb

@@ -10,5 +10,5 @@ describe Relation::Operation::Order::Ascending, '#reverse' do
 
   it { should be_instance_of(Relation::Operation::Order::Descending) }
 
-  its(:attribute) { should equal(attribute) }
+  its(:attribute) { should be(attribute) }
 end

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

@@ -5,30 +5,132 @@ require 'spec_helper'
 describe Relation::Operation::Order, '.new' do
   subject { object.new(relation, directions) }
 
-  let(:header)   { [ [ :id, Integer ], [ :name, String ] ]   }
-  let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ] }
-  let(:relation) { Relation.new(header, body)                }
-  let(:object)   { described_class                           }
+  let(:object)   { described_class                     }
+  let(:relation) { Relation.new(header, body)          }
+  let(:header)   { [[:id, Integer], [:name, String]]   }
+  let(:body)     { [[1, 'Dan Kubb'], [2, 'Alex Kubb']] }
 
-  context 'with all attributes specified in the directions' do
-    let(:directions) { [ relation[:id], relation[:name] ] }
+  context 'attribute names' do
+    context 'full header' do
+      let(:directions) { [:id, :name] }
 
-    it { should be_instance_of(object) }
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:id].asc, relation[:name].asc] }
+    end
 
-    its(:operand) { should equal(relation) }
+    context 'partial header' do
+      let(:directions) { [:name] }
 
-    its(:directions) { should == [ relation[:id].asc, relation[:name].asc ] }
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:name].asc, relation[:id].asc] }
+    end
   end
 
-  context 'without no attributes specified in the directions' do
-    let(:directions) { [] }
+  context 'attributes' do
+    context 'full header' do
+      let(:directions) { [relation[:id], relation[:name]] }
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:id].asc, relation[:name].asc] }
+    end
+
+    context 'partial header' do
+      let(:directions) { [relation[:name]] }
+
+      it { should be_instance_of(object) }
 
-    specify { expect { subject }.to raise_error(InvalidDirectionsError, 'directions must include every attribute in the header') }
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:name].asc, relation[:id].asc] }
+    end
   end
 
-  context 'without all attributes specified in the directions' do
-    let(:directions) { [ relation[:id] ] }
+  context 'array of directions' do
+    context 'full header' do
+      let(:directions) { [relation[:id].desc, relation[:name].desc] }
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:id].desc, relation[:name].desc] }
+    end
+
+    context 'partial header' do
+      let(:directions) { [relation[:name].desc] }
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:name].desc, relation[:id].asc] }
+    end
+  end
+
+  context 'header' do
+    context 'full header' do
+      let(:directions) { relation.header }
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:id].asc, relation[:name].asc] }
+    end
+
+    context 'partial header' do
+      let(:directions) { relation.header.project([:name]) }
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:name].asc, relation[:id].asc] }
+    end
+  end
+
+  context 'direction set' do
+    context 'full header' do
+      let(:directions) do
+        Relation::Operation::Order::DirectionSet.new([relation[:id].desc, relation[:name].desc])
+      end
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:id].desc, relation[:name].desc] }
+    end
+
+    context 'partial header' do
+      let(:directions) do
+        Relation::Operation::Order::DirectionSet.new([relation[:name].desc])
+      end
+
+      it { should be_instance_of(object) }
+
+      its(:operand) { should be(relation) }
+
+      its(:directions) { should == [relation[:name].desc, relation[:id].asc] }
+    end
+  end
+
+  context 'no attributes' do
+    let(:directions) { [] }
+
+    it { should be_instance_of(object) }
+
+    its(:operand) { should be(relation) }
 
-    specify { expect { subject }.to raise_error(InvalidDirectionsError, 'directions must include every attribute in the header') }
+    its(:directions) { should == [relation[:id].asc, relation[:name].asc] }
   end
 end

data/spec/unit/axiom/relation/operation/order/delete_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)     { described_class.new(relation, directions)                                }
-  let(:relation)   { Relation.new([ attribute ], LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ])) }
-  let(:attribute)  { Attribute::Integer.new(:id)                                              }
-  let(:directions) { [ attribute.desc ]                                                       }
+  let(:object)     { described_class.new(relation, directions)                      }
+  let(:relation)   { Relation.new([attribute], LazyEnumerable.new([[1], [2], [3]])) }
+  let(:attribute)  { Attribute::Integer.new(:id)                                    }
+  let(:directions) { [attribute.desc]                                               }
 
   context 'when other relation has matching directions' do
-    let(:other)      { other_base.sort_by(directions)                             }
-    let(:other_base) { Relation.new([ attribute ], LazyEnumerable.new([ [ 2 ] ])) }
+    let(:other)      { other_base.sort_by(directions)                       }
+    let(:other_base) { Relation.new([attribute], LazyEnumerable.new([[2]])) }
 
     it { should be_instance_of(described_class) }
 
@@ -20,25 +20,25 @@ describe Relation::Operation::Order, '#delete' do
 
     it 'passes expected relations into the deletion' do
       subject = self.subject.operand
-      subject.left.should equal(relation)
-      subject.right.should equal(other_base)
+      subject.left.should be(relation)
+      subject.right.should be(other_base)
     end
 
     its(:directions) { should == directions }
 
     it 'deletes the tuples' do
-      should == [ [ 3 ], [ 1 ] ]
+      should == [[3], [1]]
     end
   end
 
   context 'when other relation does not have the same directions' do
-    let(:other) { Relation.new([ attribute ], LazyEnumerable.new([ [ 2 ] ])).sort_by([ attribute ]) }
+    let(:other) { Relation.new([attribute], LazyEnumerable.new([[2]])).sort_by([attribute]) }
 
     specify { expect { subject }.to raise_error(OrderMismatchError, 'other relation must have matching directions to be deleted') }
   end
 
   context 'when other relation is not an order' do
-    let(:other) { Relation.new([ attribute ], LazyEnumerable.new([ [ 2 ] ])) }
+    let(:other) { Relation.new([attribute], LazyEnumerable.new([[2]])) }
 
     specify { expect { subject }.to raise_error(OrderMismatchError, 'other relation must have matching directions to be deleted') }
   end