axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/algebra/join/class_methods/new_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Algebra::Join, '.new' do
   subject { object.new(left, right) }
 
-  let(:header) { [ [ :id, Integer ] ]                   }
-  let(:left)   { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-  let(:object) { described_class                        }
+  let(:header) { [[:id, Integer]]                 }
+  let(:left)   { Relation.new(header, [[1], [2]]) }
+  let(:object) { described_class                  }
 
   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']]) }
 
     it { should be_instance_of(object) }
   end
@@ -22,7 +22,7 @@ describe Algebra::Join, '.new' do
   end
 
   context 'with relations having different headers' do
-    let(:right) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+    let(:right) { Relation.new([[:name, String]], [['Dan Kubb']]) }
 
     it { should be_instance_of(object) }
   end

data/spec/unit/axiom/algebra/join/delete_spec.rb

@@ -5,22 +5,22 @@ require 'spec_helper'
 describe Algebra::Join, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(left, right)                                             }
-  let(:left)           { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                         }
-  let(:right)          { Relation.new(header,               [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]) }
-  let(:other_relation) { Relation.new(header,               [ [ 1, 'John Doe' ] ])                    }
-  let(:header)         { [ [ :id, Integer ], [ :name, String ] ]                                      }
+  let(:object)         { described_class.new(left, right)                         }
+  let(:left)           { Relation.new([[:id, Integer]], [[1], [2]])               }
+  let(:right)          { Relation.new(header, [[1, 'John Doe'], [2, 'Jane Doe']]) }
+  let(:other_relation) { Relation.new(header, [[1, 'John Doe']])                  }
+  let(:header)         { [[:id, Integer], [:name, String]]                        }
 
   shared_examples_for 'Algebra::Join#delete' do
     it { should be_instance_of(described_class) }
 
-    its(:left)  { should eql(left.delete(other_relation.project([ :id ])))         }
-    its(:right) { should eql(right.delete(other_relation.project([ :id, :name ]))) }
+    its(:left)  { should eql(left.delete(other_relation.project([:id])))         }
+    its(:right) { should eql(right.delete(other_relation.project([:id, :name]))) }
 
     its(:header) { should == header }
 
     it 'deletes the tuples' do
-      should == [ [ 2, 'Jane Doe' ] ]
+      should == [[2, 'Jane Doe']]
     end
   end
 

data/spec/unit/axiom/algebra/join/each_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Algebra::Join, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object) { described_class.new(left, right)                     }
-  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:yields) { []                                                   }
+  let(:object) { described_class.new(left, right)           }
+  let(:left)   { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:yields) { []                                         }
 
   context 'when the attributes are joined' do
-    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+    let(:right) { Relation.new([[:id, Integer], [:name, String]], [[2, 'Dan Kubb']]) }
 
     it_should_behave_like 'an #each method'
 
@@ -25,14 +25,14 @@ describe Algebra::Join, '#each' do
     end
 
     it 'yields only tuples with the expected data' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ [ 2, 'Dan Kubb' ] ])
+      expect { subject }.to change { yields.dup }
+        .from([])
+        .to([[2, 'Dan Kubb']])
     end
   end
 
   context 'when the attributes are disjoint' do
-    let(:right) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+    let(:right) { Relation.new([[:name, String]], [['Dan Kubb']]) }
 
     it_should_behave_like 'an #each method'
 
@@ -47,14 +47,14 @@ describe Algebra::Join, '#each' do
     end
 
     it 'yields only tuples with the expected data' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ])
+      expect { subject }.to change { yields.dup }
+        .from([])
+        .to([[1, 'Dan Kubb'], [2, 'Dan Kubb']])
     end
   end
 
   context 'when the attributes are an intersection' do
-    let(:right) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+    let(:right) { Relation.new([[:id, Integer]], [[1]]) }
 
     it_should_behave_like 'an #each method'
 
@@ -69,9 +69,9 @@ describe Algebra::Join, '#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
 end

data/spec/unit/axiom/algebra/join/insert_spec.rb

@@ -5,22 +5,22 @@ require 'spec_helper'
 describe Algebra::Join, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)         { described_class.new(left, right)                          }
