axiom 0.1.0

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

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :union, :| ].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 == attributes }
+
+      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 == [ [ :id, Integer ], [ :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 ], [ :age, Integer ] ] }
+
+      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 == other_attributes }
+
+      its(:keys) { should eql(keys) }
+    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 == other_attributes }
+
+      its(:keys) { should == [ [ [ :id, Integer ] ] ] }
+    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 == other_attributes }
+
+      its(:keys) { should be_empty }
+    end
+
+    context 'when the other can be coerced into a Header' do
+      let(:other) { other_attributes }
+
+      its(:to_ary) { should == attributes }
+
+      its(:keys) { should be_empty }
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#header' do
+  subject { object.header }
+
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ])   }
+  let(:object) { described_class.new(header, LazyEnumerable.new) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#include?' do
+  subject { object.include?(tuple) }
+
+  let(:object) { described_class.new(header, [ [ 1 ] ])        }
+  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
+
+  context 'when the tuple is in the relation' do
+    let(:tuple) { Tuple.new(header, [ 1 ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when the tuple is not in the relation' do
+    let(:tuple) { Tuple.new(header, [ 2 ]) }
+
+    it { should be(false) }
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '.new' do
+  subject { object.new(argument) }
+
+  let(:object) { described_class              }
+  let(:id)     { Attribute::Integer.new(:id)  }
+  let(:name)   { Attribute::String.new(:name) }
+
+  context 'with no arguments' do
+    subject { object.new }
+
+    it { should be_instance_of(object) }
+
+    it { should be_empty }
+  end
+
+  context 'with an argument that responds to #to_ary and contains irreducible keys' do
+    let(:argument) { [ Relation::Header.new([ id ]) ] }
+
+    it { should be_instance_of(object) }
+
+    it { should == argument }
+
+    it 'does not freeze the argument' do
+      argument.should_not be_frozen
+      expect { subject }.to_not change(argument, :frozen?)
+    end
+  end
+
+  context 'with an argument that responds to #to_ary and contains reducible keys' do
+    let(:argument)        { [ reducible_key, irreducible_key ] }
+    let(:reducible_key)   { Relation::Header.new([ id, name ]) }
+    let(:irreducible_key) { Relation::Header.new([ id ])       }
+
+    specify { expect { subject }.to raise_error(ReducibleKeyError, "reducible keys: #{[ reducible_key.to_set ].inspect}") }
+  end
+
+  context 'when the argument is not a Keys and does not respond to #to_ary' do
+    let(:argument) { Object.new }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :difference, :- ].each do |method|
+  describe Relation::Keys, "##{method}" do
+    subject { object.send(method, other) }
+
+    let(:object) { described_class.coerce([ header       ]) }
+    let(:other)  { described_class.coerce([ other_header ]) }
+    let(:header) { [ [ :id, Integer ] ]                     }
+
+    context 'when the attributes overlap' do
+      let(:other_header) { [ [ :id, Integer ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      it { should be_empty }
+    end
+
+    context 'when the attributes do not overlap' do
+      let(:other_header) { [ [ :name, String ] ] }
+
+      it { should equal(object) }
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#each' do
+  subject { object.each { |key| yields << key } }
+
+  let(:object) { described_class.coerce([ header ]) }
+  let(:header) { [ [ :id ] ]                        }
+  let(:yields) { []                                 }
+
+  it_should_behave_like 'an #each method'
+
+  it 'yields only headers' do
+    subject
+    yields.each { |header| header.should be_instance_of(Relation::Header) }
+  end
+
+  it 'yields only headers with the expected data' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ header ])
+  end
+end
+
+describe Relation::Keys 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

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#empty?' do
+  subject { object.empty? }
+
+  let(:object) { described_class.coerce(keys) }
+
+  context 'with keys' do
+    let(:keys) { [ [ [ :id ] ] ] }
+
+    it { should be(false) }
+  end
+
+  context 'without keys' do
+    let(:keys) { [] }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/relation/keys/extend_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#extend' do
+  subject { object.extend(attributes) }
+
+  let(:object)    { described_class.coerce([ header ]) }
+  let(:header)    { []                                 }
+
+  context 'with attributes that do not change the keys' do
+    let(:attributes) { [] }
+
+    it { should equal(object) }
+  end
+
+  context 'with attributes that change the keys' do
+    let(:attributes) { [ :id ] }
+
+    it { should be_instance_of(described_class) }
+
+    it { should == [ attributes ] }
+  end
+
+  context 'when the keys are empty' do
+    let(:object)     { described_class.new }
+    let(:attributes) { [ :id ]             }
+
+    it { should be_instance_of(described_class) }
+
+    it { should == [ attributes ] }
+  end
+end

data/spec/unit/axiom/relation/keys/intersect_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :intersect, :& ].each do |method|
+  describe Relation::Keys, "##{method}" do
+    subject { object.send(method, other) }
+
+    let(:object) { described_class.coerce([ header       ]) }
+    let(:other)  { described_class.coerce([ other_header ]) }
+    let(:header) { [ [ :id ] ]                              }
+
+    context 'when the attributes overlap' do
+      let(:other_header) { header.dup }
+
+      it { should equal(object) }
+    end
+
+    context 'when the attributes do not overlap' do
+      let(:other_header) { [ [ :name ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      it { should be_empty }
+    end
+  end
+end

data/spec/unit/axiom/relation/keys/project_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#project' do
+  subject { object.project(attributes) }
+
+  let(:object) { described_class.coerce([ header ]) }
+  let(:header) { [ id, name ]                       }
+  let(:id)     { [ :id   ]                          }
+  let(:name)   { [ :name ]                          }
+
+  context 'with attributes that do not change the keys' do
+    let(:attributes) { [ id, name ] }
+
+    it { should equal(object) }
+  end
+
+  context 'with attributes that change the keys' do
+    let(:attributes) { [ id ] }
+
+    it { should be_instance_of(described_class) }
+
+    it { should == [ [ id ] ] }
+  end
+
+  context 'with attributes that clear the keys' do
+    let(:attributes) { [] }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_empty }
+  end
+end

data/spec/unit/axiom/relation/keys/rename_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#rename' do
+  subject { object.rename(aliases) }
+
+  let(:object)  { described_class.coerce([ header1, header2 ])               }
+  let(:header1) { [ [ :id, Integer ] ]                                       }
+  let(:header2) { [ [ :name, String ] ]                                      }
+  let(:aliases) { Algebra::Rename::Aliases.coerce(header1, :id => :other_id) }
+
+  it { should be_instance_of(described_class) }
+
+  it { should == [ [ [ :other_id, Integer ] ], header2 ] }
+end

data/spec/unit/axiom/relation/keys/to_ary_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Keys, '#to_ary' do
+  subject { object.to_ary }
+
+  let(:object) { described_class.coerce([ header ]) }
+  let(:header) { [ [ :id ] ]                        }
+
+  it { should be_instance_of(Array) }
+
+  it { should == [ header ] }
+
+  it { should be_frozen }
+end

data/spec/unit/axiom/relation/keys/union_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :union, :| ].each do |method|
+  describe Relation::Keys, "##{method}" do
+    subject { object.send(method, other) }
+
+    let(:object) { described_class.coerce([ header       ]) }
+    let(:other)  { described_class.coerce([ other_header ]) }
+    let(:header) { [ [ :id, Integer] ]                      }
+
+    context 'when the attributes overlap' do
+      let(:other_header) { [ [ :id, Integer ] ] }
+
+      it { should equal(object) }
+    end
+
+    context 'when the attributes do not overlap' do
+      let(:other_header) { [ [ :name, String ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      it { should == [ header, other_header ] }
+    end
+  end
+end