axiom 0.1.0 → 0.1.1

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

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

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:directions) { operand.header                                       }
-  let(:object)     { described_class.new(operand, directions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:directions) { operand.header                             }
+  let(:object)     { described_class.new(operand, directions)   }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,7 +40,7 @@ describe Relation::Operation::Order, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])        }
+    let(:other_operand)    { Relation.new([[:id, Integer]], [[1]])                }
     let(:other_directions) { directions                                           }
     let(:other)            { described_class.new(other_operand, other_directions) }
 
@@ -53,7 +53,7 @@ describe Relation::Operation::Order, '#eql?' do
 
   context 'with an object having different directions' do
     let(:other_operand)    { operand                                              }
-    let(:other_directions) { [ operand[:id].desc ]                                }
+    let(:other_directions) { [operand[:id].desc]                                  }
     let(:other)            { described_class.new(other_operand, other_directions) }
 
     it { should be(false) }

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#hash' do
   subject { object.hash }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]])           }
   let(:directions) { described_class::DirectionSet.coerce(operand.header) }
   let(:object)     { described_class.new(operand, directions)             }
 

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#header' do
   subject { object.header }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:relation) { Relation.new(header, [ [ 1 ], [ 2 ] ])        }
-  let(:object)   { described_class.new(relation, header)         }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]]) }
+  let(:relation) { Relation.new(header, [[1], [2]])          }
+  let(:object)   { described_class.new(relation, header)     }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(header) }
+  it { should be(header) }
 end

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

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)     { described_class.new(relation, directions)                  }
-  let(:relation)   { Relation.new([ attribute ], LazyEnumerable.new([ [ 1 ] ])) }
-  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]])) }
+  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, '#insert' do
 
     it 'passes expected relations into the insertion' 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 'inserts the tuples' do
-      should == [ [ 2 ], [ 1 ] ]
+      should == [[2], [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 inserted') }
   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 inserted') }
   end

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

@@ -3,40 +3,147 @@
 require 'spec_helper'
 
 describe Relation::Operation::Order::Methods, '#sort_by' do
-  let(:described_class) { Relation                                                                        }
-  let(:object)          { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
+  let(:object)     { Relation.new(header, LazyEnumerable.new([[1], [2]]))    }
+  let(:header)     { Relation::Header.coerce([[:id, Integer]])               }
+  let(:directions) { Relation::Operation::Order::DirectionSet.coerce(header) }
 
-  context 'with no block' do
-    subject { object.sort_by }
+  context 'with a block' do
+    context 'returning an array of attribute names' do
+      subject { object.sort_by(&block) }
 
-    specify { expect { subject }.to raise_error(LocalJumpError) }
-  end
+      let(:block) { ->(relation) { [relation[:id].name] } }
 
-  context 'with a block' do
-    subject { object.sort_by(&block) }
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
+
+    context 'returning an array of attributes' do
+      subject { object.sort_by(&block) }
+
+      let(:block) { ->(relation) { [relation[:id]] } }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
 
-    let(:block) { lambda { |relation| [ relation[:id].desc ] } }
+    context 'returning an array of directions' do
+      subject { object.sort_by(&block) }
 
-    it { should be_instance_of(Relation::Operation::Order) }
+      let(:block) { ->(relation) { [relation[:id].desc] } }
 
-    its(:directions) { should == block.call(object) }
+      it { should be_instance_of(Relation::Operation::Order) }
 
-    it 'behaves the same as Array#sort_by' do
-      subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] }.reverse)
+      its(:directions) { should eql(directions.reverse) }
+
+      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
+
+    context 'returning a header' do
+      subject { object.sort_by(&block) }
+
+      let(:block) { ->(relation) { header } }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
+
+    context 'returning a direction set' do
+      subject { object.sort_by(&block) }
+
+      let(:block) { ->(relation) { directions } }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
     end
   end
 
-  context 'with directions' do
-    subject { object.sort_by(directions) }
+  context 'without a block' do
+    context 'with an array of attribute names' do
+      subject { object.sort_by([header[:id].name]) }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
+
+    context 'with an array of attributes' do
+      subject { object.sort_by([header[:id]]) }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
+
+    context 'with an array of directions' do
+      subject { object.sort_by([header[:id].desc]) }
+
+      it { should be_instance_of(Relation::Operation::Order) }
 
-    let(:directions) { Relation::Operation::Order::DirectionSet.coerce(object.header) }
+      its(:directions) { should eql(directions.reverse) }
 
