axiom 0.1.1 → 0.2.0

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

@@ -8,29 +8,29 @@ describe Relation::Operation::Reverse, '.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 } }
 
     it { should be_instance_of(object) }
 
     it 'reverses the directions' do
-      subject.directions.should eql(relation.directions.reverse)
+      expect(subject.directions).to eql(relation.directions.reverse)
     end
   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([]) }
 
     it { should be_instance_of(object) }
 
     it 'reverses the directions' do
-      subject.directions.should eql(relation.directions.reverse)
+      expect(subject.directions).to eql(relation.directions.reverse)
     end
   end
 
-  context 'without an ordered relation' do
+  context 'without a sorted relation' do
     let(:relation) { original_relation }
 
-    specify { expect { subject }.to raise_error(OrderedRelationRequiredError, 'can only reverse an ordered operand') }
+    specify { expect { subject }.to raise_error(SortededRelationRequiredError, 'can only reverse a sorted operand') }
   end
 end

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

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

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

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Relation::Operation::Reverse, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(order)                      }
+  let(:object)   { described_class.new(sorted)                     }
   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 in reverse order' do

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

@@ -9,9 +9,9 @@ describe Relation::Operation::Set, '.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/{order → sorted}/ascending/class_methods/call_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Ascending, '.call' do
+describe Relation::Operation::Sorted::Ascending, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
@@ -27,4 +27,25 @@ describe Relation::Operation::Order::Ascending, '.call' do
 
     it { should be(-1) }
   end
+
+  context 'when left and right are nil' do
+    let(:left)  { nil }
+    let(:right) { nil }
+
+    it { should be(0) }
+  end
+
+  context 'when left is nil' do
+    let(:left)  { nil }
+    let(:right) { 2   }
+
+    it { should be(1) }
+  end
+
+  context 'when right is nil' do
+    let(:left)  { 1   }
+    let(:right) { nil }
+
+    it { should be(-1) }
+  end
 end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Sorted::Ascending, '.reverse' do
+  subject { object.reverse }
+
+  let(:object) { described_class }
+
+  it { should be(Relation::Operation::Sorted::Descending) }
+end

data/spec/unit/axiom/relation/operation/{order/descending → sorted/ascending}/reverse_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Descending, '#reverse' do
+describe Relation::Operation::Sorted::Ascending, '#reverse' do
   subject { object.reverse }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
   let(:object)    { described_class.new(attribute) }
 
-  it { should be_instance_of(Relation::Operation::Order::Ascending) }
+  it { should be_instance_of(Relation::Operation::Sorted::Descending) }
 
   its(:attribute) { should be(attribute) }
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/class_methods/new_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '.new' do
+describe Relation::Operation::Sorted, '.new' do
   subject { object.new(relation, directions) }
 
   let(:object)   { described_class                     }
@@ -101,19 +101,19 @@ describe Relation::Operation::Order, '.new' do
   context 'direction set' do
     context 'full header' do
       let(:directions) do
-        Relation::Operation::Order::DirectionSet.new([relation[:id].desc, relation[:name].desc])
+        Relation::Operation::Sorted::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] }
+      its(:directions) { should be(directions) }
     end
 
     context 'partial header' do
       let(:directions) do
-        Relation::Operation::Order::DirectionSet.new([relation[:name].desc])
+        Relation::Operation::Sorted::DirectionSet.new([relation[:name].desc])
       end
 
       it { should be_instance_of(object) }

data/spec/unit/axiom/relation/operation/{order → sorted}/delete_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#delete' do
+describe Relation::Operation::Sorted, '#delete' do
   subject { object.delete(other) }
 
   let(:object)     { described_class.new(relation, directions)                      }
@@ -20,8 +20,8 @@ describe Relation::Operation::Order, '#delete' do
 
     it 'passes expected relations into the deletion' do
       subject = self.subject.operand
-      subject.left.should be(relation)
-      subject.right.should be(other_base)
+      expect(subject.left).to be(relation)
+      expect(subject.right).to be(other_base)
     end
 
     its(:directions) { should == directions }
@@ -34,12 +34,18 @@ describe Relation::Operation::Order, '#delete' do
   context 'when other relation does not have the same directions' do
     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') }
+    specify { expect { subject }.to raise_error(SortedMismatchError, 'other relation must have matching directions to be deleted') }
   end
 
-  context 'when other relation is not an order' do
+  context 'when other relation is not sorted' do
     let(:other) { Relation.new([attribute], LazyEnumerable.new([[2]])) }
 
-    specify { expect { subject }.to raise_error(OrderMismatchError, 'other relation must have matching directions to be deleted') }
+    specify { expect { subject }.to raise_error(SortedMismatchError, 'other relation must have matching directions to be deleted') }
+  end
+
+  context 'when other object is not a relation' do
+    let(:other) { LazyEnumerable.new([[2]]) }
+
+    specify { expect { subject }.to raise_error(SortedMismatchError, 'other relation must have matching directions to be deleted') }
   end
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/descending/class_methods/call_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Descending, '.call' do
+describe Relation::Operation::Sorted::Descending, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
@@ -27,4 +27,25 @@ describe Relation::Operation::Order::Descending, '.call' do
 
     it { should be(1) }
   end
+
+  context 'when left and right are nil' do
+    let(:left)  { nil }
+    let(:right) { nil }
+
+    it { should be(0) }
+  end
+
+  context 'when left is nil' do
+    let(:left)  { nil }
+    let(:right) { 1   }
+
+    it { should be(-1) }
+  end
+
+  context 'when right is nil' do
+    let(:left)  { 1   }
+    let(:right) { nil }
+
+    it { should be(1) }
+  end
 end

