axiom 0.1.0 → 0.1.1

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

@@ -6,8 +6,8 @@ describe Algebra::Difference, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:object) { described_class.new(left, right) }
-  let(:header) { [ [ :id, Integer ] ]             }
-  let(:left)   { Relation.new(header, [ [ 1 ] ])  }
+  let(:header) { [[:id, Integer]]                 }
+  let(:left)   { Relation.new(header, [[1]])      }
   let(:yields) { []                               }
 
   context 'with relations having similar bodies' do
@@ -22,7 +22,7 @@ describe Algebra::Difference, '#each' do
   end
 
   context 'with relations having different bodies' do
-    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+    let(:right) { Relation.new(header, [[2]]) }
 
     it_should_behave_like 'an #each method'
 
@@ -37,9 +37,9 @@ describe Algebra::Difference, '#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/difference/insert_spec.rb

@@ -6,10 +6,10 @@ describe Algebra::Difference, '#insert' do
   subject { object.insert(other) }
 
   let(:object)         { described_class.new(left, right) }
-  let(:left)           { Relation.new(header, [ [ 1 ] ])  }
-  let(:right)          { Relation.new(header, [ [ 1 ] ])  }
-  let(:other_relation) { Relation.new(header, [ [ 2 ] ])  }
-  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left)           { Relation.new(header, [[1]])      }
+  let(:right)          { Relation.new(header, [[1]])      }
+  let(:other_relation) { Relation.new(header, [[2]])      }
+  let(:header)         { [[:id, Integer]]                 }
 
   shared_examples_for 'Algebra::Difference#insert' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Difference, '#insert' do
     its(:header) { should == header }
 
     it 'inserts the tuples' do
-      should == [ [ 2 ] ]
+      should == [[2]]
     end
   end
 

data/spec/unit/axiom/algebra/difference/methods/difference_spec.rb

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-[ :difference, :- ].each do |method|
+[:difference, :-].each do |method|
   describe Algebra::Difference::Methods, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:described_class) { Relation                                                   }
-    let(:header)          { [ [ :id, Integer ] ]                                       }
-    let(:other)           { described_class.new(header, LazyEnumerable.new([ [ 2 ] ])) }
-    let(:object)          { described_class.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+    let(:described_class) { Relation                                               }
+    let(:header)          { [[:id, Integer]]                                       }
+    let(:other)           { described_class.new(header, LazyEnumerable.new([[2]])) }
+    let(:object)          { described_class.new(header, LazyEnumerable.new([[1]])) }
 
     it { should be_instance_of(Algebra::Difference) }
 

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

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe Algebra::Extension, '.new' do
   subject { object.new(operand, extensions) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ]) }
-  let(:object)  { described_class                                                                                 }
+  let(:operand) { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb'], [2, 'Dan Kubb']]) }
+  let(:object)  { described_class                                                                     }
 
   context 'with a unique attribute name provided' do
-    let(:extensions) { { :unique => lambda { |tuple| 1 } } }
+    let(:extensions) { { unique: ->(tuple) { 1 } } }
 
     it { should be_instance_of(object) }
   end
 
   context 'with a duplicate attribute name provided' do
-    let(:extensions) { { :id => proc {}, :name => proc {} } }
+    let(:extensions) { { id: proc {}, name: proc {} } }
 
     specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: [:id, :name]') }
   end

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

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Algebra::Extension, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(operand, extensions)                   }
-  let(:operand)        { Relation.new(header, LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:extensions)     { { extension_attr => 1 }                                    }
-  let(:extension_attr) { Attribute::Integer.new(:test)                              }
-  let(:header)         { [ [ :id, Integer ] ]                                       }
+  let(:object)         { described_class.new(operand, extensions)             }
+  let(:operand)        { Relation.new(header, LazyEnumerable.new([[1], [2]])) }
+  let(:extensions)     { { extension_attr => 1 }                              }
+  let(:extension_attr) { Attribute::Integer.new(:test)                        }
+  let(:header)         { [[:id, Integer]]                                     }
 
   context 'when other relation has matching extensions' do
     let(:other) do
-      Relation.new(header, LazyEnumerable.new([ [ 2 ] ])).extend do |context|
+      Relation.new(header, LazyEnumerable.new([[2]])).extend do |context|
         context.add(:test, 1)
       end
     end
@@ -22,16 +22,16 @@ describe Algebra::Extension, '#delete' do
 
     its(:operand) { should be_kind_of(Relation) }
 
-    its(:header) { should == [ [ :id, Integer ], [ :test, Integer ] ] }
+    its(:header) { should == [[:id, Integer], [:test, Integer]] }
 
     it 'deletes the tuples' do
-      should == [ [ 1, 1 ] ]
+      should == [[1, 1]]
     end
   end
 
   context 'when other relation does not have the same extensions' do
-     let(:other) do
-      Relation.new(header, LazyEnumerable.new([ [ 2 ] ])).extend do |context|
+    let(:other) do
+      Relation.new(header, LazyEnumerable.new([[2]])).extend do |context|
         context.add(:test, 2)
       end
     end
@@ -40,7 +40,7 @@ describe Algebra::Extension, '#delete' do
   end
 
   context 'when other relation is not an extension' do
-    let(:other) { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
+    let(:other) { Relation.new(header, LazyEnumerable.new([[2]])) }
 
     specify { expect { subject }.to raise_error(ExtensionMismatchError, 'other relation must have matching extensions to be deleted') }
   end

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Extension, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)     { described_class.new(operand, extensions)             }
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
-  let(:yields)     { []                                                   }
+  let(:object)     { described_class.new(operand, extensions)   }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { test: ->(tuple) { 1 } }                  }
+  let(:yields)     { []                                         }
 
   it_should_behave_like 'an #each method'
 
