axiom 0.1.0 → 0.1.1

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Projection, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)         { described_class.new(operand, [ :id ])               }
-  let(:operand)        { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  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]])) }
+  let(:other_relation) { Relation.new(header, LazyEnumerable.new([[2]])) }
+  let(:header)         { [[:id, Integer]]                                }
 
   shared_examples_for 'Algebra::Projection#insert' do
     it { should be_instance_of(described_class) }
@@ -18,7 +18,7 @@ describe Algebra::Projection, '#insert' do
     its(:header) { should == header }
 
     it 'inserts the tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 
@@ -41,25 +41,25 @@ describe Algebra::Projection, '#insert' 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#insert'
   end
 
   context 'when required attributes are removed' do
-    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([ [ 1, 'John Doe', 25 ] ])) }
-    let(:other)       { Relation.new(header,      LazyEnumerable.new([ [ 2 ]                 ])) }
-    let(:base_header) { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]               }
+    let(:operand)     { Relation.new(base_header, LazyEnumerable.new([[1, 'John Doe', 25]])) }
+    let(:other)       { Relation.new(header,      LazyEnumerable.new([[2]]))                 }
+    let(:base_header) { [[:id, Integer], [:name, String], [:age, Integer]]                   }
 
     specify { expect { subject }.to raise_error(RequiredAttributesError, 'required attributes [:name, :age] have been removed') }
   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/methods/project_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Algebra::Projection::Methods, '#project' do
   subject { object.project(attributes) }
 
-  let(:described_class) { Relation                                                                                                }
-  let(:attributes)      { [ :id ]                                                                                                 }
-  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+  let(:described_class) { Relation                                                                                      }
+  let(:attributes)      { [:id]                                                                                         }
+  let(:object)          { described_class.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
 
   it { should be_instance_of(Algebra::Projection) }
 
-  its(:header) { should == [ [ :id, Integer ] ] }
+  its(:header) { should == [[:id, Integer]] }
 
   it 'behaves the same as Enumerable#map with Tuple#[]' do
-    should == object.map { |tuple| [ tuple[:id] ] }
+    should == object.map { |tuple| [tuple[:id]] }
   end
 end

data/spec/unit/axiom/algebra/projection/methods/remove_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Algebra::Projection::Methods, '#remove' do
   subject { object.remove(attributes) }
 
-  let(:described_class) { Relation                                                                                                }
-  let(:attributes)      { [ :id ]                                                                                                 }
-  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+  let(:described_class) { Relation                                                                                      }
+  let(:attributes)      { [:id]                                                                                         }
+  let(:object)          { described_class.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
 
   it { should be_instance_of(Algebra::Projection) }
 
-  its(:header) { should == [ [ :name, String ] ] }
+  its(:header) { should == [[:name, String]] }
 
   it 'behaves the same as Enumerable#map with Tuple#[]' do
-    should == object.map { |tuple| [ tuple[:name] ] }
+    should == object.map { |tuple| [tuple[:name]] }
   end
 end

data/spec/unit/axiom/algebra/rename/aliases/class_methods/coerce_spec.rb

@@ -6,7 +6,7 @@ describe Algebra::Rename::Aliases, '.coerce' do
   subject { object.coerce(attributes, aliases) }
 
   let(:attribute)  { Attribute::Integer.new(:id) }
-  let(:attributes) { [ attribute ]               }
+  let(:attributes) { [attribute]                 }
   let(:object)     { described_class             }
 
   context 'the aliases are an Alias object' do
@@ -14,7 +14,7 @@ describe Algebra::Rename::Aliases, '.coerce' do
     let(:new_attr) { attribute.rename(:other_id)      }
     let(:aliases)  { object.new(old_attr => new_attr) }
 
-    it { should equal(aliases) }
+    it { should be(aliases) }
   end
 
   context 'the old and new attributes are Symbols' do

data/spec/unit/axiom/algebra/rename/aliases/each_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Algebra::Rename::Aliases, '#each' do
-  subject { object.each { |old_attr, new_attr| yields << [ old_attr, new_attr ] } }
+  subject { object.each { |old_attr, new_attr| yields << [old_attr, new_attr] } }
 
   let(:object)    { described_class.new(aliases)                 }
   let(:aliases)   { { attribute => attribute.rename(:other_id) } }
@@ -13,8 +13,8 @@ describe Algebra::Rename::Aliases, '#each' do
   it_should_behave_like 'an #each method'
 
   it 'yields each alias' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to(aliases.to_a)
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to(aliases.to_a)
   end
 end

data/spec/unit/axiom/algebra/rename/aliases/element_reader_spec.rb

@@ -11,13 +11,13 @@ describe Algebra::Rename::Aliases, '#[]' do
   context 'when attribute is not renamed' do
     let(:aliases) { {} }
 
-    it { should equal(attribute) }
+    it { should be(attribute) }
   end
 
   context 'when attribute is renamed' do
     let(:renamed) { attribute.rename(:other_id) }
     let(:aliases) { { attribute => renamed }    }
 
-    it { should equal(renamed) }
+    it { should be(renamed) }
   end
 end

data/spec/unit/axiom/algebra/rename/aliases/to_hash_spec.rb

@@ -13,7 +13,7 @@ describe Algebra::Rename::Aliases, '#to_hash' do
 
     it_should_behave_like 'an idempotent method'
 
-    it { should equal(aliases) }
+    it { should be(aliases) }
   end
 
   context 'when aliases is not frozen' do
@@ -21,7 +21,7 @@ describe Algebra::Rename::Aliases, '#to_hash' do
 
     it_should_behave_like 'an idempotent method'
 
-    it { should_not equal(aliases) }
+    it { should_not be(aliases) }
 
     it { should be_instance_of(Hash) }
 

data/spec/unit/axiom/algebra/rename/aliases/union_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :union, :| ].each do |method|
+[:union, :|].each do |method|
   describe Algebra::Rename::Aliases, "##{method}" do
     subject { object.send(method, other) }
 

data/spec/unit/axiom/algebra/rename/aliases_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Rename, '#aliases' do
   subject { object.aliases }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])                                  }
