axiom 0.1.0

data/spec/unit/axiom/relation/materialize_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#materialize' do
+  subject { object.materialize }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ])                                   }
+  let(:object) { described_class.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+
+  before do
+    object.should be_kind_of(described_class)
+  end
+
+  it { should be_instance_of(Relation::Materialized) }
+
+  its(:header) { should equal(header) }
+
+  its(:directions) { should == header }
+
+  it 'returns an equivalent relation to the unmaterialized operation' do
+    should == object
+  end
+end

data/spec/unit/axiom/relation/materialized/class_methods/new_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '.new' do
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:tuples) { [ [ 1 ] ]                                     }
+  let(:object) { described_class                               }
+
+  context 'with directions' do
+    subject { object.new(header, tuples, directions) }
+
+    let(:directions) { [ header[:id] ] }
+
+    it { should be_instance_of(object) }
+
+    its(:header) { should equal(header) }
+
+    its(:directions) do
+      should be_instance_of(Relation::Operation::Order::DirectionSet)
+      should == directions
+    end
+
+    it { should == tuples }
+  end
+
+  context 'with no directions' do
+    subject { object.new(header, tuples) }
+
+    it { should be_instance_of(object) }
+
+    its(:header) { should equal(header) }
+
+    its(:directions) { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
+
+    it { should == tuples }
+  end
+end

data/spec/unit/axiom/relation/materialized/directions_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#directions' do
+  subject { object.directions }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:tuples) { LazyEnumerable.new                            }
+
+  context 'with directions' do
+    let(:object)     { described_class.new(header, tuples, directions) }
+    let(:directions) { [ header[:id] ]                                 }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should == directions }
+  end
+
+  context 'with no directions' do
+    let(:object) { described_class.new(header, tuples) }
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
+  end
+end

data/spec/unit/axiom/relation/materialized/empty_predicate_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#empty?' do
+  subject { object.empty? }
+
+  let(:header) { [ [ :id, Integer ] ]              }
+  let(:object) { described_class.new(header, body) }
+
+  context 'with a body containing no entries' do
+    let(:body) { [] }
+
+    it { should be(true) }
+  end
+
+  context 'with a body containing an entry' do
+    let(:body) { [ [ 1 ] ] }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/relation/materialized/materialize_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#materialize' do
+  subject { object.materialize }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  it { should equal(object) }
+end

data/spec/unit/axiom/relation/materialized/materialized_predicate_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#materialized?' do
+  subject { object.materialized? }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it { should be(true) }
+end

data/spec/unit/axiom/relation/materialized/size_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#size' do
+  subject { object.size }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should == 1 }
+end

data/spec/unit/axiom/relation/materialized_predicate_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#materialized?' do
+  subject { object.materialized? }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it { should be(false) }
+end

data/spec/unit/axiom/relation/one_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#one' do
+  subject { object.one }
+
+  let(:object) { described_class.new(header, body)             }
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+
+  context 'with a relation having no tuples' do
+    let(:body) { LazyEnumerable.new }
+
+    specify { expect { subject }.to raise_error(NoTuplesError, 'one tuple expected, but was an empty set') }
+
+    specify { expect { subject }.to raise_error(SetSizeError) }
+  end
+
+  context 'with a relation having one tuple' do
+    let(:body) { LazyEnumerable.new([ [ 1 ] ]) }
+
+    it { should be_instance_of(Tuple) }
+
+    it 'returns the expected tuple' do
+      should == [ 1 ]
+    end
+  end
+
+  context 'with a relation having many tuples' do
+    let(:body) { LazyEnumerable.new([ [ 1 ], [ 2 ] ]) }
+
+    specify { expect { subject }.to raise_error(ManyTuplesError, 'one tuple expected, but set contained 2 tuples') }
+
+    specify { expect { subject }.to raise_error(SetSizeError) }
+  end
+end

data/spec/unit/axiom/relation/operation/binary/class_methods/included_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Binary, '.included' do
+  subject { object }
+
+  let(:object) { described_class }
+  let(:klass)  { Class.new       }
+
+  it 'extends the klass' do
+    klass.singleton_class.should_not include(described_class::ClassMethods)
+    klass.send(:include, subject)
+    klass.singleton_class.should include(described_class::ClassMethods)
+  end
+
+  it 'delegates to the ancestor' do
+    included_ancestor = false
+    subject.extend Module.new {
+      define_method(:included) { |_| included_ancestor = true }
+    }
+    expect {
+      klass.send(:include, subject)
+    }.to change { included_ancestor }.from(false).to(true)
+  end
+end

