axiom 0.1.0

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction, '#eql?' do
+  subject { object.eql?(other) }
+
+  let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:predicate) { proc { true }                                 }
+  let(:object)    { described_class.new(operand, predicate)       }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(operand, predicate) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having a different operand' do
+    let(:other_operand)   { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ])       }
+    let(:other_predicate) { predicate                                           }
+    let(:other)           { described_class.new(other_operand, other_predicate) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having a different predicate' do
+    let(:other_operand)   { operand                                             }
+    let(:other_predicate) { proc { false }                                      }
+    let(:other)           { described_class.new(other_operand, other_predicate) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction, '#hash' do
+  subject { object.hash }
+
+  let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:predicate) { proc { true }                                 }
+  let(:object)    { described_class.new(operand, predicate)       }
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ operand.hash ^ predicate.hash }
+end

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction, '#insert' do
+  subject { object.insert(other) }
+
+  let(:object)         { described_class.new(operand, predicate)                           }
+  let(:operand)        { Relation.new([ attribute ], LazyEnumerable.new([ [ 1 ] ]))        }
+  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#insert' do
+    it { should be_instance_of(described_class) }
+
+    its(:operand) { should be_kind_of(Relation::Operation::Insertion) }
+
+    it 'passes expected relations into the insertion' do
+      subject = self.subject.operand
+      subject.left.should equal(operand)
+      subject.right.should be_kind_of(described_class)
+      subject.right.predicate.should equal(predicate)
+    end
+
+    its(:predicate) { should equal(predicate) }
+
+    it 'filters out tuples from the other relation not matching the predicate' do
+      should == [ [ 1 ], [ 2 ] ]
+    end
+  end
+
+  context 'with a relation' do
+    let(:other) { other_relation }
+
+    it_should_behave_like 'Algebra::Restrict#insert'
+  end
+
+  context 'with an array of tuples' do
+    let(:other) { other_relation.to_a }
+
+    it_should_behave_like 'Algebra::Restrict#insert'
+  end
+
+  context 'with an array of arrays' do
+    let(:other) { other_relation.map(&:to_ary) }
+
+    it_should_behave_like 'Algebra::Restrict#insert'
+  end
+end

