axiom 0.1.0 → 0.1.1

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation, '#header' do
   subject { object.header }
 
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ])   }
+  let(:header) { Relation::Header.coerce([[:id, Integer]])       }
   let(:object) { described_class.new(header, LazyEnumerable.new) }
 
   before do
@@ -14,5 +14,5 @@ describe Relation, '#header' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(header) }
+  it { should be(header) }
 end

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

@@ -5,17 +5,17 @@ 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 ] ]) }
+  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 ]) }
+    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 ]) }
+    let(:tuple) { Tuple.new(header, [2]) }
 
     it { should be(false) }
   end

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

@@ -8,17 +8,17 @@ describe Relation::Keys, '.coerce' do
   let(:object) { described_class }
 
   context 'when the arguments are Keys' do
-    let(:argument) { object.new([ [ [ :id ] ] ]) }
+    let(:argument) { object.new([[[:id]]]) }
 
-    it { should equal(argument) }
+    it { should be(argument) }
   end
 
   context 'when the argument responds to #to_ary' do
-    let(:argument) { [ [ [ :id ] ] ] }
+    let(:argument) { [[[:id]]] }
 
     it { should be_instance_of(object) }
 
-    it { should == [ Relation::Header.coerce([ :id ]) ] }
+    it { should == [Relation::Header.coerce([:id])] }
   end
 
   context 'when the argument is not a Keys and does not respond to #to_ary' do

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

@@ -18,7 +18,7 @@ describe Relation::Keys, '.new' do
   end
 
   context 'with an argument that responds to #to_ary and contains irreducible keys' do
-    let(:argument) { [ Relation::Header.new([ id ]) ] }
+    let(:argument) { [Relation::Header.new([id])] }
 
     it { should be_instance_of(object) }
 
@@ -31,11 +31,11 @@ describe Relation::Keys, '.new' do
   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 ])       }
+    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}") }
+    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

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

@@ -2,16 +2,16 @@
 
 require 'spec_helper'
 
-[ :difference, :- ].each do |method|
+[: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 ] ]                     }
+    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 ] ] }
+      let(:other_header) { [[:id, Integer]] }
 
       it { should be_instance_of(described_class) }
 
@@ -19,9 +19,9 @@ require 'spec_helper'
     end
 
     context 'when the attributes do not overlap' do
-      let(:other_header) { [ [ :name, String ] ] }
+      let(:other_header) { [[:name, String]] }
 
-      it { should equal(object) }
+      it { should be(object) }
     end
   end
 end

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

@@ -5,9 +5,9 @@ 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) { []                                 }
+  let(:object) { described_class.coerce([header]) }
+  let(:header) { [[:id]]                          }
+  let(:yields) { []                               }
 
   it_should_behave_like 'an #each method'
 
@@ -17,9 +17,9 @@ describe Relation::Keys, '#each' do
   end
 
   it 'yields only headers with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ header ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([header])
   end
 end
 

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

@@ -8,7 +8,7 @@ describe Relation::Keys, '#empty?' do
   let(:object) { described_class.coerce(keys) }
 
   context 'with keys' do
-    let(:keys) { [ [ [ :id ] ] ] }
+    let(:keys) { [[[:id]]] }
 
     it { should be(false) }
   end

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

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

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

@@ -2,22 +2,22 @@
 
 require 'spec_helper'
 
-[ :intersect, :& ].each do |method|
+[: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 ] ]                              }
+    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) }
+      it { should be(object) }
     end
 
     context 'when the attributes do not overlap' do
-      let(:other_header) { [ [ :name ] ] }
+      let(:other_header) { [[:name]] }
 
       it { should be_instance_of(described_class) }
 

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

@@ -5,23 +5,23 @@ 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 ]                          }
+  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 ] }
+    let(:attributes) { [id, name] }
 
-    it { should equal(object) }
+    it { should be(object) }
   end
 
   context 'with attributes that change the keys' do
-    let(:attributes) { [ id ] }
+    let(:attributes) { [id] }
 
     it { should be_instance_of(described_class) }
 
-    it { should == [ [ id ] ] }
+    it { should == [[id]] }
   end
 
   context 'with attributes that clear the keys' do

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

@@ -5,12 +5,12 @@ 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) }
+  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 ] }
+  it { should == [[[:other_id, Integer]], header2] }
 end

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

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

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

@@ -2,26 +2,26 @@
 
 require 'spec_helper'
 
-[ :union, :| ].each do |method|
+[: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] ]                      }
+    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 ] ] }
+      let(:other_header) { [[:id, Integer]] }
 
-      it { should equal(object) }
+      it { should be(object) }
     end
 
     context 'when the attributes do not overlap' do
-      let(:other_header) { [ [ :name, String ] ] }
+      let(:other_header) { [[:name, String]] }
 
       it { should be_instance_of(described_class) }
 
-      it { should == [ header, other_header ] }
+      it { should == [header, other_header] }
     end
   end
 end

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

@@ -5,8 +5,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 } }
+  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)
@@ -14,7 +14,7 @@ describe Relation, '#materialize' do
 
   it { should be_instance_of(Relation::Materialized) }
 
-  its(:header) { should equal(header) }
+  its(:header) { should be(header) }
 
   its(:directions) { should == header }
 

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

@@ -3,18 +3,18 @@
 require 'spec_helper'
 
 describe Relation::Materialized, '.new' do
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:tuples) { [ [ 1 ] ]                                     }
-  let(:object) { described_class                               }
+  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] ] }
+    let(:directions) { [header[:id]] }
 
     it { should be_instance_of(object) }
 
-    its(:header) { should equal(header) }
+    its(:header) { should be(header) }
 
     its(:directions) do
       should be_instance_of(Relation::Operation::Order::DirectionSet)
@@ -29,10 +29,22 @@ describe Relation::Materialized, '.new' do
 
     it { should be_instance_of(object) }
 
-    its(:header) { should equal(header) }
+    its(:header) { should be(header) }
 
-    its(:directions) { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
+    its(:directions) { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
 
     it { should == tuples }
   end
+
+  context 'with no tuples or directions' do
+    subject { object.new(header) }
+
+    it { should be_instance_of(object) }
+
+    its(:header) { should be(header) }
+
+    its(:directions) { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
+
+    it { should be_empty }
+  end
 end

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

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Relation::Materialized, '#directions' do
   subject { object.directions }
 
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:tuples) { LazyEnumerable.new                            }
+  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] ]                                 }
+    let(:directions) { [header[:id]]                                   }
 
     it_should_behave_like 'an idempotent method'
 
@@ -22,6 +22,6 @@ describe Relation::Materialized, '#directions' do
 
     it_should_behave_like 'an idempotent method'
 
-    it { should equal(Relation::Operation::Order::DirectionSet::EMPTY) }
+    it { should be(Relation::Operation::Order::DirectionSet::EMPTY) }
   end
 end

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

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

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

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