@@ -23,8 +23,8 @@ describe Algebra::Extension, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 1, 1 ], [ 2, 1 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[1, 1], [2, 1]])
   end
 end

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Extension, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
-  let(:object)     { described_class.new(operand, extensions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { test: ->(tuple) { 1 } }                  }
+  let(:object)     { described_class.new(operand, extensions)   }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,7 +40,7 @@ describe Algebra::Extension, '#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_extensions) { extensions                                           }
     let(:other)            { described_class.new(other_operand, other_extensions) }
 
@@ -53,7 +53,7 @@ describe Algebra::Extension, '#eql?' do
 
   context 'with an object having different extensions' do
     let(:other_operand)    { operand                                              }
-    let(:other_extensions) { { :text => lambda { |tuple| 2 } }                    }
+    let(:other_extensions) { { text: ->(tuple) { 2 } }                            }
     let(:other)            { described_class.new(other_operand, other_extensions) }
 
     it { should be(false) }

data/spec/unit/axiom/algebra/extension/extensions_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Extension, '#extensions' do
   subject { object.extensions }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { :test => 1 }                                       }
-  let(:object)     { described_class.new(operand, extensions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { test: 1 }                                }
+  let(:object)     { described_class.new(operand, extensions)   }
 
   it_should_behave_like 'an idempotent method'
 

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Extension, '#hash' do
   subject { object.hash }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { Attribute::Integer.new(:test) => 1 }               }
-  let(:object)     { described_class.new(operand, extensions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { Attribute::Integer.new(:test) => 1 }     }
+  let(:object)     { described_class.new(operand, extensions)   }
 
   it_should_behave_like 'a hash method'
 

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Extension, '#header' do
   subject { object.header }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
-  let(:object)     { described_class.new(operand, extensions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { test: ->(tuple) { 1 } }                  }
+  let(:object)     { described_class.new(operand, extensions)   }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(Relation::Header) }
 
-  it { should == [ [ :id, Integer ], [ :test, Object ] ] }
+  it { should == [[:id, Integer], [:test, Object]] }
 end

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

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Algebra::Extension, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)         { described_class.new(operand, extensions)            }
-  let(:operand)        { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:extensions)     { { extension_attr => 1 }                             }
-  let(:extension_attr) { Attribute::Integer.new(:test)                       }
-  let(:header)         { [ [ :id, Integer ] ]                                }
+  let(:object)         { described_class.new(operand, extensions)        }
+  let(:operand)        { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:extensions)     { { extension_attr => 1 }                         }
+  let(:extension_attr) { Attribute::Integer.new(:test)                   }
+  let(:header)         { [[:id, Integer]]                                }
 
   context 'when other relation has matching extensions' do
     let(:other) do
-      Relation.new(header, LazyEnumerable.new([ [ 2 ] ])).extend do |context|
+      Relation.new(header, LazyEnumerable.new([[2]])).extend do |context|
         context.add(:test, 1)
       end
     end
@@ -22,16 +22,16 @@ describe Algebra::Extension, '#insert' do
 
     its(:operand) { should be_kind_of(Relation) }
 
-    its(:header) { should == [ [ :id, Integer ], [ :test, Integer ] ] }
+    its(:header) { should == [[:id, Integer], [:test, Integer]] }
 
     it 'inserts the tuples' do
-      should == [ [ 1, 1 ], [ 2, 1 ] ]
+      should == [[1, 1], [2, 1]]
     end
   end
 
   context 'when other relation does not have the same extensions' do
-     let(:other) do
-      Relation.new(header, LazyEnumerable.new([ [ 2 ] ])).extend do |context|
+    let(:other) do
+      Relation.new(header, LazyEnumerable.new([[2]])).extend do |context|
         context.add(:test, 2)
       end
     end
@@ -40,7 +40,7 @@ describe Algebra::Extension, '#insert' do
   end
 
   context 'when other relation is not an extension' do
