axiom 0.1.0

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module UnaryOperationSpecs
+  class Object < Relation
+    include Relation::Operation::Unary
+
+    def each(&block)
+      operand.each(&block)
+      self
+    end
+
+    def new(relation)
+      self.class.new(relation)
+    end
+
+  end # class Object
+end # module UnaryOperationSpecs

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Relation::Operation::Unary, '#header' do
+  subject { object.header }
+
+  let(:described_class) { UnaryOperationSpecs::Object                   }
+  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:relation)        { Relation.new(header, [ [ 1 ] ])               }
+  let(:object)          { described_class.new(relation)                 }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
+end

data/spec/unit/axiom/relation/proxy/each_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Proxy, '#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:object)          { described_class.new(relation)            }
+  let(:described_class) { Class.new(Relation)                      }
+  let(:relation)        { Relation.new([ [ :id, Integer ] ], body) }
+  let(:body)            { [ [ 1 ], [ 2 ] ]                         }
+  let(:yields)          { []                                       }
+
+  before do
+    described_class.class_eval do
+      include Relation::Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+    end
+  end
+
+  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 be(object.header) }
+  end
+
+  it 'yields only tuples with the expected data' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to(body)
+  end
+end

data/spec/unit/axiom/relation/proxy/hash_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Proxy, '#hash' do
+  subject { object.hash }
+
+  let(:object)          { described_class.new(relation)            }
+  let(:described_class) { Class.new(Relation)                      }
+  let(:relation)        { Relation.new([ [ :id, Integer ] ], body) }
+  let(:body)            { [ [ 1 ], [ 2 ] ]                         }
+
+  before do
+    described_class.class_eval do
+      include Relation::Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+    end
+  end
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ relation.hash }
+end

data/spec/unit/axiom/relation/proxy/method_missing_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Proxy, '#method_missing' do
+  subject { object.unknown }
+
+  let(:object)          { described_class.new(relation)            }
+  let(:described_class) { Class.new(Relation)                      }
+  let(:relation)        { Relation.new([ [ :id, Integer ] ], body) }
+  let(:body)            { [ [ 1 ], [ 2 ] ]                         }
+
+  before do
+    described_class.class_eval do
+      include Relation::Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+    end
+  end
+
+  specify { expect { subject }.to raise_error(NoMethodError) }
+end

data/spec/unit/axiom/relation/proxy/respond_to_predicate_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Proxy, '#respond_to?' do
+  subject { object.respond_to?(method) }
+
+  let(:object)          { described_class.new(relation)            }
+  let(:described_class) { Class.new(Relation)                      }
+  let(:relation)        { Relation.new([ [ :id, Integer ] ], body) }
+  let(:body)            { [ [ 1 ], [ 2 ] ]                         }
+
+  before do
+    described_class.class_eval do
+      include Relation::Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+    end
+  end
+
+  context 'with a known method in the proxy' do
+    let(:method) { :header }
+
+    it { should be(true) }
+  end
+
+  context 'with a known method in the relation' do
+    let(:method) { :each }
+
+    it { should be(true) }
+  end
+
+  context 'with an unknown method' do
+    let(:method) { :unknown }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#replace' do
+  subject { object.replace(other) }
+
+  let(:object)         { described_class.new(header, [ [ 1 ] ]) }
+  let(:other_relation) { described_class.new(header, [ [ 2 ] ]) }
+  let(:header)         { [ [ :id, Integer ] ]                   }
+
+  shared_examples_for 'Relation#replace' do
+    it { should be_instance_of(Relation::Operation::Insertion) }
+
+    its(:header) { should == header }
+
+    it 'returns the expected tuples' do
+      should == other
+    end
+
+    it 'applies the left operations in the correct sequence' do
+      subject = self.subject.left
+      subject.should be_instance_of(Relation::Operation::Deletion)
+      subject.left.should equal(object)
+      subject.right.should be_instance_of(Algebra::Difference)
+      subject.right.left.should equal(object)
+      subject.right.right.should eql(other_relation)
+    end
+
+    it 'applies the right operations in the correct sequence' do
+      subject = self.subject.right
+      subject.should be_instance_of(Algebra::Difference)
+      subject.left.should eql(other_relation)
+      subject.right.should equal(object)
+    end
+  end
+
+  context 'with a relation' do
+    let(:other) { other_relation }
+
+    it_should_behave_like 'Relation#replace'
+  end
+
+  context 'with an array of tuples' do
+    let(:other) { other_relation.to_a }
+
+    it_should_behave_like 'Relation#replace'
+  end
+
+  context 'with an array of arrays' do
+    let(:other) { other_relation.map(&:to_ary) }
+
+    it_should_behave_like 'Relation#replace'
+  end
+end