data/spec/unit/axiom/relation/operation/binary/class_methods/new_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe Relation::Operation::Binary::ClassMethods, '#new' do
+  subject { object.new(left, right) }
+
+  let(:original_left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
+  let(:original_right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+  let(:object)         { BinaryRelationOperationSpecs::Object                     }
+
+  context 'with left and right ordered' do
+    let(:left)  { original_left.sort_by  { |r| r.id   } }
+    let(:right) { original_right.sort_by { |r| r.name } }
+
+    it { should be_instance_of(object) }
+  end
+
+  context 'with left and right unordered' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should be_instance_of(object) }
+  end
+
+  context 'with left ordered, and right unordered' do
+    let(:left)  { original_left.sort_by { |r| r.id } }
+    let(:right) { original_right                     }
+
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+  end
+
+  context 'with right ordered, and left unordered' do
+    let(:left)  { original_left                         }
+    let(:right) { original_right.sort_by { |r| r.name } }
+
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+  end
+end

data/spec/unit/axiom/relation/operation/binary/fixtures/classes.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module BinaryRelationOperationSpecs
+  class Object < Relation
+    include Relation::Operation::Binary
+
+    def each(&block)
+      left.each(&block)
+      right.each(&block)
+      self
+    end
+
+  end # class Object
+end # module BinaryRelationOperationSpecs

data/spec/unit/axiom/relation/operation/binary/header_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Relation::Operation::Binary, '#header' do
+  subject { object.header }
+
+  let(:described_class) { BinaryRelationOperationSpecs::Object                     }
+  let(:left)            { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
+  let(:right)           { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+  let(:object)          { described_class.new(left, right)                         }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it { should == [ [ :id, Integer ], [ :name, String ] ] }
+end

data/spec/unit/axiom/relation/operation/combination/class_methods/combine_tuples_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Combination, '.combine_tuples' do
+  subject { object.combine_tuples(header, left_tuple, right_tuples) { |tuple| yields << tuple } }
+
+  let(:left_header)  { Relation::Header.coerce([ [ :id,   Integer ] ] ) }
+  let(:right_header) { Relation::Header.coerce([ [ :name, String  ] ] ) }
+  let(:left_tuple)   { Tuple.new(left_header,  [ 1 ])                   }
+  let(:right_tuples) { [ Tuple.new(right_header, [ 'Dan Kubb' ]) ]      }
+  let(:header)       { left_header | right_header                       }
+  let(:object)       { self.class.described_class                       }
+  let(:yields)       { []                                               }
+
+  it 'yields each combined tuple' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ [ 1, 'Dan Kubb' ] ])
+  end
+end

data/spec/unit/axiom/relation/operation/combination/fixtures/classes.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module CombinationOperationSpecs
+  class Object < Relation
+    include Relation::Operation::Combination
+
+    def each
+      left.each  { |tuple| yield tuple.project(header) }
+      right.each { |tuple| yield tuple.project(header) }
+      self
+    end
+
+  end # class Object
+end # module CombinationOperationSpecs

data/spec/unit/axiom/relation/operation/combination/header_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Relation::Operation::Combination, '#header' do
+  subject { object.header }
+
+  let(:described_class) { CombinationOperationSpecs::Object                        }
+  let(:left)            { Relation.new([ [ :id,   Integer ] ], [ [ 1 ], [ 2 ] ])   }
+  let(:right)           { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+  let(:object)          { described_class.new(left, right)                         }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it 'unions the headers' do
+    should == [ [ :id, Integer ], [ :name, String ] ]
+  end
+end

data/spec/unit/axiom/relation/operation/deletion/initialize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Deletion, '#initialize' do
+  subject { described_class.new(base, other) }
+
+  let(:base)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:other) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  it { should be_instance_of(described_class) }
+
+  its(:left) { should be(base) }
+
+  its(:right) { should be(other) }
+end

data/spec/unit/axiom/relation/operation/deletion/methods/delete_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Deletion::Methods, '#insert' do
+  subject { object.delete(other) }
+
+  let(:object) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:tuples) { [ [ 1 ] ]                                            }
+
+  context 'when other is a Relation' do
+    let(:other) { Relation.new([ [ :id, Integer ] ], tuples) }
+
+    it { should be_instance_of(Relation::Operation::Deletion) }
+
+    its(:left) { should be(object) }
+
+    its(:right) { should be(other) }
+
+    it 'returns the expected tuples' do
+      should == [ [ 2 ] ]
+    end
+  end
+
+  context 'when other is an Enumerable' do
+    let(:other) { tuples }
+
+    it { should be_instance_of(Relation::Operation::Deletion) }
+
+    its(:left) { should be(object) }
+
+    its(:right) { should_not be(other) }
+
+    its(:right) { should be_kind_of(Relation) }
+
+    its(:right) { should == other }
+
+    it 'returns the expected tuples' do
+      should == [ [ 2 ] ]
+    end
+  end
+end

data/spec/unit/axiom/relation/operation/insertion/initialize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Insertion, '#initialize' do
+  subject { described_class.new(base, other) }
+
+  let(:base)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:other) { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ]) }
+
+  it { should be_instance_of(described_class) }
+
+  its(:left) { should be(base) }
+
+  its(:right) { should be(other) }
+end