+  let(:relation) { Relation.new([[:id, Integer]], [[1]])                                          }
   let(:aliases)  { described_class::Aliases.new(relation[:id] => relation[:id].rename(:other_id)) }
   let(:object)   { described_class.new(relation, aliases)                                         }
 
-  it { should equal(aliases) }
+  it { should be(aliases) }
 end

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Rename, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(operand, aliases)                                    }
-  let(:operand)        { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:other_relation) { Relation.new(header,               LazyEnumerable.new([ [ 2 ]        ])) }
-  let(:aliases)        { described_class::Aliases.coerce(operand.header, :id => :other_id)        }
-  let(:header)         { [ [ :other_id, Integer ] ]                                               }
+  let(:object)         { described_class.new(operand, aliases)                          }
+  let(:operand)        { Relation.new([[:id, Integer]], LazyEnumerable.new([[1], [2]])) }
+  let(:other_relation) { Relation.new(header,               LazyEnumerable.new([[2]]))  }
+  let(:aliases)        { described_class::Aliases.coerce(operand.header, id: :other_id) }
+  let(:header)         { [[:other_id, Integer]]                                         }
 
   shared_examples_for 'Algebra::Rename#delete' do
     it { should be_instance_of(described_class) }
@@ -21,7 +21,7 @@ describe Algebra::Rename, '#delete' do
     its(:aliases) { should eql(aliases) }
 
     it 'deletes the tuples' do
-      should == [ [ 1 ] ]
+      should == [[1]]
     end
   end
 

data/spec/unit/axiom/algebra/rename/directions_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Algebra::Rename, '#directions' do
   subject { object.directions }
 
-  let(:relation) { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:object)   { described_class.new(operand, :id => :other_id)         }
+  let(:relation) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:object)   { described_class.new(operand, id: :other_id)        }
 
   context 'containing a relation' do
     let(:operand) { relation }
@@ -19,12 +19,12 @@ describe Algebra::Rename, '#directions' do
   end
 
   context 'containing an ordered relation' do
-    let(:operand) { relation.sort_by { [ relation[:id] ] } }
+    let(:operand) { relation.sort_by { [relation[:id]] } }
 
     it_should_behave_like 'an idempotent method'
 
     it { should be_instance_of(Relation::Operation::Order::DirectionSet) }
 
-    it { should == [ Attribute::Integer.new(:other_id).asc ] }
+    it { should == [Attribute::Integer.new(:other_id).asc] }
   end
 end

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Rename, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(relation, :id => :other_id) }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])   }
-  let(:yields)   { []                                              }
+  let(:object)   { described_class.new(relation, id: :other_id) }
+  let(:relation) { Relation.new([[:id, Integer]], [[1]])        }
+  let(:yields)   { []                                           }
 
   it_should_behave_like 'an #each method'
 
@@ -22,8 +22,8 @@ describe Algebra::Rename, '#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/algebra/rename/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Rename, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:aliases) { { :id => :other_id }                          }
-  let(:object)  { described_class.new(operand, aliases)         }
+  let(:operand) { Relation.new([[:id, Integer]], [[1]]) }
+  let(:aliases) { { id: :other_id }                     }
+  let(:object)  { described_class.new(operand, aliases) }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,7 +40,7 @@ describe Algebra::Rename, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ])     }
+    let(:other_operand) { Relation.new([[:id, Integer]], [[2]])             }
     let(:other_aliases) { aliases                                           }
     let(:other)         { described_class.new(other_operand, other_aliases) }
 
