veritas 0.0.2 → 0.0.3

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

@@ -1,16 +1,15 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Product#each' do
+describe Algebra::Product, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:klass)  { Algebra::Product                                                             }
   let(:header) { Relation::Header.new([ [ :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(:object) { klass.new(left, right)                                                       }
+  let(:object) { described_class.new(left, right)                                             }
   let(:yields) { []                                                                           }
 
-  it_should_behave_like 'a command method'
+  it_should_behave_like 'an #each method'
 
   it 'yields each tuple' do
     expect { subject }.to change { yields.dup }.

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

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

data/spec/unit/veritas/algebra/projection/directions_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection#directions' do
+describe Algebra::Projection, '#directions' do
   subject { object.directions }
 
-  let(:klass)    { Algebra::Projection                                                          }
   let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
-  let(:object)   { klass.new(operand, [ :id ])                                                  }
+  let(:object)   { described_class.new(operand, [ :id ])                                        }
 
   context 'containing an unordered relation' do
     let(:operand) { relation }

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

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection#each' do
+describe Algebra::Projection, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:klass)    { Algebra::Projection                                         }
   let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb'] ] }
   let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
-  let(:object)   { klass.new(relation, [ :id ])                                }
+  let(:object)   { described_class.new(relation, [ :id ])                      }
   let(:yields)   { []                                                          }
 
-  it_should_behave_like 'a command method'
+  it_should_behave_like 'an #each method'
 
   it 'yields each tuple' do
     expect { subject }.to change { yields.dup }.

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

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection#eql?' do
+describe Algebra::Projection, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:klass)      { Algebra::Projection                                         }
   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)     { klass.new(operand, attributes)                              }
+  let(:object)     { described_class.new(operand, attributes)                    }
 
   context 'with the same object' do
     let(:other) { object }
@@ -30,7 +29,7 @@ describe 'Veritas::Algebra::Projection#eql?' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(klass).new(operand, attributes) }
+    let(:other) { Class.new(described_class).new(operand, attributes) }
 
     it { should be(false) }
 
@@ -40,9 +39,9 @@ describe 'Veritas::Algebra::Projection#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand)    { Relation.new([ [ :id, Integer ] ], [ [ 3 ] ]) }
-    let(:other_attributes) { attributes                                    }
-    let(:other)            { klass.new(other_operand, other_attributes)    }
+    let(:other_operand)    { Relation.new([ [ :id, Integer ] ], [ [ 3 ] ])        }
+    let(:other_attributes) { attributes                                           }
+    let(:other)            { described_class.new(other_operand, other_attributes) }
 
     it { should be(false) }
 
@@ -52,9 +51,9 @@ describe 'Veritas::Algebra::Projection#eql?' do
   end
 
   context 'with an object having different attributes' do
-    let(:other_operand)    { operand                                    }
-    let(:other_attributes) { []                                         }
-    let(:other)            { klass.new(other_operand, other_attributes) }
+    let(:other_operand)    { operand                                              }
+    let(:other_attributes) { []                                                   }
+    let(:other)            { described_class.new(other_operand, other_attributes) }
 
     it { should be(false) }
 

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

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection#hash' do
+describe Algebra::Projection, '#hash' do
   subject { object.hash }
 
-  let(:klass)      { Algebra::Projection                                           }
-  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)     { klass.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'
 
-  it { should == klass.hash ^ operand.hash ^ object.header.hash }
+  it { should == described_class.hash ^ operand.hash ^ object.header.hash }
 end

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

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection#header' do
+describe Algebra::Projection, '#header' do
   subject { object.header }
 
-  let(:klass)    { Algebra::Projection                           }
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:object)   { klass.new(relation, [ :id ])                  }
+  let(:object)   { described_class.new(relation, [ :id ])        }
 
   it_should_behave_like 'an idempotent method'
 

data/spec/unit/veritas/algebra/projection/methods/project_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection::Methods#project' do
+describe Algebra::Projection::Methods, '#project' do
   subject { object.project(attributes) }
 
-  let(:klass)      { Relation                                                                       }
-  let(:attributes) { [ :id ]                                                                        }
-  let(:object)     { klass.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:described_class) { Relation                                                                                 }
+  let(:attributes)      { [ :id ]                                                                                  }
+  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
 
   it { should be_kind_of(Algebra::Projection) }
 

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

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Projection::Methods#remove' do
+describe Algebra::Projection::Methods, '#remove' do
   subject { object.remove(attributes) }
 
