axiom 0.1.1 → 0.2.0

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#attributes' do
+describe Relation::Operation::Sorted::DirectionSet, '#attributes' do
   subject { object.attributes }
 
   let(:attribute) { Attribute::Integer.new(:id)         }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '.coerce' do
+describe Relation::Operation::Sorted::DirectionSet, '.coerce' do
   subject { object.coerce(argument) }
 
   let(:object)        { described_class             }
@@ -14,8 +14,8 @@ describe Relation::Operation::Order::DirectionSet, '.coerce' do
     subject { object.coerce(argument, &block) }
 
     context 'when the argument is a DirectionSet' do
-      let(:argument) { direction_set                     }
-      let(:block)    { proc { raise 'should not raise' } }
+      let(:argument) { direction_set                   }
+      let(:block)    { proc { fail 'should not fail' } }
 
       it { should be(direction_set) }
     end

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '.new' do
+describe Relation::Operation::Sorted::DirectionSet, '.new' do
   subject { object.new(argument) }
 
   let(:id)     { Attribute::Integer.new(:id).asc  }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#eql?' do
+describe Relation::Operation::Sorted::DirectionSet, '#eql?' do
   subject { object.eql?(other) }
 
   let(:attributes) { [Attribute::Integer.new(:id)]      }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#==' do
+describe Relation::Operation::Sorted::DirectionSet, '#==' do
   subject { object == other }
 
   let(:attributes) { [Attribute::Integer.new(:id)]      }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#project' do
+describe Relation::Operation::Sorted::DirectionSet, '#project' do
   subject { object.project(attributes) }
 
   let(:header)     { Relation::Header.coerce([[:id, Integer], [:name, String]]) }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#rename' do
+describe Relation::Operation::Sorted::DirectionSet, '#rename' do
   subject { object.rename(aliases) }
 
   let(:attribute) { Attribute::Integer.new(:id)                            }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#reverse' do
+describe Relation::Operation::Sorted::DirectionSet, '#reverse' do
   subject { object.reverse }
 
   let(:attribute1) { Attribute::Integer.new(:id)                      }
@@ -18,6 +18,6 @@ describe Relation::Operation::Order::DirectionSet, '#reverse' do
   end
 
   it 'does not reverse the attribute order' do
-    subject.attributes.should eql([attribute1, attribute2])
+    expect(subject.attributes).to eql([attribute1, attribute2])
   end
 end

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
+describe Relation::Operation::Sorted::DirectionSet, '#sort_tuples' do
   subject { object.sort_tuples(relation) }
 
   let(:header)   { [[:id, Integer], [:name, String]]                    }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::DirectionSet, '#to_ary' do
+describe Relation::Operation::Sorted::DirectionSet, '#to_ary' do
   subject { object.to_ary }
 
   let(:attribute) { Attribute::Integer.new(:id)         }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#directions' do
+describe Relation::Operation::Sorted, '#directions' do
   subject { object.directions }
 
   let(:relation)   { Relation.new([[:id, Integer]], LazyEnumerable.new)    }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#each' do
+describe Relation::Operation::Sorted, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:object)     { described_class.new(relation, directions)       }
@@ -14,12 +14,12 @@ describe Relation::Operation::Order, '#each' do
 
   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 order' do

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#eql?' do
+describe Relation::Operation::Sorted, '#eql?' do
   subject { object.eql?(other) }
 
   let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#header' do
+describe Relation::Operation::Sorted, '#header' do
   subject { object.header }
 
   let(:header)   { Relation::Header.coerce([[:id, Integer]]) }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#insert' do
+describe Relation::Operation::Sorted, '#insert' do
   subject { object.insert(other) }
 
   let(:object)     { described_class.new(relation, directions)            }
@@ -20,8 +20,8 @@ describe Relation::Operation::Order, '#insert' do
 
     it 'passes expected relations into the insertion' 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, '#insert' 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 inserted') }
+    specify { expect { subject }.to raise_error(SortedMismatchError, 'other relation must have matching directions to be inserted') }
   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 inserted') }
+    specify { expect { subject }.to raise_error(SortedMismatchError, 'other relation must have matching directions to be inserted') }
+  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 inserted') }
   end
 end

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

@@ -2,10 +2,10 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order::Methods, '#sort_by' do
-  let(:object)     { Relation.new(header, LazyEnumerable.new([[1], [2]]))    }
-  let(:header)     { Relation::Header.coerce([[:id, Integer]])               }
-  let(:directions) { Relation::Operation::Order::DirectionSet.coerce(header) }
+describe Relation::Operation::Sorted::Methods, '#sort_by' do
+  let(:object)     { Relation.new(header, LazyEnumerable.new([[1], [2]]))     }
+  let(:header)     { Relation::Header.coerce([[:id, Integer]])                }
+  let(:directions) { Relation::Operation::Sorted::DirectionSet.coerce(header) }
 
   context 'with a block' do
     context 'returning an array of attribute names' do
@@ -13,12 +13,12 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
 
       let(:block) { ->(relation) { [relation[:id].name] } }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
       end
     end
 
@@ -27,12 +27,12 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
 
       let(:block) { ->(relation) { [relation[:id]] } }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
       end
     end
 
@@ -41,12 +41,12 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
 
       let(:block) { ->(relation) { [relation[:id].desc] } }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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)
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] }.reverse)
       end
     end
 
@@ -55,12 +55,12 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
 
       let(:block) { ->(relation) { header } }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
       end
     end
 
@@ -69,12 +69,12 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
 
       let(:block) { ->(relation) { directions } }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
       end
     end
   end
@@ -83,60 +83,60 @@ describe Relation::Operation::Order::Methods, '#sort_by' do
     context 'with an array of attribute names' do
       subject { object.sort_by([header[:id].name]) }
 
-      it { should be_instance_of(Relation::Operation::Order) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to 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) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to 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) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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)
+        expect(subject.to_a).to 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) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to 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) }
+      it { should be_instance_of(Relation::Operation::Sorted) }
 
       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] })
+        expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
       end
     end
 

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Sorted::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::Sorted::DirectionSet.coerce(header) }
+
+  it { should be_instance_of(Relation::Operation::Sorted) }
+
+  its(:directions) { should eql(directions) }
+
+  it 'behaves the same as Array#sort_by' do
+    expect(subject.to_a).to eql(object.to_a.sort_by { |tuple| tuple[:id] })
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Ungroup, '#each' do
+  subject { object }
+
+  let(:object)   { described_class.new(relation, :names)            }
+  let(:relation) { Relation.new(header, body).group(names: [:name]) }
+  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 eq(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/ungroup/header_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Ungroup, '#header' do
+  subject { object.header }
+
+  let(:object)   { described_class.new(relation, :names)          }
+  let(:relation) { Relation.new(header, []).group(names: [:name]) }
+  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 == header
+  end
+end

data/spec/unit/axiom/relation/operation/ungroup/methods/ungroup_spec.rb

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