veritas 0.0.1

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+[ :join, :+ ].each do |method|
+  describe "Veritas::Algebra::Join::Methods##{method}" do
+    subject { relation.send(method, other, *args, &block) }
+
+    let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ]) }
+
+    context 'without predicate arguments or a block' do
+      let(:other) { Relation.new([ [ :id, Integer ], [ :age, Integer ] ], [ [ 1, 35 ] ]) }
+      let(:args)  { []                                                                   }
+      let(:block) { nil                                                                  }
+
+      it { should be_kind_of(Algebra::Join) }
+    end
+
+    context 'with predicate arguments' do
+      let(:other)     { Relation.new([ Attribute::Boolean.new(:active) ], [ [ true ] ]) }
+      let(:predicate) { relation[:id].eq(1)                                             }
+      let(:args)      { [ predicate ]                                                   }
+      let(:block)     { nil                                                             }
+
+      it { should be_kind_of(Algebra::Restriction) }
+
+      it 'restricts a product' do
+        should == [ [ 1, 'Dan Kubb', true ] ]
+      end
+    end
+
+    context 'with a block' do
+      let(:other) { Relation.new([ Attribute::Boolean.new(:active) ], [ [ true ] ]) }
+      let(:args)  { []                                                              }
+      let(:block) do
+        lambda do |relation|
+          relation[:id].eq(1).and(relation[:active].eq(true))
+        end
+      end
+
+      it { should be_kind_of(Algebra::Restriction) }
+
+      it 'restricts a product' do
+        should == [ [ 1, 'Dan Kubb', true ] ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Product.new' do
+  subject { Algebra::Product.new(left, right) }
+
+  let(:header) { [ [ :id, Integer ] ]            }
+  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+
+  context 'with relations having headers with common attributes' do
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be disjointed for Veritas::Algebra::Product.new') }
+  end
+
+  context 'with relations having equivalent headers' do
+    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must be disjointed for Veritas::Algebra::Product.new') }
+  end
+
+  context 'with relations having different headers' do
+    let(:right) { Relation.new([ [ :number, Integer ] ], [ [ 2 ] ]) }
+
+    specify { expect { subject }.to_not raise_error }
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Product#each' do
+  subject { product.each { |tuple| yields << tuple } }
+
+  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(:product) { Algebra::Product.new(left, right)                                            }
+  let(:yields)  { []                                                                           }
+
+  it { should equal(product) }
+
+  it 'yields the product' do
+    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/veritas/algebra/product/methods/product_spec.rb

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

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Veritas::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 ])                                                  }
+
+  context 'containing a relation' do
+    let(:operand) { relation }
+
+    it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+
+    it { should be_empty }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'containing an ordered relation' do
+    let(:operand) { relation.order }
+
+    it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+
+    it { should == [ operand[:id].asc ] }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Veritas::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(:yields)   { []                                                          }
+
+  it { should equal(object) }
+
+  it 'yields each tuple only once' do
+    expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ], [ 2 ] ])
+  end
+end

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

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

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Projection::Methods#project' do
+  subject { relation.project([ :id ]) }
+
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  it { should be_kind_of(Algebra::Projection) }
+
+  it 'behaves the same as Enumerable#map with Tuple#[]' do
+    should == relation.map { |tuple| [ tuple[:id] ] }
+  end
+end

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

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

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'Veritas::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            }
+
+  context 'the aliases are an Alias object' do
+    let(:old_attr) { attribute                        }
+    let(:new_attr) { attribute.rename(:other_id)      }
+    let(:aliases)  { object.new(old_attr => new_attr) }
+
+    it { should equal(aliases) }
+  end
+
+  context 'the old and new attributes are Symbols' do
+    let(:old_attr) { :id                      }
+    let(:new_attr) { :other_id                }
+    let(:aliases)  { { old_attr => new_attr } }
+
+    it { should eql(object.new(attribute => attribute.rename(:other_id))) }
+  end
+
+  context 'the old attribute is a Symbol, and the new attribute is an Attribute' do
+    let(:old_attr) { :id                         }
+    let(:new_attr) { attribute.rename(:other_id) }
+    let(:aliases)  { { old_attr => new_attr }    }
+
+    it { should eql(object.new(attribute => attribute.rename(:other_id))) }
+  end
+
+  context 'the old attribute is an Attribute, and the new attribute is a Symbol' do
+    let(:old_attr) { attribute                }
+    let(:new_attr) { :other_id                }
+    let(:aliases)  { { old_attr => new_attr } }
+
+    it { should eql(object.new(attribute => attribute.rename(:other_id))) }
+  end
+
+  context 'the old and new attributes are Attributes' do
+    let(:old_attr) { attribute                   }
+    let(:new_attr) { attribute.rename(:other_id) }
+    let(:aliases)  { { old_attr => new_attr }    }
+
+    it { should eql(object.new(attribute => attribute.rename(:other_id))) }
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Veritas::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(:yields)    { []                                           }
+
+  it { should equal(object) }
+
+  it 'yields each alias' do
+    expect { subject }.to change { yields.dup }.from([]).to(aliases.to_a)
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename::Aliases#[]' do
+  subject { object[attribute] }
+
+  let(:klass)     { Algebra::Rename::Aliases    }
+  let(:attribute) { Attribute::Integer.new(:id) }
+  let(:object)    { klass.new(aliases)          }
+
+  context 'when attribute is not renamed' do
+    let(:aliases) { {} }
+
+    it { should equal(attribute) }
+  end
+
+  context 'when attribute is renamed' do
+    let(:renamed) { attribute.rename(:other_id) }
+    let(:aliases) { { attribute => renamed }    }
+
+    it { should equal(renamed) }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename::Aliases#empty?' do
+  subject { object.empty? }
+
+  let(:klass)     { Algebra::Rename::Aliases    }
+  let(:attribute) { Attribute::Integer.new(:id) }
+  let(:object)    { klass.new(aliases)          }
+
+  context 'when aliases are empty' do
+    let(:aliases) { {} }
+
+    it { should be(true) }
+  end
+
+  context 'when aliases are not empty' do
+    let(:aliases) { { attribute => attribute.rename(:other_id) } }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'Veritas::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)                           }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with a different object' do
+    let(:other) { klass.new(attribute => attribute.rename(:another_id)) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent object of a different class' do
+    let(:other) { Class.new(klass).new(aliases) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'Veritas::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)                           }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with a different object' do
+    let(:other) { klass.new(attribute => attribute.rename(:another_id)) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an equivalent object of a different class' do
+    let(:other) { Class.new(klass).new(aliases) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Veritas::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)                           }
+
+  it { should be_kind_of(Integer) }
+
+  it { should == aliases.hash }
+
+  it_should_behave_like 'an idempotent method'
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Veritas::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)                           }
+
+  context 'when aliases is frozen' do
+    let(:aliases) { { attribute => attribute.rename(:other_id) }.freeze }
+
+    it { should equal(aliases) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when aliases is not frozen' do
+    let(:aliases) { { attribute => attribute.rename(:other_id) } }
+
+    it { should_not equal(aliases) }
+
+    it { should eql(aliases) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+[ :union, :| ].each do |method|
+  describe "Veritas::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)                           }
+
+    context 'when other is empty' do
+      let(:other) { {} }
+
+      it { should be_kind_of(klass) }
+
+      it 'does nothing' do
+        should eql(object)
+      end
+    end
+
+    context 'when other contains duplicate attributes' do
+      let(:other) { klass.new(attribute => attribute.rename(:another_id)) }
+
+      it { should be_kind_of(klass) }
+
+      it 'ignores duplicate attributes' do
+        should eql(klass.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)) }
+
+      it { should be_kind_of(klass) }
+
+      it 'allows new attributes' do
+        should eql(klass.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)) }
+
+      it { should be_kind_of(klass) }
+
+      it 'simplifies the rename' do
+        should eql(klass.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)) }
+
+      it { should be_kind_of(klass) }
+
+      it 'eliminates the name' do
+        should eql(klass.new({}))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename#aliases' do
+  subject { object.aliases }
+
+  let(:klass)    { Algebra::Rename                               }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:aliases)  { { :id => :other_id }                          }
+  let(:object)   { klass.new(relation, aliases)                  }
+
+  it { should eql(klass::Aliases.coerce(relation.header, aliases)) }
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename#directions' do
+  subject { object.directions }
+
+  let(:klass)    { Algebra::Rename                               }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object)   { klass.new(operand, :id => :other_id)          }
+
+  context 'containing a relation' do
+    let(:operand) { relation }
+
+    it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+
+    it { should be_empty }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'containing an ordered relation' do
+    let(:operand) { relation.order([ relation[:id] ]) }
+
+    it { should be_kind_of(Relation::Operation::Order::DirectionSet) }
+
+    it { should == [ Attribute::Integer.new(:other_id).asc ] }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:klass)    { Algebra::Rename                               }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object)   { klass.new(relation, :id => :other_id)         }
+  let(:yields)   { []                                            }
+
+  it { should equal(object) }
+
+  it 'yields each tuple' do
+    expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+  end
+
+  it 'changes the header for each tuple' do
+    subject
+    yields.first.header.should equal(object.header)
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename#eql?' do
+  subject { object.eql?(other) }
+
+  let(:klass)    { Algebra::Rename                               }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:aliases)  { { :id => :other_id }                          }
+  let(:object)   { klass.new(relation, aliases)                  }
+
+  context 'with the same rename' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent rename' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with a different rename' do
+    let(:other) { klass.new(relation, :id => :another_id) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent rename of a different class' do
+    let(:other) { Class.new(klass).new(relation, aliases) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Rename::Methods#rename' do
+  subject { relation.rename(:id => :other_id) }
+
+  let(:attribute) { Attribute::Integer.new(:id)            }
+  let(:other)     { attribute.rename(:other_id)            }
+  let(:relation)  { Relation.new([ attribute ], [ [ 1 ] ]) }
+  let(:aliases)   { { attribute => other }                 }
+
+  it { should be_kind_of(Algebra::Rename) }
+end