data/spec/unit/axiom/relation/operation/sorted/descending/class_methods/reverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Sorted::Descending, '.reverse' do
+  subject { object.reverse }
+
+  let(:object) { described_class }
+
+  it { should be(Relation::Operation::Sorted::Ascending) }
+end

data/spec/unit/axiom/relation/operation/{order/ascending → sorted/descending}/reverse_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Ascending, '#reverse' do
+describe Relation::Operation::Sorted::Descending, '#reverse' do
   subject { object.reverse }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
   let(:object)    { described_class.new(attribute) }
 
-  it { should be_instance_of(Relation::Operation::Order::Descending) }
+  it { should be_instance_of(Relation::Operation::Sorted::Ascending) }
 
   its(:attribute) { should be(attribute) }
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/attribute_spec.rb

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '#attribute' do
+describe Relation::Operation::Sorted::Direction, '#attribute' do
   subject { object.attribute }
 
-  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:object)          { described_class.new(attribute)                   }
+  let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+  let(:attribute)       { Attribute::Integer.new(:id)                       }
+  let(:object)          { described_class.new(attribute)                    }
 
   it { should be(attribute) }
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/call_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '#call' do
+describe Relation::Operation::Sorted::Direction, '#call' do
   subject { object.call(left, right) }
 
-  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:header)          { Relation::Header.coerce([[:id, Integer]])        }
-  let(:left)            { Tuple.new(header, [1])                           }
-  let(:right)           { Tuple.new(header, [2])                           }
-  let(:object)          { described_class.new(header[:id])                 }
+  let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]])         }
+  let(:left)            { Tuple.new(header, [1])                            }
+  let(:right)           { Tuple.new(header, [2])                            }
+  let(:object)          { described_class.new(header[:id])                  }
 
   it 'sends the tuple value to self.class.call' do
     response = double('#call response')
-    described_class.should_receive(:call).with(1, 2).and_return(response)
+    expect(described_class).to receive(:call).with(1, 2).and_return(response)
     should be(response)
   end
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/class_methods/coerce_spec.rb

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '.coerce' do
+describe Relation::Operation::Sorted::Direction, '.coerce' do
   subject { object.coerce(argument) }
 
   let(:object)    { Class.new(described_class)  }
   let(:attribute) { Attribute::Integer.new(:id) }
 
   context 'when the argument is a Direction' do
-    let(:argument) { Relation::Operation::Order::Ascending.new(attribute) }
+    let(:argument) { Relation::Operation::Sorted::Ascending.new(attribute) }
 
     it { should be(argument) }
   end

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/eql_predicate_spec.rb

@@ -3,12 +3,12 @@
 require 'spec_helper'
 
 [:eql?, :==].each do |method|
-  describe Relation::Operation::Order::Direction, "##{method}" do
+  describe Relation::Operation::Sorted::Direction, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-    let(:attribute)       { Attribute::Integer.new(:id)                      }
-    let(:object)          { described_class.new(attribute)                   }
+    let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+    let(:attribute)       { Attribute::Integer.new(:id)                       }
+    let(:object)          { described_class.new(attribute)                    }
 
     context 'with the same object' do
       let(:other) { object }

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/name_spec.rb

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '#name' do
+describe Relation::Operation::Sorted::Direction, '#name' do
   subject { object.name }
 
-  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:object)          { described_class.new(attribute)                   }
+  let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+  let(:attribute)       { Attribute::Integer.new(:id)                       }
+  let(:object)          { described_class.new(attribute)                    }
 
   it { should be(:id) }
 end

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/rename_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '#rename' do
+describe Relation::Operation::Sorted::Direction, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:header)          { Relation::Header.new([attribute])                }
-  let(:object)          { described_class.new(attribute)                   }
+  let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+  let(:attribute)       { Attribute::Integer.new(:id)                       }
+  let(:header)          { Relation::Header.new([attribute])                 }
+  let(:object)          { described_class.new(attribute)                    }
 
   context 'with aliases matching the attribute' do
     let(:aliases) { Algebra::Rename::Aliases.coerce(header, id: :other_id) }

data/spec/unit/axiom/relation/operation/{order → sorted}/direction/reverse_spec.rb

@@ -2,26 +2,26 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Direction, '#reverse' do
+describe Relation::Operation::Sorted::Direction, '#reverse' do
   subject { object.reverse }
 
-  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:reverse_class)   { double('Reverse Class', new: reverse)            }
-  let(:reverse)         { double('Reverse Instance')                       }
-  let(:object)          { described_class.new(attribute)                   }
+  let(:described_class) { Class.new(Relation::Operation::Sorted::Direction) }
+  let(:attribute)       { Attribute::Integer.new(:id)                       }
+  let(:reverse_class)   { double('Reverse Class', new: reverse)             }
+  let(:reverse)         { double('Reverse Instance')                        }
+  let(:object)          { described_class.new(attribute)                    }
 
   before do
-    described_class.stub(reverse: reverse_class)
+    allow(described_class).to receive(:reverse).and_return(reverse_class)
   end
 
   it 'calls .reverse on the class' do
-    described_class.should_receive(:reverse).with(no_args)
+    expect(described_class).to receive(:reverse).with(no_args)
     subject
   end
 
   it 'calls .new on the reverse class' do
-    reverse_class.should_receive(:new).with(attribute)
+    expect(reverse_class).to receive(:new).with(attribute)
     subject
   end