axiom 0.1.1 → 0.2.0

data/spec/unit/axiom/relation/keys/class_methods/new_spec.rb

@@ -25,7 +25,7 @@ describe Relation::Keys, '.new' do
     it { should == argument }
 
     it 'does not freeze the argument' do
-      argument.should_not be_frozen
+      expect(argument).not_to be_frozen
       expect { subject }.to_not change(argument, :frozen?)
     end
   end

data/spec/unit/axiom/relation/keys/each_spec.rb

@@ -13,7 +13,7 @@ describe Relation::Keys, '#each' do
 
   it 'yields only headers' do
     subject
-    yields.each { |header| header.should be_instance_of(Relation::Header) }
+    yields.each { |header| expect(header).to be_instance_of(Relation::Header) }
   end
 
   it 'yields only headers with the expected data' do
@@ -31,6 +31,6 @@ describe Relation::Keys do
   it { should be_kind_of(Enumerable) }
 
   it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
+    expect(Enumerable === subject).to be(true)
   end
 end

data/spec/unit/axiom/relation/materialize_spec.rb

@@ -9,7 +9,7 @@ describe Relation, '#materialize' do
   let(:object) { described_class.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
 
   before do
-    object.should be_kind_of(described_class)
+    expect(object).to be_kind_of(described_class)
   end
 
   it { should be_instance_of(Relation::Materialized) }

data/spec/unit/axiom/relation/materialized/class_methods/new_spec.rb

@@ -17,7 +17,7 @@ describe Relation::Materialized, '.new' do
     its(:header) { should be(header) }
 
     its(:directions) do
-      should be_instance_of(Relation::Operation::Order::DirectionSet)
+      should be_instance_of(Relation::Operation::Sorted::DirectionSet)
       should == directions
     end
 
@@ -31,19 +31,45 @@ describe Relation::Materialized, '.new' do
 
     its(:header) { should be(header) }
 
-    its(:directions) { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
+    its(:directions) { should be(Relation::Operation::Sorted::DirectionSet::EMPTY) }
 
     it { should == tuples }
   end
 
+  context 'with empty tuples and no directions' do
+    subject { object.new(header, tuples) }
+
+    let(:tuples) { [] }
+
+    it { should be_instance_of(Relation::Empty) }
+
+    its(:header) { should be(header) }
+
+    its(:directions) { should be(Relation::Operation::Sorted::DirectionSet::EMPTY) }
+
+    it { should be_empty }
+  end
+
   context 'with no tuples or directions' do
     subject { object.new(header) }
 
-    it { should be_instance_of(object) }
+    it { should be_instance_of(Relation::Empty) }
+
+    its(:header) { should be(header) }
+
+    its(:directions) { should be(Relation::Operation::Sorted::DirectionSet::EMPTY) }
+
+    it { should be_empty }
+  end
+
+  context 'with no tuples or directions' do
+    subject { object.new(header) }
+
+    it { should be_instance_of(Relation::Empty) }
 
     its(:header) { should be(header) }
 
-    its(:directions) { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
+    its(:directions) { should be(Relation::Operation::Sorted::DirectionSet::EMPTY) }
 
     it { should be_empty }
   end

data/spec/unit/axiom/relation/materialized/directions_spec.rb

@@ -22,6 +22,6 @@ describe Relation::Materialized, '#directions' do
 
     it_should_behave_like 'an idempotent method'
 
-    it { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
+    it { should be(Relation::Operation::Sorted::DirectionSet::EMPTY) }
   end
 end

data/spec/unit/axiom/relation/materialized/materialized_predicate_spec.rb

@@ -8,7 +8,7 @@ describe Relation::Materialized, '#materialized?' do
   let(:object) { described_class.new([[:id, Integer]], [[1]]) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it { should be(true) }

data/spec/unit/axiom/relation/materialized_predicate_spec.rb

@@ -8,7 +8,7 @@ describe Relation, '#materialized?' do
   let(:object) { described_class.new([[:id, Integer]], LazyEnumerable.new) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it { should be(false) }

data/spec/unit/axiom/relation/operation/binary/class_methods/included_spec.rb

@@ -9,9 +9,9 @@ describe Relation::Operation::Binary, '.included' do
   let(:klass)  { Class.new       }
 
   it 'extends the klass' do
-    klass.singleton_class.should_not include(described_class::ClassMethods)
+    expect(klass.singleton_class).not_to include(described_class::ClassMethods)
     klass.send(:include, subject)
-    klass.singleton_class.should include(described_class::ClassMethods)
+    expect(klass.singleton_class).to include(described_class::ClassMethods)
   end
 
   it 'delegates to the ancestor' do

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

@@ -10,31 +10,31 @@ describe Relation::Operation::Binary::ClassMethods, '#new' do
   let(:original_right) { Relation.new([[:name, String]],  [['Dan Kubb']]) }
   let(:object)         { BinaryRelationOperationSpecs::Object             }
 
-  context 'with left and right ordered' do
+  context 'with left and right sorted' do
     let(:left)  { original_left.sort_by  { |r| r.id   } }
     let(:right) { original_right.sort_by { |r| r.name } }
 
     it { should be_instance_of(object) }
   end
 
-  context 'with left and right unordered' do
+  context 'with left and right unsorted' do
     let(:left)  { original_left  }
     let(:right) { original_right }
 
     it { should be_instance_of(object) }
   end
 
-  context 'with left ordered, and right unordered' do
+  context 'with left sorted, and right unsorted' do
     let(:left)  { original_left.sort_by { |r| r.id } }
     let(:right) { original_right                     }
 
-    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be sorted or neither may be sorted') }
   end
 
-  context 'with right ordered, and left unordered' do
+  context 'with right sorted, and left unsorted' do
     let(:left)  { original_left                         }
     let(:right) { original_right.sort_by { |r| r.name } }
 
-    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be sorted or neither may be sorted') }
   end
 end

data/spec/unit/axiom/relation/operation/combination/class_methods/combine_tuples_spec.rb

@@ -12,12 +12,12 @@ describe Relation::Operation::Combination, '.combine_tuples' do
     )
   end
 
-  let(:left_header)  { Relation::Header.coerce([[:id,   Integer]]) }
-  let(:right_header) { Relation::Header.coerce([[:name, String]])  }
+  let(:object)       { self.class.described_class                  }
+  let(:header)       { left_header | right_header                  }
   let(:left_tuple)   { Tuple.new(left_header,  [1])                }
   let(:right_tuples) { [Tuple.new(right_header, ['Dan Kubb'])]     }
-  let(:header)       { left_header | right_header                  }
-  let(:object)       { self.class.described_class                  }
+  let(:left_header)  { Relation::Header.coerce([[:id,   Integer]]) }
+  let(:right_header) { Relation::Header.coerce([[:name, String]])  }
   let(:yields)       { []                                          }
 
   it 'yields each combined tuple' do

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Group, '#each' do
+  subject { object }
+
+  let(:object)   { described_class.new(relation, :names, [:name]) }
+  let(:relation) { Relation.new(header, body)                     }
+  let(:header)   { [[:id, Integer], [:name, String]]              }
+  let(:body)     { [[1, 'John Doe']]                              }
+
+  it_should_behave_like 'an #each method'
+
+  it 'is a command method' do
+    expect(subject.each(&EMPTY_PROC)).to be(object)
+  end
+
+  it 'yields only tuples' do
+    expect { |block| subject.each(&block) }.to yield_with_args(Tuple)
+  end
+
+  it 'yields only tuples with the expected header' do
+    tuples = []
+    subject.each(&tuples.method(:<<))
+    expect(tuples.first.header).to be(object.header)
+  end
+
+  it 'yields only tuples with the expected data' do
+    expect { |block| subject.each(&block) }
+      .to yield_with_args([1, [['John Doe']]])
+  end
+end

data/spec/unit/axiom/relation/operation/group/header_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Group, '#header' do
+  subject { object.header }
+
+  let(:object)   { described_class.new(relation, :names, [:name]) }
+  let(:relation) { Relation.new(header, [])                       }
+  let(:header)   { [[:id, Integer], [:name, String]]              }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it 'returns the expected attributes' do
+    should == [
+      Attribute::Integer.new(:id),
+      Attribute::Relation.new(:names, header: [[:name, String]]),
+    ]
+  end
+end

data/spec/unit/axiom/relation/operation/group/methods/group_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Group::Methods, '#group' do
+  subject { object.group(name => attributes) }
+
+  let(:object)          { described_class.new(header, body) }
+  let(:described_class) { Relation                          }
+  let(:header)          { [[:id, Integer], [:name, String]] }
+  let(:body)            { [[1, 'John Doe']]                 }
+  let(:name)            { :names                            }
+  let(:attributes)      { [:name]                           }
+
+  it { should be_instance_of(Relation::Operation::Group) }
+
+  its(:header) do
+    should == [
+      Attribute::Integer.new(:id),
+      Attribute::Relation.new(:names, header: [[:name, String]]),
+    ]
+  end
+
+  its(:to_a) { should eq([[1, [['John Doe']]]]) }
+end

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

@@ -8,25 +8,25 @@ describe Relation::Operation::Limit, '.new' do
   let(:original_relation) { Relation.new([[:id, Integer]], [[1], [2]]) }
   let(:object)            { described_class                            }
 
-  context 'with an ordered relation' do
+  context 'with a sorted relation' do
     let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:limit)    { 1                                      }
 
     it { should be_instance_of(object) }
   end
 
-  context 'with an ordered relation having an empty header' do
+  context 'with a sorted relation having an empty header' do
     let(:relation) { original_relation.sort_by { |r| r.id }.project([]) }
     let(:limit)    { 1                                                  }
 
     it { should be_instance_of(object) }
   end
 
-  context 'without an ordered relation' do
+  context 'without a sorted relation' do
     let(:relation) { original_relation }
     let(:limit)    { 1                 }
 
-    specify { expect { subject }.to raise_error(OrderedRelationRequiredError, 'can only limit an ordered operand') }
+    specify { expect { subject }.to raise_error(SortededRelationRequiredError, 'can only limit a sorted operand') }
   end
 
   context 'with an limit less than 0' do

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

@@ -6,10 +6,10 @@ describe Relation::Operation::Limit, '#directions' do
   subject { object.directions }
 
   let(:relation) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
-  let(:object)   { described_class.new(ordered, 1)                    }
-  let(:ordered)  { relation.sort_by { |r| r.id }                      }
+  let(:object)   { described_class.new(sorted, 1)                     }
+  let(:sorted)   { relation.sort_by { |r| r.id }                      }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be(ordered.directions) }
+  it { should be(sorted.directions) }
 end

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

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(order, 1)                   }
+  let(:object)   { described_class.new(sorted, 1)                  }
   let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
-  let(:order)    { relation.sort_by { |r| r.id }                   }
+  let(:sorted)   { relation.sort_by { |r| r.id }                   }
   let(:yields)   { []                                              }
 
   it_should_behave_like 'an #each method'
 
   it 'yields only tuples' do
     subject
-    yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+    yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
   end
 
   it 'yields only tuples with the expected header' do
     subject
-    yields.each { |tuple| tuple.header.should be(object.header) }
+    yields.each { |tuple| expect(tuple.header).to be(object.header) }
   end
 
   it 'yields only tuples with the expected data' do

data/spec/unit/axiom/relation/operation/limit/limit_spec.rb

@@ -6,9 +6,9 @@ describe Relation::Operation::Limit, '#limit' do
   subject { object.limit }
 
   let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
-  let(:order)    { relation.sort_by { |r| r.id }                   }
+  let(:sorted)   { relation.sort_by { |r| r.id }                   }
   let(:limit)    { 1                                               }
-  let(:object)   { described_class.new(order, limit)               }
+  let(:object)   { described_class.new(sorted, limit)              }
 
   it { should == limit }
 end

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

@@ -8,25 +8,25 @@ describe Relation::Operation::Offset, '.new' do
   let(:original_relation) { Relation.new([[:id, Integer]], [[1], [2]]) }
   let(:object)            { described_class                            }
 
-  context 'with an ordered relation' do
+  context 'with a sorted relation' do
     let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:offset)   { 1                                      }
 
     it { should be_instance_of(object) }
   end
 
-  context 'with an ordered relation having an empty header' do
+  context 'with a sorted relation having an empty header' do
     let(:relation) { original_relation.sort_by { |r| r.id }.project([]) }
     let(:offset)   { 1                                                  }
 
     it { should be_instance_of(object) }
   end
 
-  context 'without an ordered relation' do
+  context 'without a sorted relation' do
     let(:relation) { original_relation }
     let(:offset)   { 1                 }
 
-    specify { expect { subject }.to raise_error(OrderedRelationRequiredError, 'can only offset an ordered operand') }
+    specify { expect { subject }.to raise_error(SortededRelationRequiredError, 'can only offset a sorted operand') }
   end
 
   context 'with an offset less than 0' do

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

@@ -6,10 +6,10 @@ 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(:object)   { described_class.new(sorted, 0)                     }
+  let(:sorted)   { relation.sort_by { |r| r.id }                      }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be(ordered.directions) }
+  it { should be(sorted.directions) }
 end

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

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

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

@@ -6,9 +6,9 @@ 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(:sorted)   { relation.sort_by { |r| r.id }                   }
   let(:offset)   { 1                                               }
-  let(:object)   { described_class.new(order, offset)              }
+  let(:object)   { described_class.new(sorted, offset)             }
 
   it { should == offset }
 end