-  let(:left)           { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])             }
-  let(:right)          { Relation.new(header,               [ [ 1, 'John Doe' ] ]) }
-  let(:other_relation) { Relation.new(header,               [ [ 2, 'Jane Doe' ] ]) }
-  let(:header)         { [ [ :id, Integer ], [ :name, String ] ]                   }
+  let(:object)         { described_class.new(left, right)                      }
+  let(:left)           { Relation.new([[:id, Integer]], [[1]])                 }
+  let(:right)          { Relation.new(header,               [[1, 'John Doe']]) }
+  let(:other_relation) { Relation.new(header,               [[2, 'Jane Doe']]) }
+  let(:header)         { [[:id, Integer], [:name, String]]                     }
 
   shared_examples_for 'Algebra::Join#insert' do
     it { should be_instance_of(described_class) }
 
-    its(:left)  { should eql(left.insert(other_relation.project([ :id ])))         }
-    its(:right) { should eql(right.insert(other_relation.project([ :id, :name ]))) }
+    its(:left)  { should eql(left.insert(other_relation.project([:id])))         }
+    its(:right) { should eql(right.insert(other_relation.project([:id, :name]))) }
 
     its(:header) { should == header }
 
     it 'inserts the tuples' do
-      should == [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]
+      should == [[1, 'John Doe'], [2, 'Jane Doe']]
     end
   end
 

data/spec/unit/axiom/algebra/join/join_header_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Join, '#join_header' do
   subject { object.join_header }
 
-  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                         }
-  let(:right)  { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
-  let(:object) { described_class.new(left, right)                                             }
+  let(:left)   { Relation.new([[:id, Integer]], [[1], [2]])                         }
+  let(:right)  { Relation.new([[:id, Integer], [:name, String]], [[2, '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 ] ] }
+  it { should == [[:id, Integer]] }
 end

data/spec/unit/axiom/algebra/join/methods/join_spec.rb

@@ -2,15 +2,15 @@
 
 require 'spec_helper'
 
-[ :join, :+ ].each do |method|
+[:join, :+].each do |method|
   describe Algebra::Join::Methods, "##{method}" do
-    let(:described_class) { Relation                                                                                                                    }
-    let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ])) }
+    let(:described_class) { Relation                                                                                                       }
+    let(:object)          { described_class.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb'], [2, 'Dan Kubb']])) }
 
     context 'without a block' do
       subject { object.send(method, other) }
 
-      let(:other) { described_class.new([ [ :id, Integer ], [ :age, Integer ] ], LazyEnumerable.new([ [ 1, 35 ] ])) }
+      let(:other) { described_class.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]])) }
 
       it { should be_instance_of(Algebra::Join) }
     end
@@ -18,7 +18,7 @@ require 'spec_helper'
     context 'with a block' do
       subject { object.send(method, other, &block) }
 
-      let(:other) { described_class.new([ Attribute::Boolean.new(:active) ], [ [ true ] ]) }
+      let(:other) { described_class.new([[:active, TrueClass]], [[true]]) }
       let(:block) do
         lambda do |relation|
           relation[:id].eq(1).and(relation[:active].eq(true))
@@ -28,7 +28,7 @@ require 'spec_helper'
       it { should be_instance_of(Algebra::Restriction) }
 
       it 'restricts a product' do
-        should == [ [ 1, 'Dan Kubb', true ] ]
+        should == [[1, 'Dan Kubb', true]]
       end
     end
   end

data/spec/unit/axiom/algebra/product/class_methods/new_spec.rb

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Algebra::Product, '.new' do
   subject { object.new(left, right) }
 
-  let(:header) { [ [ :id, Integer ] ]            }
-  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
-  let(:object) { described_class                 }
+  let(:header) { [[:id, Integer]]            }
+  let(:left)   { Relation.new(header, [[1]]) }
+  let(:object) { described_class             }
 
   context 'with relations having different headers' do
