axiom 0.1.0

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

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#==' do
+  subject { object == other }
+
+  let(:header) { [ [ :id, Integer ] ]              }
+  let(:body)   { LazyEnumerable.new([ [ 1 ] ])     }
+  let(:object) { described_class.new(header, body) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  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, body) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having a different header' do
+    let(:other_header) { [ [ :id, Numeric ] ]                          }
+    let(:other_body)   { body                                          }
+    let(:other)        { described_class.new(other_header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having a different body' do
+    let(:other_header) { header                                        }
+    let(:other_body)   { LazyEnumerable.new([ [ 2 ] ])                 }
+    let(:other)        { described_class.new(other_header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having an equivalent header in a different order' do
+    let(:attribute1) { [ :id,   Integer ]                                                      }
+    let(:attribute2) { [ :name, String  ]                                                      }
+    let(:header1)    { [ attribute1, attribute2 ]                                              }
+    let(:header2)    { [ attribute2, attribute1 ]                                              }
+    let(:object)     { described_class.new(header1, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+    let(:other)      { described_class.new(header2, LazyEnumerable.new([ [ 'Dan Kubb', 1 ] ])) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object responding to #to_set' do
+    let(:other) { Set[ [ 1 ] ] }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      pending 'Set#== should call to_set on other' do
+        should eql(other == object)
+      end
+    end
+  end
+
+  context 'with a different object responding to #to_set' do
+    let(:other) { Set[ [ 2 ] ] }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with a different object having a superset of the headers' do
+    let(:other_header) { [ [ :id, Integer ], [ :name, String ] ]       }
+    let(:other_body)   { LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])     }
+    let(:other)        { described_class.new(other_header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#hash' do
+  subject { object.hash }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+  let(:body)   { LazyEnumerable.new                            }
+  let(:object) { described_class.new(header, body)             }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ header.hash ^ body.to_set.hash }
+end

data/spec/unit/axiom/relation/header/call_spec.rb

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

data/spec/unit/axiom/relation/header/class_methods/coerce_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Header, '.coerce' do
+  let(:object)    { described_class             }
+  let(:header)    { object.new([ attribute ])   }
+  let(:attribute) { Attribute::Integer.new(:id) }
+  let(:array)     { [ [ :id, Integer ] ]        }
+
+  context 'with a block' do
+    subject { object.coerce(argument, &block) }
+
+    context 'when the argument is a Header' do
+      let(:argument) { header                            }
+      let(:block)    { proc { raise 'should not raise' } }
+
+      it { should equal(header) }
+    end
+
+    context 'when the argument responds to #to_ary' do
+      let(:argument) { array }
+
+      context 'and the block returns another attribute' do
+        let(:block) { lambda { |attribute| other } }
+        let(:other) { Attribute::Object.new(:id)   }
+
+        it { should be_instance_of(object) }
+
+        it { should eql(object.new([ other ])) }
+
+        its(:keys) { should be_empty }
+      end
+
+      context 'and the block does not match another attribute' do
+        let(:block) { lambda { |attribute| nil } }
+
+        it { should be_instance_of(object) }
+
+        it { should eql(header) }
+
+        its(:keys) { should be_empty }
+      end
+    end
+
+    context 'when the argument is not a Header and does not respond to #to_ary' do
+      let(:argument) { Object.new                 }
+      let(:block)    { lambda { |attribute| nil } }
+
+      specify { expect { subject }.to raise_error(NoMethodError) }
+    end
+  end
+
+  context 'without a block' do
+    subject { object.coerce(argument) }
+
+    context 'when the argument is a Header' do
+      let(:argument) { header }
+
+      it { should equal(header) }
+    end
+
+    context 'when the argument responds to #to_ary' do
+      let(:argument) { array }
+
+      it { should be_instance_of(object) }
+
+      it { should eql(header) }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the argument is not a Header and does not respond to #to_ary' do
+      let(:argument) { Object.new }
+
+      specify { expect { subject }.to raise_error(NoMethodError) }
+    end
+  end
+
+  context 'with an attribute' do
+    subject { object.coerce(attribute) }
+
+    it { should be_instance_of(object) }
+
+    its(:to_a) { should == [ attribute ] }
+
+    its(:keys) { should be_empty }
+  end
+
+  context 'with options' do
+    subject { object.coerce(array, options) }
+
+    let(:options) { { :keys => [ array ] } }
+
+    it { should be_instance_of(object) }
+
+    its(:to_a) { should == array }
+
+    its(:keys) { should == [ array ] }
+  end
+end

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Header, '.new' do
+  let(:object) { described_class              }
+  let(:id)     { Attribute::Integer.new(:id)  }
+  let(:name)   { Attribute::String.new(:name) }
+  let(:age)    { Attribute::Integer.new(:age) }
+
+  context 'with no arguments' do
+    subject { object.new }
+
+    it { should be_instance_of(object) }
+
+    it { should be_empty }
+  end
+
+  context 'with attributes' do
+    subject { object.new(attributes) }
+
+    let(:attributes) { [ id, name ] }
+
+    it { should be_instance_of(object) }
+
+    it { should == attributes }
+
+    it 'does not freeze the attributes' do
+      attributes.should_not be_frozen
+      expect { subject }.to_not change(attributes, :frozen?)
+    end
+  end
+
+  context 'with attributes and options' do
+    subject { object.new(attributes, options) }
+
+    let(:attributes) { [ id, name ] }
+    let(:options)    { {}           }
+
+    it { should be_instance_of(object) }
+
+    it { should == attributes }
+
+    it 'does not freeze the attributes' do
+      attributes.should_not be_frozen
+      expect { subject }.to_not change(attributes, :frozen?)
+    end
+
+    it 'does not freeze the options' do
+      options.should_not be_frozen
+      expect { subject }.to_not change(options, :frozen?)
+    end
+  end
+
+  context 'with attributes that contain duplicates' do
+    subject { object.new([ id, id, name, name, name, age ]) }
+
+    specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: [:id, :name]') }
+  end
+
+  context 'with an argument that does not respond to #to_ary' do
+    subject { object.new(Object.new) }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

data/spec/unit/axiom/relation/header/difference_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :difference, :- ].each do |method|
+  describe Relation::Header, "##{method}" do
+    subject { object.send(method, other) }
+
+    let(:object)           { described_class.coerce(attributes, options)             }
+    let(:other)            { described_class.coerce(other_attributes, other_options) }
+    let(:attributes)       { [ [ :id, Integer ], [ :name, String ] ]                 }
+    let(:other_attributes) { attributes                                              }
+    let(:options)          { {}                                                      }
+    let(:other_options)    { options                                                 }
+    let(:keys)             { Relation::Keys.coerce([ [ [ :id, Integer ] ] ])         }
+    let(:other_keys)       { keys                                                    }
+
+    context 'when the attributes are equivalent' do
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should be_empty }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the attributes intersect' do
+      let(:other_attributes) { [ [ :id, Integer ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should == [ [ :name, String ] ] }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the attributes do not intersect' do
+      let(:other_attributes) { [ [ :age, Integer ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should == [ [ :id, Integer ], [ :name, String ] ] }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the keys are equivalent' do
+      let(:other_attributes) { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
+      let(:options)          { { :keys => keys }                                          }
+
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should be_empty }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the keys intersect' do
+      let(:other_attributes) { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
+      let(:options)          { { :keys => keys }                                          }
+      let(:other_options)    { { :keys => other_keys }                                    }
+
+      let(:other_keys) do
+        Relation::Keys.coerce([
+          [ [ :id,  Integer ] ],
+          [ [ :age, Integer ] ],
+         ])
+      end
+
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should be_empty }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the keys do not intersect' do
+      let(:other_attributes) { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
+      let(:options)          { { :keys => keys }                                          }
+      let(:other_options)    { { :keys => other_keys }                                    }
+
+      let(:other_keys) do
+        Relation::Keys.coerce([ [ [ :name, String ], [ :age, Integer ] ] ])
+      end
+
+      it { should be_instance_of(described_class) }
+
+      its(:to_ary) { should be_empty }
+
+      its(:keys) { should eql(keys) }
+    end
+
+    context 'when the other can be coerced into a Header' do
+      let(:other) { other_attributes }
+
+      its(:to_ary) { should be_empty }
+
+      its(:keys) { should be_empty }
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Header, '#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:attribute) { Attribute::Integer.new(:id)        }
+  let(:object)    { described_class.new([ attribute ]) }
+  let(:yields)    { []                                 }
+
+  it_should_behave_like 'an #each method'
+
+  it 'yields only attributes' do
+    subject
+    yields.each { |attribute| attribute.should be_kind_of(Attribute) }
+  end
+
+  it 'yields each attribute' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ attribute ])
+  end
+end
+
+describe Relation::Header do
+  subject { object.new }
+
+  let(:object) { described_class }
+
+  it { should be_kind_of(Enumerable) }
+
+  it 'case matches Enumerable' do
+    (Enumerable === subject).should be(true)
+  end
+end