axiom 0.1.0 → 0.1.1

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Materialized, '#materialized?' do
   subject { object.materialized? }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object) { described_class.new([[:id, Integer]], [[1]]) }
 
   before do
     object.should be_instance_of(described_class)

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Materialized, '#size' do
   subject { object.size }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object) { described_class.new([[:id, Integer]], [[1]]) }
 
   it_should_behave_like 'an idempotent method'
 

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation, '#materialized?' do
   subject { object.materialized? }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+  let(:object) { described_class.new([[:id, Integer]], LazyEnumerable.new) }
 
   before do
     object.should be_instance_of(described_class)

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

@@ -16,11 +16,11 @@ describe Relation::Operation::Binary, '.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/binary/class_methods/new_spec.rb

@@ -6,9 +6,9 @@ require File.expand_path('../../fixtures/classes', __FILE__)
 describe Relation::Operation::Binary::ClassMethods, '#new' do
   subject { object.new(left, right) }
 
-  let(:original_left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
-  let(:original_right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
-  let(:object)         { BinaryRelationOperationSpecs::Object                     }
+  let(:original_left)  { Relation.new([[:id,   Integer]], [[1]])          }
+  let(:original_right) { Relation.new([[:name, String]],  [['Dan Kubb']]) }
+  let(:object)         { BinaryRelationOperationSpecs::Object             }
 
   context 'with left and right ordered' do
     let(:left)  { original_left.sort_by  { |r| r.id   } }

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

@@ -6,14 +6,14 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Relation::Operation::Binary, '#header' do
   subject { object.header }
 
-  let(:described_class) { BinaryRelationOperationSpecs::Object                     }
-  let(:left)            { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
-  let(:right)           { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
-  let(:object)          { described_class.new(left, right)                         }
+  let(:described_class) { BinaryRelationOperationSpecs::Object             }
+  let(:left)            { Relation.new([[:id,   Integer]], [[1]])          }
+  let(:right)           { Relation.new([[:name, String]],  [['Dan Kubb']]) }
+  let(:object)          { described_class.new(left, right)                 }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(Relation::Header) }
 
-  it { should == [ [ :id, Integer ], [ :name, String ] ] }
+  it { should == [[:id, Integer], [:name, String]] }
 end

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

@@ -3,19 +3,26 @@
 require 'spec_helper'
 
 describe Relation::Operation::Combination, '.combine_tuples' do
-  subject { object.combine_tuples(header, left_tuple, right_tuples) { |tuple| yields << tuple } }
+  subject do
+    object.combine_tuples(
+      header,
+      left_tuple,
+      right_tuples,
+      &yields.method(:<<)
+    )
+  end
 
-  let(:left_header)  { Relation::Header.coerce([ [ :id,   Integer ] ] ) }
-  let(:right_header) { Relation::Header.coerce([ [ :name, String  ] ] ) }
-  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(:yields)       { []                                               }
+  let(:left_header)  { Relation::Header.coerce([[:id,   Integer]]) }
+  let(:right_header) { Relation::Header.coerce([[:name, String]])  }
+  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(:yields)       { []                                          }
 
   it 'yields each combined tuple' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 1, 'Dan Kubb' ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[1, 'Dan Kubb']])
   end
 end

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

@@ -6,16 +6,16 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Relation::Operation::Combination, '#header' do
   subject { object.header }
 
-  let(:described_class) { CombinationOperationSpecs::Object                        }
-  let(:left)            { Relation.new([ [ :id,   Integer ] ], [ [ 1 ], [ 2 ] ])   }
-  let(:right)           { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
-  let(:object)          { described_class.new(left, right)                         }
+  let(:described_class) { CombinationOperationSpecs::Object                }
+  let(:left)            { Relation.new([[:id,   Integer]], [[1], [2]])     }
+  let(:right)           { Relation.new([[:name, String]],  [['Dan Kubb']]) }
+  let(:object)          { described_class.new(left, right)                 }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(Relation::Header) }
 
   it 'unions the headers' do
-    should == [ [ :id, Integer ], [ :name, String ] ]
+    should == [[:id, Integer], [:name, String]]
   end
 end

data/spec/unit/axiom/relation/operation/deletion/initialize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation::Operation::Deletion, '#initialize' do
   subject { described_class.new(base, other) }
 
-  let(:base)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:other) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:base)  { Relation.new([[:id, Integer]], [[1]]) }
+  let(:other) { Relation.new([[:id, Integer]], [[1]]) }
 
   it { should be_instance_of(described_class) }
 

data/spec/unit/axiom/relation/operation/deletion/methods/delete_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation::Operation::Deletion::Methods, '#insert' do
   subject { object.delete(other) }
 
-  let(:object) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:tuples) { [ [ 1 ] ]                                            }
+  let(:object) { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:tuples) { [[1]]                                      }
 
   context 'when other is a Relation' do
-    let(:other) { Relation.new([ [ :id, Integer ] ], tuples) }
+    let(:other) { Relation.new([[:id, Integer]], tuples) }
 
     it { should be_instance_of(Relation::Operation::Deletion) }
 
@@ -18,7 +18,7 @@ describe Relation::Operation::Deletion::Methods, '#insert' do
     its(:right) { should be(other) }
 
     it 'returns the expected tuples' do
-      should == [ [ 2 ] ]
+      should == [[2]]
     end
   end
 
@@ -36,7 +36,7 @@ describe Relation::Operation::Deletion::Methods, '#insert' do
     its(:right) { should == other }
 
     it 'returns the expected tuples' do