-  let(:klass)      { Relation                                                                       }
-  let(:attributes) { [ :id ]                                                                        }
-  let(:object)     { klass.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:described_class) { Relation                                                                                 }
+  let(:attributes)      { [ :id ]                                                                                  }
+  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
 
   it { should be_kind_of(Algebra::Projection) }
 

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

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases.coerce' do
+describe Algebra::Rename::Aliases, '.coerce' do
   subject { object.coerce(attributes, aliases) }
 
   let(:attribute)  { Attribute::Integer.new(:id)         }
   let(:attributes) { Relation::Header.new([ attribute ]) }
-  let(:object)     { Algebra::Rename::Aliases            }
+  let(:object)     { described_class                     }
 
   context 'the aliases are an Alias object' do
     let(:old_attr) { attribute                        }

data/spec/unit/veritas/algebra/rename/aliases/class_methods/new_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Algebra::Rename::Aliases, '.new' do
+  subject { object.new(aliases) }
+
+  let(:id)     { Attribute::Integer.new(:id)  }
+  let(:uid)    { Attribute::Integer.new(:uid) }
+  let(:object) { described_class              }
+
+  context 'when aliases are unique' do
+    let(:aliases)  { { id => id.rename(:other_id), uid => uid.rename(:other_uid) } }
+
+    it { should be_kind_of(object) }
+  end
+
+  context 'when aliases are duplicated' do
+    let(:aliases)  { { id => id.rename(:other), uid => uid.rename(:other) } }
+
+    specify { expect { subject }.to raise_error(DuplicateAliasError, 'the aliases must be unique') }
+  end
+end

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

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#each' do
+describe Algebra::Rename::Aliases, '#each' do
   subject { object.each { |old_attr, new_attr| yields << [ old_attr, new_attr ] } }
 
-  let(:klass)     { Algebra::Rename::Aliases                     }
   let(:attribute) { Attribute::Integer.new(:id)                  }
   let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-  let(:object)    { klass.new(aliases)                           }
+  let(:object)    { described_class.new(aliases)                 }
   let(:yields)    { []                                           }
 
-  it_should_behave_like 'a command method'
+  it_should_behave_like 'an #each method'
 
   it 'yields each alias' do
     expect { subject }.to change { yields.dup }.

data/spec/unit/veritas/algebra/rename/aliases/element_reference_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#[]' do
+describe Algebra::Rename::Aliases, '#[]' do
   subject { object[attribute] }
 
-  let(:klass)     { Algebra::Rename::Aliases    }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:object)    { klass.new(aliases)          }
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:object)    { described_class.new(aliases) }
 
   context 'when attribute is not renamed' do
     let(:aliases) { {} }

data/spec/unit/veritas/algebra/rename/aliases/empty_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#empty?' do
+describe Algebra::Rename::Aliases, '#empty?' do
   subject { object.empty? }
 
-  let(:klass)     { Algebra::Rename::Aliases    }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:object)    { klass.new(aliases)          }
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:object)    { described_class.new(aliases) }
 
   context 'when aliases are empty' do
     let(:aliases) { {} }

data/spec/unit/veritas/algebra/rename/aliases/eql_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#eql?' do
+describe Algebra::Rename::Aliases, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:klass)     { Algebra::Rename::Aliases                     }
   let(:attribute) { Attribute::Integer.new(:id)                  }
   let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-  let(:object)    { klass.new(aliases)                           }
+  let(:object)    { described_class.new(aliases)                 }
 
   context 'with the same object' do
     let(:other) { object }
@@ -29,7 +28,7 @@ describe 'Veritas::Algebra::Rename::Aliases#eql?' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(klass).new(aliases) }
+    let(:other) { Class.new(described_class).new(aliases) }
 
     it { should be(false) }
 
@@ -40,7 +39,7 @@ describe 'Veritas::Algebra::Rename::Aliases#eql?' do
 
   context 'with an object having different aliases' do
     let(:other_aliases) { { attribute => attribute.rename(:another_id) } }
-    let(:other)         { klass.new(other_aliases)                       }
+    let(:other)         { described_class.new(other_aliases)             }
 
     it { should be(false) }
 

data/spec/unit/veritas/algebra/rename/aliases/equal_value_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#==' do
+describe Algebra::Rename::Aliases, '#==' do
   subject { object == other }
 
-  let(:klass)     { Algebra::Rename::Aliases                     }
   let(:attribute) { Attribute::Integer.new(:id)                  }
   let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-  let(:object)    { klass.new(aliases)                           }
+  let(:object)    { described_class.new(aliases)                 }
 
   context 'with the same object' do
     let(:other) { object }