-    let(:other) { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
+    let(:other) { Relation.new(header, LazyEnumerable.new([[2]])) }
 
     specify { expect { subject }.to raise_error(ExtensionMismatchError, 'other relation must have matching extensions to be inserted') }
   end

data/spec/unit/axiom/algebra/extension/methods/extend_spec.rb

@@ -3,17 +3,17 @@
 require 'spec_helper'
 
 describe Algebra::Extension::Methods, '#extend' do
-  let(:object)          { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:described_class) { Relation                                                                 }
-  let(:extensions)      { { :test => function }                                                    }
-  let(:function)        { object[:id]                                                              }
+  let(:object)          { described_class.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:described_class) { Relation                                                         }
+  let(:extensions)      { { test: function }                                               }
+  let(:function)        { object[:id]                                                      }
 
   context 'with extensions' do
     subject { object.extend(extensions) }
 
     it { should be_instance_of(Algebra::Extension) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
     its(:extensions) { should == { Attribute::Object.new(:test) => function } }
   end
@@ -27,7 +27,7 @@ describe Algebra::Extension::Methods, '#extend' do
 
     it { should be_instance_of(Algebra::Extension) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
     its(:extensions) { should == { Attribute::Integer.new(:test) => function } }
   end

data/spec/unit/axiom/algebra/extension/operand_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Extension, '#operand' do
   subject { object.operand }
 
-  let(:operand)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:extensions) { { :test => lambda { |tuple| 1 } }                    }
-  let(:object)     { described_class.new(operand, extensions)             }
+  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
+  let(:extensions) { { test: ->(tuple) { 1 } }                  }
+  let(:object)     { described_class.new(operand, extensions)   }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(operand) }
+  it { should be(operand) }
 end

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Intersection, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(left, right)       }
-  let(:left)           { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-  let(:right)          { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-  let(:other_relation) { Relation.new(header, [ [ 1 ] ])        }
-  let(:header)         { [ [ :id, Integer ] ]                   }
+  let(:object)         { described_class.new(left, right) }
+  let(:left)           { Relation.new(header, [[1], [2]]) }
+  let(:right)          { Relation.new(header, [[1], [2]]) }
+  let(:other_relation) { Relation.new(header, [[1]])      }
+  let(:header)         { [[:id, Integer]]                 }
 
   shared_examples_for 'Algebra::Intersection#delete' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Intersection, '#delete' do
     its(:header) { should == header }
 
     it 'deletes the tuples' do
-      should == [ [ 2 ] ]
+      should == [[2]]
     end
   end
 

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

@@ -6,8 +6,8 @@ describe Algebra::Intersection, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:object) { described_class.new(left, right) }
-  let(:left)   { Relation.new(header, [ [ 1 ] ])  }
-  let(:header) { [ [ :id, Integer ] ]             }
+  let(:left)   { Relation.new(header, [[1]])      }
+  let(:header) { [[:id, Integer]]                 }
   let(:yields) { []                               }
 
   context 'with relations having similar bodies' do
@@ -26,14 +26,14 @@ describe Algebra::Intersection, '#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
 
   context 'with relations having different bodies' do
-    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+    let(:right) { Relation.new(header, [[2]]) }
 
     it_should_behave_like 'an #each method'
 

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

@@ -6,10 +6,10 @@ describe Algebra::Intersection, '#insert' do
   subject { object.insert(other) }
 
   let(:object)         { described_class.new(left, right) }
-  let(:left)           { Relation.new(header, [ [ 1 ] ])  }
-  let(:right)          { Relation.new(header, [ [ 1 ] ])  }
-  let(:other_relation) { Relation.new(header, [ [ 2 ] ])  }
-  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left)           { Relation.new(header, [[1]])      }
+  let(:right)          { Relation.new(header, [[1]])      }
+  let(:other_relation) { Relation.new(header, [[2]])      }
+  let(:header)         { [[:id, Integer]]                 }
 
   shared_examples_for 'Algebra::Intersection#insert' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Intersection, '#insert' do
     its(:header) { should == header }
 
     it 'inserts the tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 

data/spec/unit/axiom/algebra/intersection/methods/intersect_spec.rb

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-[ :intersect, :& ].each do |method|
+[:intersect, :&].each do |method|
   describe Algebra::Intersection::Methods, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:described_class) { Relation                                                   }
-    let(:header)          { [ [ :id, Integer ] ]                                       }
-    let(:object)          { described_class.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-    let(:other)           { described_class.new(header, LazyEnumerable.new([ [ 2 ] ])) }
+    let(:described_class) { Relation                                               }
+    let(:header)          { [[:id, Integer]]                                       }
+    let(:object)          { described_class.new(header, LazyEnumerable.new([[1]])) }
+    let(:other)           { described_class.new(header, LazyEnumerable.new([[2]])) }
 
     it { should be_instance_of(Algebra::Intersection) }