-    it { should be_instance_of(Relation::Operation::Order) }
+      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
+
+    context 'with a header' do
+      subject { object.sort_by(header) }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
+
+    context 'with a direction set' do
+      subject { object.sort_by(directions) }
+
+      it { should be_instance_of(Relation::Operation::Order) }
+
+      its(:directions) { should eql(directions) }
+
+      it 'behaves the same as Array#sort_by' do
+        subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      end
+    end
 
-    its(:directions) { should equal(directions) }
+    context 'with no arguments' do
+      subject { object.sort_by }
 
-    it 'behaves the same as Array#sort_by' do
-      subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+      specify { expect { subject }.to raise_error }
     end
   end
 end

data/spec/unit/axiom/relation/operation/order/methods/sort_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Order::Methods, '#sort' do
+  subject { object.sort }
+
+  let(:object)     { Relation.new(header, LazyEnumerable.new([[1], [2]]))    }
+  let(:header)     { Relation::Header.coerce([[:id, Integer]])               }
+  let(:directions) { Relation::Operation::Order::DirectionSet.coerce(header) }
+
+  it { should be_instance_of(Relation::Operation::Order) }
+
+  its(:directions) { should eql(directions) }
+
+  it 'behaves the same as Array#sort_by' do
+    subject.to_a.should eql(object.to_a.sort_by { |tuple| tuple[:id] })
+  end
+end

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

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation::Operation::Reverse, '.new' do
   subject { object.new(relation) }
 
-  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/reverse/directions_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 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(:relation) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:object)   { described_class.new(ordered)                       }
+  let(:ordered)  { relation.sort_by { |r| r.id }                      }
 
   it_should_behave_like 'an idempotent method'
 
   it 'reverses the directions' do
-    should equal(ordered.directions.reverse)
+    should eql(ordered.directions.reverse)
   end
 end

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Reverse, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(order)                                  }
-  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)                      }
+  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::Reverse, '#each' do
   end
 
   it 'yields only tuples with the expected data in reverse order' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 3 ], [ 2 ], [ 1 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[3], [2], [1]])
   end
 end

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Reverse::Methods, '#reverse' do
   subject { object.reverse }
 
-  let(:described_class) { Relation                                                                        }
-  let(:relation)        { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:object)          { relation.sort_by { |r| r.id }                                                   }
+  let(:described_class) { Relation                                                              }
+  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::Reverse) }
 

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

@@ -16,11 +16,11 @@ describe Relation::Operation::Set, '.included' do
 
   it 'delegates to the ancestor' do
     included_ancestor = false
-    subject.extend Module.new {
+    mod = Module.new do
       define_method(:included) { |_| included_ancestor = true }
-    }
-    expect {
-      klass.send(:include, subject)
-    }.to change { included_ancestor }.from(false).to(true)
+    end
+    subject.extend(mod)
+    expect { klass.send(:include, subject) }
+      .to change { included_ancestor }.from(false).to(true)
   end
 end

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

@@ -6,24 +6,24 @@ require File.expand_path('../../fixtures/classes', __FILE__)
 describe Relation::Operation::Set::ClassMethods, '#new' do
   subject { object.new(left, right) }
 
-  let(:header) { [ [ :id, Integer ] ]            }
-  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
-  let(:object) { SetOperationSpecs::Object       }
+  let(:header) { [[:id, Integer]]            }
+  let(:left)   { Relation.new(header, [[1]]) }
+  let(:object) { SetOperationSpecs::Object   }
 
   context 'with relations having equivalent headers' do
-    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+    let(:right) { Relation.new(header, [[2]]) }
 
     it { should be_instance_of(object) }
   end
 
   context 'with relations having headers with common attributes' do
-    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+    let(:right) { Relation.new([[:id, Integer], [:name, String]], [[2, 'Dan Kubb']]) }
 
     specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent') }
   end
 
   context 'with relations having different headers' do
-    let(:right) { Relation.new([ [ :number, Integer ] ], [ [ 2 ] ]) }
+    let(:right) { Relation.new([[:number, Integer]], [[2]]) }
 
     specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent') }
   end

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

@@ -6,12 +6,12 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Relation::Operation::Set, '#header' do
   subject { object.header }
 
-  let(:described_class) { SetOperationSpecs::Object                     }
-  let(:left)            { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:right)           { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:object)          { described_class.new(left, right)              }
+  let(:described_class) { SetOperationSpecs::Object             }
+  let(:left)            { Relation.new([[:id, Integer]], [[1]]) }
+  let(:right)           { Relation.new([[:id, Integer]], [[1]]) }
+  let(:object)          { described_class.new(left, right)      }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(left.header) }
+  it { should be(left.header) }
 end