data/spec/unit/axiom/algebra/restriction/methods/restrict_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction::Methods, '#restrict' do
+  let(:object)          { described_class.new(header, body)                             }
+  let(:header)          { [ [ :id, Integer ], [ :name, String ] ]                       }
+  let(:body)            { LazyEnumerable.new([ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ]) }
+  let(:described_class) { Relation                                                      }
+  let(:tautology)       { Function::Proposition::Tautology.instance                     }
+
+  context 'with a predicate' do
+    subject { object.restrict(predicate) }
+
+    let(:predicate) { object[:id].eq(1) }
+
+    it { should be_instance_of(Algebra::Restriction) }
+
+    it 'sets the predicate' do
+      subject.predicate.should equal(predicate)
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == object.select { |tuple| tuple[:id] == 1 }
+    end
+  end
+
+  context 'with a block' do
+    subject do
+      object.restrict { |context| context.id.eq(1) }
+    end
+
+    it { should be_instance_of(Algebra::Restriction) }
+
+    it 'sets the predicate' do
+      subject.predicate.should eql(object[:id].eq(1))
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == object.select { |tuple| tuple[:id] == 1 }
+    end
+  end
+
+  context 'with a Hash' do
+    subject { object.restrict(predicate) }
+
+    let(:predicate) { { :id => 1, :name => 'Dan Kubb' } }
+
+    it { should be_instance_of(Algebra::Restriction) }
+
+    # Hash order is not guaranteed except under 1.9+
+    if RUBY_VERSION >= '1.9'
+      it 'sets the predicate' do
+        subject.predicate.should eql(tautology.and(object[:id].eq(1).and(object[:name].eq('Dan Kubb'))))
+      end
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == object.select { |tuple| tuple[:id] == 1 and tuple[:name] == 'Dan Kubb' }
+    end
+  end
+
+  context 'with an Array' do
+    subject { object.restrict(predicate) }
+
+    let(:predicate) { [ [ :id, 1 ], [ :name, 'Dan Kubb' ] ] }
+
+    it { should be_instance_of(Algebra::Restriction) }
+
+    it 'sets the predicate' do
+      subject.predicate.should eql(tautology.and(object[:id].eq(1).and(object[:name].eq('Dan Kubb'))))
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == object.select { |tuple| tuple[:id] == 1 and tuple[:name] == 'Dan Kubb' }
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction, '#predicate' do
+  subject { object.predicate }
+
+  let(:relation)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:predicate) { relation[:id].ne(0)                           }
+  let(:object)    { described_class.new(relation, predicate)      }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should equal(predicate) }
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '.new' do
+  subject { object.new(operand, summarize_per, summarizers) }
+
+  let(:header)      { [ [ :id, Integer ], [ :name, String ] ]                        }
+  let(:operand)     { Relation.new(header, [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]) }
+  let(:summarizers) { {}                                                             }
+  let(:object)      { described_class                                                }
+
+  context 'with a summarize_per that has a subset of the headers in the operand' do
+    let(:summarize_per) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+
+    it { should be_instance_of(object) }
+  end
+
+  context 'with a summarize_per that has equivalent headers to the headers in the operand' do
+    let(:summarize_per) { operand }
+
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the summarize_per header must be a proper subset of the operand header') }
+  end
+
+  context 'with a summarize_per that has a superset of the headers in the operand' do
+    let(:summarize_per) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+
+    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the summarize_per header must be a proper subset of the operand header') }
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#delete' do
+  subject { object.delete(other) }
+
+  let(:object)       { described_class.new(operand, summarize_by, summarizers) }
+  let(:other)        { stub('other')                                           }
+  let(:operand)      { Relation.new([ [ :id, Integer ] ], [])                  }
+  let(:summarize_by) { operand.project([])                                     }
+  let(:summarizers)  { { :test => 1 }                                          }
+
+  specify { expect { subject }.to raise_error(ImmutableRelationError, 'deleting from a summarization is impossible') }
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:object)      { described_class.new(operand, operand.project([]), summarizers) }
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])           }
+  let(:summarizers) { { :count => lambda { |acc, tuple| acc.to_i + 1 } }             }
+  let(:yields)      { []                                                             }
+
+  it_should_behave_like 'an #each method'
+
+  it 'yields only tuples' do
+    subject
+    yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+  end
+
+  it 'yields only tuples with the expected header' do
+    subject
+    yields.each { |tuple| tuple.header.should eql(object.header) }
+  end
+
+  it 'yields only tuples with the expected data' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 2 ] ])
+  end
+end

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#eql?' do
+  subject { object.eql?(other) }
+
+  let(:operand)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])    }
+  let(:summarize_by) { operand.project([])                                     }
+  let(:summarizers)  { { :count => lambda { |acc, tuple| acc.to_i + 1 } }      }
+  let(:object)       { described_class.new(operand, summarize_by, summarizers) }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(operand, operand.project([]), summarizers) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having a different operand' do
+    let(:other_operand)      { Relation.new([ [ :id, Integer ] ], [ [ 3 ] ])                             }
+    let(:other_summarize_by) { summarize_by                                                              }
+    let(:other_summarizers)  { summarizers                                                               }
+    let(:other)              { described_class.new(other_operand, other_summarize_by, other_summarizers) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having a different summarize_by' do
+    let(:other_operand)      { operand                                                                   }
+    let(:other_summarize_by) { operand.project([]).sort_by {}                                            }
+    let(:other_summarizers)  { summarizers                                                               }
+    let(:other)              { described_class.new(other_operand, other_summarize_by, other_summarizers) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having different summarizers' do
+    let(:other_operand)      { operand                                                                   }
+    let(:other_summarize_by) { summarize_by                                                              }
+    let(:other_summarizers)  { {}                                                                        }
+    let(:other)              { described_class.new(other_operand, other_summarize_by, other_summarizers) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#hash' do
+  subject { object.hash }
+
+  let(:operand)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])    }
+  let(:summarize_by) { operand.project([])                                     }
+  let(:summarizers)  { { :count => lambda { |acc, tuple| acc.to_i + 1 } }      }
+  let(:object)       { described_class.new(operand, summarize_by, summarizers) }
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ operand.hash ^ summarize_by.hash ^ summarizers.hash }
+end

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#header' do
+  subject { object.header }
+
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:object)      { described_class.new(operand, TABLE_DEE, summarizers) }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it { should == [ [ :test, Object ] ] }
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#insert' do
+  subject { object.insert(other) }
+
+  let(:object)       { described_class.new(operand, summarize_by, summarizers) }
+  let(:other)        { stub('other')                                           }
+  let(:operand)      { Relation.new([ [ :id, Integer ] ], [])                  }
+  let(:summarize_by) { operand.project([])                                     }
+  let(:summarizers)  { { :test => 1 }                                          }
+
+  specify { expect { subject }.to raise_error(ImmutableRelationError, 'inserting into a summarization is impossible') }
+end

data/spec/unit/axiom/algebra/summarization/methods/summarize_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization::Methods, '#summarize' do
+  subject { object.summarize(summarize_with, &block) }
+
+  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+  let(:described_class) { Relation                                                                                                }
+  let(:block)           { lambda { |r| r.add(:test, r.id.count) }                                                                 }
+  let(:summarizers)     { [ :test, function ]                                                                                     }
+  let(:function)        { object[:id].count                                                                                       }
+
+  context 'with no arguments' do
+    subject { object.summarize(&block) }
+
+    it { should be_instance_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should equal(TABLE_DEE) }
+
+    its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
+  end
+
+  context 'with a relation' do
+    let(:summarize_with) { object.project([]) }
+
+    it { should be_instance_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should equal(summarize_with) }
+
+    its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
+  end
+
+  context 'with a header' do
+    let(:summarize_with) { object.project([]).header }
+
+    it { should be_instance_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should eql(object.project(summarize_with)) }
+
+    its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
+  end
+
+  context 'with attributes' do
+    let(:summarize_with) { [ :name ] }
+
+    it { should be_instance_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should eql(object.project(summarize_with)) }
+
+    its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
+  end
+
+  context 'with summarizers' do
+    subject { object.summarize(summarize_with, summarizers) }
+
+    let(:summarize_with) { object.project([])                           }
+    let(:summarizers)    { { Attribute::Object.new(:test) => function } }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should eql(summarize_with) }
+
+    its(:summarizers) { should eql(summarizers) }
+  end
+
+  context 'with a header containing an attribute used in the context block' do
+    let(:summarize_with) { object.project([ :id ])                  }
+    let(:block)          { lambda { |r| r.add(:count, r.id.count) } }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end