@@ -29,7 +28,7 @@ describe 'Veritas::Algebra::Rename::Aliases#==' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(klass).new(aliases) }
+    let(:other) { Class.new(described_class).new(aliases) }
 
     it { should be(true) }
 
@@ -40,7 +39,7 @@ describe 'Veritas::Algebra::Rename::Aliases#==' do
 
   context 'with an object having different aliases' do
     let(:other_aliases) { { attribute => attribute.rename(:another_id) } }
-    let(:other)         { klass.new(other_aliases)                       }
+    let(:other)         { described_class.new(other_aliases)             }
 
     it { should be(false) }
 

data/spec/unit/veritas/algebra/rename/aliases/hash_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#hash' do
+describe Algebra::Rename::Aliases, '#hash' do
   subject { object.hash }
 
-  let(:klass)     { Algebra::Rename::Aliases                     }
   let(:attribute) { Attribute::Integer.new(:id)                  }
   let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-  let(:object)    { klass.new(aliases)                           }
+  let(:object)    { described_class.new(aliases)                 }
 
   it_should_behave_like 'a hash method'
 
-  it { should == klass.hash ^ aliases.hash }
+  it { should == described_class.hash ^ aliases.hash }
 end

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

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Algebra::Rename::Aliases#to_hash' do
+describe Algebra::Rename::Aliases, '#to_hash' do
   subject { object.to_hash }
 
-  let(:klass)     { Algebra::Rename::Aliases    }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:object)    { klass.new(aliases)          }
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:object)    { described_class.new(aliases) }
 
   context 'when aliases is frozen' do
     let(:aliases) { { attribute => attribute.rename(:other_id) }.freeze }

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

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
 [ :union, :| ].each do |method|
-  describe "Veritas::Algebra::Rename::Aliases##{method}" do
+  describe Algebra::Rename::Aliases, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:klass)     { Algebra::Rename::Aliases                     }
     let(:attribute) { Attribute::Integer.new(:id)                  }
     let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-    let(:object)    { klass.new(aliases)                           }
+    let(:object)    { described_class.new(aliases)                 }
 
     context 'when other is empty' do
       let(:other) { {} }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(described_class) }
 
       it 'does nothing' do
         should == object
@@ -20,45 +19,45 @@ require 'spec_helper'
     end
 
     context 'when other contains duplicate attributes' do
-      let(:other) { klass.new(attribute => attribute.rename(:another_id)) }
+      let(:other) { described_class.new(attribute => attribute.rename(:another_id)) }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(described_class) }
 
       it 'ignores duplicate attributes' do
-        should == klass.new(attribute => attribute.rename(:other_id))
+        should == described_class.new(attribute => attribute.rename(:other_id))
       end
     end
 
     context 'when other contains new attributes' do
-      let(:other_attribute) { Attribute::String.new(:name) }
-      let(:other)           { klass.new(other_attribute => other_attribute.rename(:other_name)) }
+      let(:other_attribute) { Attribute::String.new(:name)                                                }
+      let(:other)           { described_class.new(other_attribute => other_attribute.rename(:other_name)) }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(described_class) }
 
       it 'allows new attributes' do
-        should == klass.new(attribute => attribute.rename(:other_id), other_attribute => other_attribute.rename(:other_name))
+        should == described_class.new(attribute => attribute.rename(:other_id), other_attribute => other_attribute.rename(:other_name))
       end
     end
 
     context 'when other has an original attribute that is renamed to a different name' do
-      let(:other_attribute) { Attribute::Integer.new(:original_id) }
-      let(:other)           { klass.new(other_attribute => other_attribute.rename(:id)) }
+      let(:other_attribute) { Attribute::Integer.new(:original_id)                                }
+      let(:other)           { described_class.new(other_attribute => other_attribute.rename(:id)) }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(described_class) }
 
       it 'simplifies the rename' do
-        should == klass.new(other_attribute => attribute.rename(:other_id))
+        should == described_class.new(other_attribute => attribute.rename(:other_id))
       end
     end
 
     context 'when other has an original attribute that is renamed to the same name' do
-      let(:other_attribute) { Attribute::Integer.new(:other_id) }
-      let(:other)           { klass.new(other_attribute => other_attribute.rename(:id)) }
+      let(:other_attribute) { Attribute::Integer.new(:other_id)                                   }
+      let(:other)           { described_class.new(other_attribute => other_attribute.rename(:id)) }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(described_class) }
 
       it 'eliminates the name' do
-        should == klass.new({})
+        should == described_class.new({})
       end
     end
   end