-      should == [ [ 2 ] ]
+      should == [[2]]
     end
   end
 end

data/spec/unit/axiom/relation/operation/insertion/initialize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation::Operation::Insertion, '#initialize' do
   subject { described_class.new(base, other) }
 
-  let(:base)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:other) { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ]) }
+  let(:base)  { Relation.new([[:id, Integer]], [[1]]) }
+  let(:other) { Relation.new([[:id, Integer]], [[2]]) }
 
   it { should be_instance_of(described_class) }
 

data/spec/unit/axiom/relation/operation/insertion/methods/insert_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation::Operation::Insertion::Methods, '#insert' do
   subject { object.insert(other) }
 
-  let(:object) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:tuples) { [ [ 2 ] ]                                     }
+  let(:object) { Relation.new([[:id, Integer]], [[1]]) }
+  let(:tuples) { [[2]]                                 }
 
   context 'when other is a Relation' do
-    let(:other) { Relation.new([ [ :id, Integer ] ], tuples) }
+    let(:other) { Relation.new([[:id, Integer]], tuples) }
 
     it { should be_instance_of(Relation::Operation::Insertion) }
 
@@ -18,7 +18,7 @@ describe Relation::Operation::Insertion::Methods, '#insert' do
     its(:right) { should be(other) }
 
     it 'returns the expected tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 
@@ -36,7 +36,7 @@ describe Relation::Operation::Insertion::Methods, '#insert' do
     its(:right) { should == other }
 
     it 'returns the expected tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 end

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

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#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 a limit is impossible') }
 end

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 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(:relation) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:object)   { described_class.new(ordered, 1)                    }
+  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/limit/each_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#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::Limit, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 1 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[1]])
   end
 end

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).sort_by { |r| r.id } }
-  let(:limit)   { 1                                                                                }
-  let(:object)  { described_class.new(operand, limit)                                              }
+  let(:operand) { Relation.new([[:id, Integer]], [[1], [2], [3]]).sort_by { |r| r.id } }
+  let(:limit)   { 1                                                                    }
+  let(:object)  { described_class.new(operand, limit)                                  }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,9 +40,9 @@ describe Relation::Operation::Limit, '#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_limit)   { limit                                                                     }
-    let(:other)         { described_class.new(other_operand, other_limit)                           }
+    let(:other_operand) { Relation.new([[:id, Integer]], [[1], [2]]).sort_by { |r| r.id } }
+    let(:other_limit)   { limit                                                           }
+    let(:other)         { described_class.new(other_operand, other_limit)                 }
 
     it { should be(false) }
 

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

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

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#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 a limit is impossible') }
 end

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 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(:limit)    { 1                                                           }
-  let(:object)   { described_class.new(order, limit)                           }
+  let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
+  let(:order)    { relation.sort_by { |r| r.id }                   }
+  let(:limit)    { 1                                               }
+  let(:object)   { described_class.new(order, limit)               }
 
   it { should == limit }
 end

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

@@ -3,9 +3,9 @@
 require 'spec_helper'
 
 describe Relation::Operation::Limit::Methods, '#first' do
-  let(:described_class) { Relation                                                                               }
-  let(:relation)        { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ])) }
-  let(:object)          { relation.sort_by { |r| r.id }                                                          }
+  let(:described_class) { Relation                                                                   }
+  let(:relation)        { described_class.new([[:id, Integer]], LazyEnumerable.new([[1], [2], [3]])) }
+  let(:object)          { relation.sort_by { |r| r.id }                                              }
 
   context 'with no arguments' do
     subject { object.first }
@@ -15,11 +15,11 @@ describe Relation::Operation::Limit::Methods, '#first' do
     its(:limit) { should == 1 }
 
     it 'returns the expected tuples' do
-      should == [ [ 1 ] ]
+      should == [[1]]
     end
 
     it 'behaves similar to Array#first' do
-      should == [ object.to_a.first ]
+      should == [object.to_a.first]
     end
   end
 
@@ -33,7 +33,7 @@ describe Relation::Operation::Limit::Methods, '#first' do
     its(:limit) { should == limit }
 
     it 'returns the expected tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
 
     it 'behaves the same as Array#first' do

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

@@ -3,9 +3,9 @@
 require 'spec_helper'
 
 describe Relation::Operation::Limit::Methods, '#last' do
-  let(:described_class) { Relation                                                                               }
-  let(:relation)        { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ])) }
-  let(:object)          { relation.sort_by { |r| r.id }                                                          }
+  let(:described_class) { Relation                                                                   }
+  let(:relation)        { described_class.new([[:id, Integer]], LazyEnumerable.new([[1], [2], [3]])) }
+  let(:object)          { relation.sort_by { |r| r.id }                                              }
 
   context 'with no arguments' do
     subject { object.last }
@@ -13,11 +13,11 @@ describe Relation::Operation::Limit::Methods, '#last' do
     it { should be_instance_of(Relation::Operation::Reverse) }
 
     it 'returns the expected tuples' do
-      should == [ [ 3 ] ]
+      should == [[3]]
     end
 
     it 'behaves similar to Array#last' do
-      should == [ object.to_a.last ]
+      should == [object.to_a.last]
     end
   end
 
@@ -29,7 +29,7 @@ describe Relation::Operation::Limit::Methods, '#last' do
     it { should be_instance_of(Relation::Operation::Reverse) }
 
     it 'returns the expected tuples' do
-      should == [ [ 2 ], [ 3 ] ]
+      should == [[2], [3]]
     end
 
     it 'behaves the same as Array#last' do