-    let(:right) { Relation.new([ [ :number, Integer ] ], [ [ 2 ] ]) }
+    let(:right) { Relation.new([[:number, Integer]], [[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 disjointed') }
   end
 
   context 'with relations having equivalent headers' do
-    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+    let(:right) { Relation.new(header, [[2]]) }
 
     specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be disjointed') }
   end

data/spec/unit/axiom/algebra/product/delete_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Product, '#delete' do
   subject { object.delete(other) }
 
-  let(:object) { described_class.new(left, right)                        }
-  let(:other)  { stub('other')                                           }
-  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])           }
-  let(:right)  { Relation.new([ [ :name, String ] ], [ [ 'John Doe' ] ]) }
+  let(:object) { described_class.new(left, right)                }
+  let(:other)  { double('other')                                 }
+  let(:left)   { Relation.new([[:id, Integer]], [[1]])           }
+  let(:right)  { Relation.new([[:name, String]], [['John Doe']]) }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'deleting from a product is impossible') }
 end

data/spec/unit/axiom/algebra/product/each_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Product, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object) { described_class.new(left, right)                                             }
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ])             }
-  let(:left)   { Relation.new(header.project([ :id ]), [ [ 1 ], [ 2 ] ])                      }
-  let(:right)  { Relation.new(header.project([ :name ]), [ [ 'Dan Kubb' ], [ 'Alex Kubb' ] ]) }
-  let(:yields) { []                                                                           }
+  let(:object) { described_class.new(left, right)                                     }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String]])           }
+  let(:left)   { Relation.new(header.project([:id]), [[1], [2]])                      }
+  let(:right)  { Relation.new(header.project([:name]), [['Dan Kubb'], ['Alex Kubb']]) }
+  let(:yields) { []                                                                   }
 
   it_should_behave_like 'an #each method'
 
@@ -24,8 +24,8 @@ describe Algebra::Product, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 1, 'Dan Kubb' ], [ 1, 'Alex Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[1, 'Dan Kubb'], [1, 'Alex Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']])
   end
 end

data/spec/unit/axiom/algebra/product/insert_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Product, '#insert' do
   subject { object.insert(other) }
 
-  let(:object) { described_class.new(left, right)                        }
-  let(:other)  { stub('other')                                           }
-  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])           }
-  let(:right)  { Relation.new([ [ :name, String ] ], [ [ 'John Doe' ] ]) }
+  let(:object) { described_class.new(left, right)                }
+  let(:other)  { double('other')                                 }
+  let(:left)   { Relation.new([[:id, Integer]], [[1]])           }
+  let(:right)  { Relation.new([[:name, String]], [['John Doe']]) }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'inserting into a product is impossible') }
 end

data/spec/unit/axiom/algebra/product/methods/product_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-[ :product, :* ].each do |method|
+[:product, :*].each do |method|
   describe Algebra::Product::Methods, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:described_class) { Relation                                                                            }
-    let(:object)          { described_class.new([ [ :id,   Integer ] ], LazyEnumerable.new([ [ 1          ] ])) }
-    let(:other)           { described_class.new([ [ :name, String  ] ], LazyEnumerable.new([ [ 'Dan Kubb' ] ])) }
+    let(:described_class) { Relation                                                                    }
+    let(:object)          { described_class.new([[:id,   Integer]], LazyEnumerable.new([[1]]))          }
+    let(:other)           { described_class.new([[:name, String]],  LazyEnumerable.new([['Dan Kubb']])) }
 
     it { should be_instance_of(Algebra::Product) }
   end