@@ -53,7 +53,7 @@ describe Algebra::Rename, '#eql?' do
 
   context 'with an object having different aliases' do
     let(:other_operand) { operand                                           }
-    let(:other_aliases) { { :id => :another_id }                            }
+    let(:other_aliases) { { id: :another_id }                               }
     let(:other)         { described_class.new(other_operand, other_aliases) }
 
     it { should be(false) }

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

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

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

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

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Rename, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)         { described_class.new(operand, aliases)                             }
-  let(:operand)        { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:other_relation) { Relation.new(header,               LazyEnumerable.new([ [ 2 ] ])) }
-  let(:aliases)        { described_class::Aliases.coerce(operand.header, :id => :other_id) }
-  let(:header)         { [ [ :other_id, Integer ] ]                                        }
+  let(:object)         { described_class.new(operand, aliases)                          }
+  let(:operand)        { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]]))      }
+  let(:other_relation) { Relation.new(header,               LazyEnumerable.new([[2]]))  }
+  let(:aliases)        { described_class::Aliases.coerce(operand.header, id: :other_id) }
+  let(:header)         { [[:other_id, Integer]]                                         }
 
   shared_examples_for 'Algebra::Rename#insert' do
     it { should be_instance_of(described_class) }
@@ -21,7 +21,7 @@ describe Algebra::Rename, '#insert' do
     its(:aliases) { should eql(aliases) }
 
     it 'inserts the tuples' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 

data/spec/unit/axiom/algebra/rename/methods/rename_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Algebra::Rename::Methods, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:described_class) { Relation                                                          }
-  let(:attribute)       { Attribute::Integer.new(:id)                                       }
-  let(:aliases)         { { :id => :other_id }                                              }
-  let(:object)          { described_class.new([ attribute ], LazyEnumerable.new([ [ 1 ] ])) }
+  let(:described_class) { Relation                                                    }
+  let(:attribute)       { Attribute::Integer.new(:id)                                 }
+  let(:aliases)         { { id: :other_id }                                           }
+  let(:object)          { described_class.new([attribute], LazyEnumerable.new([[1]])) }
 
   it { should be_instance_of(Algebra::Rename) }
 end

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Restriction, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(operand, predicate)                           }
-  let(:operand)        { Relation.new([ attribute ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-  let(:other_relation) { Relation.new([ attribute ], LazyEnumerable.new([ [ 0 ], [ 2 ] ])) }
-  let(:attribute)      { Attribute::Integer.new(:id)                                       }
-  let(:predicate)      { attribute.gte(1)                                                  }
+  let(:object)         { described_class.new(operand, predicate)                   }
+  let(:operand)        { Relation.new([attribute], LazyEnumerable.new([[1], [2]])) }
+  let(:other_relation) { Relation.new([attribute], LazyEnumerable.new([[0], [2]])) }
+  let(:attribute)      { Attribute::Integer.new(:id)                               }
+  let(:predicate)      { attribute.gte(1)                                          }
 
   shared_examples_for 'Algebra::Restrict#delete' do
     it { should be_instance_of(described_class) }
@@ -18,15 +18,15 @@ describe Algebra::Restriction, '#delete' do
 
     it 'passes expected relations into the deletion' do
       subject = self.subject.operand
-      subject.left.should equal(operand)
+      subject.left.should be(operand)
       subject.right.should be_kind_of(described_class)
-      subject.right.predicate.should equal(predicate)
+      subject.right.predicate.should be(predicate)
     end
 
-    its(:predicate) { should equal(predicate) }
+    its(:predicate) { should be(predicate) }
 
     it 'filters out tuples from the other relation not matching the predicate' do
-      should == [ [ 1 ] ]
+      should == [[1]]
     end
   end
 

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Restriction, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:object)   { described_class.new(relation, predicate)      }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:yields)   { []                                            }
+  let(:object)   { described_class.new(relation, predicate) }
+  let(:relation) { Relation.new([[:id, Integer]], [[1]])    }
+  let(:yields)   { []                                       }
 
   context 'when predicate is a Proc' do
     let(:predicate) { proc { true } }
@@ -25,9 +25,9 @@ describe Algebra::Restriction, '#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
 
@@ -47,9 +47,9 @@ describe Algebra::Restriction, '#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
 
@@ -69,9 +69,9 @@ describe Algebra::Restriction, '#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