data/spec/unit/axiom/tuple/call_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+[ :call, :[] ].each do |method|
+  describe Tuple, "##{method}" do
+    subject { object.send(method, attribute) }
+
+    let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+    let(:object) { described_class.new(header, [ 1 ])            }
+
+    context 'with a known attribute' do
+      let(:attribute) { header[:id] }
+
+      it { should == 1 }
+    end
+
+    context 'with an unknown attribute' do
+      let(:attribute) { Attribute::Integer.new(:other_id) }
+
+      specify { expect { subject }.to raise_error(UnknownAttributeError, 'the attribute other_id is unknown') }
+    end
+  end
+end

data/spec/unit/axiom/tuple/class_methods/coerce_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '.coerce' do
+  subject { object.coerce(header, argument) }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:object) { described_class                               }
+  let(:tuple)  { object.new(header, [ 1 ])                     }
+
+  context 'when the argument is a Tuple' do
+    let(:argument) { tuple }
+
+    it { should equal(argument) }
+  end
+
+  context 'when the argument responds to #to_ary' do
+    let(:argument) { [ 1 ] }
+
+    it { should be_instance_of(object) }
+
+    it { should eql(tuple) }
+  end
+
+  context 'when the argument is not a Tuple and does not respond to #to_ary' do
+    let(:argument) { { :id => 1 } }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

data/spec/unit/axiom/tuple/data_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#data' do
+  subject { object.data }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:object) { described_class.new(header, [ 1 ])            }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Hash) }
+
+  it { should eql(header[:id] => 1) }
+end

data/spec/unit/axiom/tuple/eql_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#eql?' do
+  subject { object.eql?(other) }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:data)   { [ 1 ]                                         }
+  let(:object) { described_class.new(header, data)             }
+
+  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(header, data) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having a different header' do
+    let(:other_header) { Relation::Header.coerce([ [ :id, Numeric ] ]) }
+    let(:other_data)   { data                                          }
+    let(:other)        { described_class.new(other_header, other_data) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an object having different data' do
+    let(:other_header) { header                                        }
+    let(:other_data)   { [ 2 ]                                         }
+    let(:other)        { described_class.new(other_header, other_data) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

data/spec/unit/axiom/tuple/equality_operator_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#==' do
+  subject { object == other }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:data)   { [ 1 ]                                         }
+  let(:object) { described_class.new(header, data)             }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(header, data) }
+
+    it { should be(true) }
+
+    it 'is not symmetric' do
+      should_not eql(other == object)
+    end
+  end
+
+  context 'with an object having a different header' do
+    let(:other_header) { Relation::Header.coerce([ [ :id, Numeric ] ]) }
+    let(:other_data)   { data                                          }
+    let(:other)        { described_class.new(other_header, other_data) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having different data' do
+    let(:other_header) { header                                        }
+    let(:other_data)   { [ 2 ]                                         }
+    let(:other)        { described_class.new(other_header, other_data) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object responding to #to_ary' do
+    let(:other) { data }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with a different object responding to #to_ary' do
+    let(:other) { [ 2 ] }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+end