data/spec/unit/axiom/algebra/projection/delete_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Projection, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(operand, [ :id ])                      }
-  let(:operand)        { Relation.new(header, LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:other_relation) { Relation.new(header, LazyEnumerable.new([ [ 2 ] ]))        }
-  let(:header)         { [ [ :id, Integer ] ]                                       }
+  let(:object)         { described_class.new(operand, [:id])                  }
+  let(:operand)        { Relation.new(header, LazyEnumerable.new([[1], [2]])) }
+  let(:other_relation) { Relation.new(header, LazyEnumerable.new([[2]]))      }
+  let(:header)         { [[:id, Integer]]                                     }
 
   shared_examples_for 'Algebra::Projection#delete' do
     it { should be_instance_of(described_class) }
@@ -18,7 +18,7 @@ describe Algebra::Projection, '#delete' do
     its(:header) { should == header }
 
     it 'deletes the tuples' do
-      should == [ [ 1 ] ]
+      should == [[1]]
     end
   end
 
@@ -41,17 +41,17 @@ describe Algebra::Projection, '#delete' do
   end
 
   context 'when optional attributes are removed' do
-    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([ [ 1, 'John Doe' ] ])) }
-    let(:other)       { Relation.new(header,      LazyEnumerable.new([ [ 2             ] ])) }
-    let(:base_header) { [ [ :id, Integer ], [ :name, String, { :required => false } ] ]      }
+    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([[1, 'John Doe']])) }
+    let(:other)       { Relation.new(header,      LazyEnumerable.new([[2]]))             }
+    let(:base_header) { [[:id, Integer], [:name, String, { required: false }]]           }
 
     it_should_behave_like 'Algebra::Projection#delete'
   end
 
   context 'when the other header does not match the projection' do
-    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([ [ 1, 'John Doe' ] ])) }
-    let(:other)       { Relation.new(base_header, LazyEnumerable.new([ [ 2, 'Jane Doe' ] ])) }
-    let(:base_header) { [ [ :id, Integer ], [ :name, String, { :required => false } ] ]      }
+    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([[1, 'John Doe']])) }
+    let(:other)       { Relation.new(base_header, LazyEnumerable.new([[2, 'Jane Doe']])) }
+    let(:base_header) { [[:id, Integer], [:name, String, { required: false }]]           }
 
     specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be equivalent') }
   end

data/spec/unit/axiom/algebra/projection/each_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Projection, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(relation, [ :id ])                      }
-  let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
-  let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb'] ] }
-  let(:yields)   { []                                                          }
+  let(:object)   { described_class.new(relation, [:id])                  }
+  let(:relation) { Relation.new([[:id, Integer], [:name, String]], body) }
+  let(:body)     { [[1, 'Dan Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']]  }
+  let(:yields)   { []                                                    }
 
   it_should_behave_like 'an #each method'
 
@@ -23,8 +23,8 @@ describe Algebra::Projection, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 1 ], [ 2 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[1], [2]])
   end
 end

data/spec/unit/axiom/algebra/projection/eql_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Projection, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:body)       { [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb'] ] }
-  let(:operand)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
-  let(:attributes) { [ :id ]                                                     }
-  let(:object)     { described_class.new(operand, attributes)                    }
+  let(:body)       { [[1, 'Dan Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']]  }
+  let(:operand)    { Relation.new([[:id, Integer], [:name, String]], body) }
+  let(:attributes) { [:id]                                                 }
+  let(:object)     { described_class.new(operand, attributes)              }
 
   context 'with the same object' do
     let(:other) { object }
@@ -41,7 +41,7 @@ describe Algebra::Projection, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand)    { Relation.new([ [ :id, Integer ] ], [ [ 3 ] ])        }
+    let(:other_operand)    { Relation.new([[:id, Integer]], [[3]])                }
     let(:other_attributes) { attributes                                           }
     let(:other)            { described_class.new(other_operand, other_attributes) }
 

data/spec/unit/axiom/algebra/projection/hash_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Projection, '#hash' do
   subject { object.hash }
 
-  let(:body)       { [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb'] ] }
-  let(:operand)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
-  let(:attributes) { [ :id ]                                                     }
-  let(:object)     { described_class.new(operand, attributes)                    }
+  let(:body)       { [[1, 'Dan Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']]  }
+  let(:operand)    { Relation.new([[:id, Integer], [:name, String]], body) }
+  let(:attributes) { [:id]                                                 }
+  let(:object)     { described_class.new(operand, attributes)              }
 
   it_should_behave_like 'a hash method'
 

data/spec/unit/axiom/algebra/projection/header_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Algebra::Projection, '#header' do
   subject { object.header }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:object)   { described_class.new(relation, [ :id ])        }
+  let(:relation) { Relation.new([[:id, Integer]], [[1]]) }
+  let(:object)   { described_class.new(relation, [:id])  }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(Relation::Header) }
 
-  it { should == [ [ :id, Integer ] ] }
+  it { should == [[:id, Integer]] }
 end