axiom 0.1.0 → 0.1.1

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

@@ -5,9 +5,9 @@ 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)    { []                                 }
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:object)    { described_class.new([attribute]) }
+  let(:yields)    { []                               }
 
   it_should_behave_like 'an #each method'
 
@@ -17,9 +17,9 @@ describe Relation::Header, '#each' do
   end
 
   it 'yields each attribute' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ attribute ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([attribute])
   end
 end
 

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

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

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Header, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:attributes) { [ [ :id, Integer ] ]               }
+  let(:attributes) { [[:id, Integer]]                   }
   let(:object)     { described_class.coerce(attributes) }
 
   context 'with the same object' do
@@ -39,7 +39,7 @@ describe Relation::Header, '#eql?' do
   end
 
   context 'with an object having different attributes' do
-    let(:other_attributes) { [ [ :name, String ] ]                    }
+    let(:other_attributes) { [[:name, String]]                        }
     let(:other)            { described_class.coerce(other_attributes) }
 
     it { should be(false) }
@@ -50,10 +50,10 @@ describe Relation::Header, '#eql?' do
   end
 
   context 'with an object having equivalent attributes in a different order' do
-    let(:attribute1) { [ :id,   Integer ]                                 }
-    let(:attribute2) { [ :name, String  ]                                 }
-    let(:object)     { described_class.coerce([ attribute1, attribute2 ]) }
-    let(:other)      { described_class.coerce([ attribute2, attribute1 ]) }
+    let(:attribute1) { [:id,   Integer]                                 }
+    let(:attribute2) { [:name, String]                                  }
+    let(:object)     { described_class.coerce([attribute1, attribute2]) }
+    let(:other)      { described_class.coerce([attribute2, attribute1]) }
 
     it { should be(true) }
 

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Header, '#==' do
   subject { object == other }
 
-  let(:attributes) { [ [ :id, Integer ] ]               }
+  let(:attributes) { [[:id, Integer]]                   }
   let(:object)     { described_class.coerce(attributes) }
 
   context 'with the same object' do
@@ -39,7 +39,7 @@ describe Relation::Header, '#==' do
   end
 
   context 'with an object having different attributes' do
-    let(:other_attributes) { [ [ :name, String ] ]                    }
+    let(:other_attributes) { [[:name, String]]                        }
     let(:other)            { described_class.coerce(other_attributes) }
 
     it { should be(false) }
@@ -50,10 +50,10 @@ describe Relation::Header, '#==' do
   end
 
   context 'with an object having equivalent attributes in a different order' do
-    let(:attribute1) { [ :id,   Integer ]                                 }
-    let(:attribute2) { [ :name, String  ]                                 }
-    let(:object)     { described_class.coerce([ attribute1, attribute2 ]) }
-    let(:other)      { described_class.coerce([ attribute2, attribute1 ]) }
+    let(:attribute1) { [:id,   Integer]                                 }
+    let(:attribute2) { [:name, String]                                  }
+    let(:object)     { described_class.coerce([attribute1, attribute2]) }
+    let(:other)      { described_class.coerce([attribute2, attribute1]) }
 
     it { should be(true) }
 
@@ -73,7 +73,7 @@ describe Relation::Header, '#==' do
   end
 
   context 'with an equivalent object with no type responding to #to_ary' do
-    let(:other) { [ :id ] }
+    let(:other) { [:id] }
 
     it { should be(true) }
 
@@ -83,7 +83,7 @@ describe Relation::Header, '#==' do
   end
 
   context 'with a different object responding to #to_ary' do
-    let(:other) { [ [ :name, String ] ] }
+    let(:other) { [[:name, String]] }
 
     it { should be(false) }
 

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

@@ -5,31 +5,31 @@ require 'spec_helper'
 describe Relation::Header, '#extend' do
   subject { object.extend(attributes) }
 
-  let(:object) { described_class.coerce([ [ :id, Integer ] ], :keys => keys) }
-  let(:keys)   { Relation::Keys.new([ described_class.new ])                 }
+  let(:object) { described_class.coerce([[:id, Integer]], keys: keys) }
+  let(:keys)   { Relation::Keys.new([described_class.new])            }
 
   context 'with attribute objects' do
-    let(:attributes) { [ attribute ]                }
+    let(:attributes) { [attribute]                  }
     let(:attribute)  { Attribute::String.new(:name) }
 
     it { should be_instance_of(described_class) }
 
     it 'uses the attribute object' do
-      subject[:name].should equal(attribute)
+      subject[:name].should be(attribute)
     end
 
-    its(:to_ary) { should == [ [ :id, Integer ], [ :name, String ] ] }
+    its(:to_ary) { should == [[:id, Integer], [:name, String]] }
 
-    its(:keys) { should equal(keys) }
+    its(:keys) { should be(keys) }
   end
 
   context 'with Symbol attributes' do
-    let(:attributes) { [ :name ] }
+    let(:attributes) { [:name] }
 
     it { should be_instance_of(described_class) }
 
-    its(:to_ary) { should == [ [ :id, Integer ], [ :name, Object ] ] }
+    its(:to_ary) { should == [[:id, Integer], [:name, Object]] }
 
-    its(:keys) { should equal(keys) }
+    its(:keys) { should be(keys) }
   end
 end

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Header, '#hash' do
   subject { object.hash }
 
-  let(:object)    { described_class.new([ attribute ], :keys => keys) }
-  let(:attribute) { Attribute::Integer.new(:id)                       }
-  let(:keys)      { Relation::Keys.new                                }
+  let(:object)    { described_class.new([attribute], keys: keys) }
+  let(:attribute) { Attribute::Integer.new(:id)                  }
+  let(:keys)      { Relation::Keys.new                           }
 
   it_should_behave_like 'a hash method'
 

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

@@ -2,17 +2,17 @@
 
 require 'spec_helper'
 
-[ :intersect, :& ].each do |method|
+[:intersect, :&].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(:attributes)       { [[:id, Integer], [:name, String]]                       }
     let(:other_attributes) { attributes                                              }
     let(:options)          { {}                                                      }
     let(:other_options)    { options                                                 }
-    let(:keys)             { Relation::Keys.coerce([ [ [ :id, Integer ] ] ])         }
+    let(:keys)             { Relation::Keys.coerce([[[:id, Integer]]])               }
     let(:other_keys)       { keys                                                    }
 
     context 'when the attributes are equivalent' do
@@ -24,7 +24,7 @@ require 'spec_helper'
     end
 
     context 'when the attributes intersect' do
-      let(:other_attributes) { [ [ :id, Integer ] ] }
+      let(:other_attributes) { [[:id, Integer]] }
 
       it { should be_instance_of(described_class) }
 
@@ -34,7 +34,7 @@ require 'spec_helper'
     end
 
     context 'when the attributes do not intersect' do
-      let(:other_attributes) { [ [ :age, Integer ] ] }
+      let(:other_attributes) { [[:age, Integer]] }
 
       it { should be_instance_of(described_class) }
 
@@ -44,8 +44,8 @@ require 'spec_helper'
     end
 
     context 'when the keys are equivalent' do
-      let(:other_attributes) { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
-      let(:options)          { { :keys => keys }                                          }
+      let(:other_attributes) { [[:id, Integer], [:name, String], [:age, Integer]] }
+      let(:options)          { { keys: keys }                                     }
 
       it { should be_instance_of(described_class) }
 
@@ -55,38 +55,38 @@ require 'spec_helper'
     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_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 ] ],
-         ])
+          [[:id,  Integer]],
+          [[:age, Integer]],
+        ])
       end
 
       it { should be_instance_of(described_class) }
 
       its(:to_ary) { should == attributes }
 
-      its(:keys) { should == [ [ [ :id, Integer ] ] ] }
+      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_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 ] ] ])
+        Relation::Keys.coerce([[[:name, String], [:age, Integer]]])
       end
 
       it { should be_instance_of(described_class) }
 
       its(:to_ary) { should == attributes }
 
-      its(:keys) { should == [ [ [ :id, Integer ] ], [ [ :name, String ] ] ] }
+      its(:keys) { should == [[[:id, Integer]], [[:name, String]]] }
     end
 
     context 'when the other can be coerced into a Header' do

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

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe Relation::Header, '#keys' do
   subject { object.keys }
 
-  let(:attributes) { [ [ :id, Integer ], [ :name, String ] ] }
-  let(:keys_class) { Relation::Keys                          }
+  let(:attributes) { [[:id, Integer], [:name, String]] }
+  let(:keys_class) { Relation::Keys                    }
 
   context 'with explicit keys' do
-    let(:object) { described_class.coerce(attributes, :keys => keys) }
-    let(:keys)   { [ [ :id ] ]                                       }
+    let(:object) { described_class.coerce(attributes, keys: keys) }
+    let(:keys)   { [[:id]]                                        }
 
     it { should be_instance_of(keys_class) }
 
     it 'has a set of keys' do
-      should == keys_class.new([ described_class.new([ object[:id] ]) ])
+      should == keys_class.new([described_class.new([object[:id]])])
     end
 
     it { should be_frozen }

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

@@ -5,41 +5,41 @@ require 'spec_helper'
 describe Relation::Header, '#project' do
   subject { object.project(attributes) }
 
-  let(:object) { described_class.coerce([ [ :id, Integer ], [ :name, String ] ], :keys => keys)          }
-  let(:keys)   { Relation::Keys.new([ described_class.coerce([ [ :id, Integer ], [ :name, String ] ]) ]) }
+  let(:object) { described_class.coerce([[:id, Integer], [:name, String]], keys: keys)           }
+  let(:keys)   { Relation::Keys.new([described_class.coerce([[:id, Integer], [:name, String]])]) }
 
   context 'with attribute objects' do
-    let(:attributes) { [ attribute ]               }
+    let(:attributes) { [attribute]                 }
     let(:attribute)  { Attribute::Integer.new(:id) }
 
     it { should be_instance_of(described_class) }
 
     it 'uses the attribute object' do
-      subject[:id].should equal(attribute)
+      subject[:id].should be(attribute)
     end
 
-    its(:to_ary) { should == [ [ :id, Integer ] ] }
+    its(:to_ary) { should == [[:id, Integer]] }
 
-    its(:keys) { should eql(Relation::Keys.new([ described_class.coerce([ [ :id, Integer ] ]) ])) }
+    its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:id, Integer]])])) }
   end
 
   context 'with Symbol attributes' do
-    let(:attributes) { [ :id ] }
+    let(:attributes) { [:id] }
 
     it { should be_instance_of(described_class) }
 
-    its(:to_ary) { should == [ [ :id, Integer ] ] }
+    its(:to_ary) { should == [[:id, Integer]] }
 
-    its(:keys) { should eql(Relation::Keys.new([ described_class.coerce([ [ :id, Integer ] ]) ])) }
+    its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:id, Integer]])])) }
   end
 
   context 'when the header has no keys' do
     let(:keys)       { Relation::Keys.new }
-    let(:attributes) { [ :id ]            }
+    let(:attributes) { [:id]              }
 
     it { should be_instance_of(described_class) }
 
-    its(:to_ary) { should == [ [ :id, Integer ] ] }
+    its(:to_ary) { should == [[:id, Integer]] }
 
     its(:keys) { should be_empty }
   end

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

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Relation::Header, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:object)  { described_class.coerce([ [ :id, Integer ], [ :name, String ] ], :keys => keys) }
-  let(:aliases) { Algebra::Rename::Aliases.coerce(object, :id => :other_id)                      }
-  let(:keys)    { Relation::Keys.new([ described_class.coerce([ [ :id, Integer ] ]) ])           }
+  let(:object)  { described_class.coerce([[:id, Integer], [:name, String]], keys: keys) }
+  let(:aliases) { Algebra::Rename::Aliases.coerce(object, id: :other_id)                }
+  let(:keys)    { Relation::Keys.new([described_class.coerce([[:id, Integer]])])        }
 
   it { should be_instance_of(described_class) }
 
-  it { should_not equal(object) }
+  it { should_not be(object) }
 
-  its(:to_ary) { should == [ [ :other_id, Integer ], [ :name, String ] ] }
+  its(:to_ary) { should == [[:other_id, Integer], [:name, String]] }
 
-  its(:keys) { should eql(Relation::Keys.new([ described_class.coerce([ [ :other_id, Integer ] ]) ])) }
+  its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:other_id, Integer]])])) }
 end

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

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

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

@@ -2,17 +2,17 @@
 
 require 'spec_helper'
 
-[ :union, :| ].each do |method|
+[: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(:attributes)       { [[:id, Integer], [:name, String]]                       }
     let(:other_attributes) { attributes                                              }
     let(:options)          { {}                                                      }
     let(:other_options)    { options                                                 }
-    let(:keys)             { Relation::Keys.coerce([ [ [ :id, Integer ] ] ])         }
+    let(:keys)             { Relation::Keys.coerce([[[:id, Integer]]])               }
     let(:other_keys)       { keys                                                    }
 
     context 'when the attributes are equivalent' do
@@ -24,28 +24,28 @@ require 'spec_helper'
     end
 
     context 'when the attributes intersect' do
-      let(:other_attributes) { [ [ :id, Integer ] ] }
+      let(:other_attributes) { [[:id, Integer]] }
 
       it { should be_instance_of(described_class) }
 
-      its(:to_ary) { should == [ [ :id, Integer ], [ :name, String ] ] }
+      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 ] ] }
+      let(:other_attributes) { [[:age, Integer]] }
 
       it { should be_instance_of(described_class) }
 
-      its(:to_ary) { should == [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
+      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 }                                          }
+      let(:other_attributes) { [[:id, Integer], [:name, String], [:age, Integer]] }
+      let(:options)          { { keys: keys }                                     }
 
       it { should be_instance_of(described_class) }
 
@@ -55,31 +55,31 @@ require 'spec_helper'
     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_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 ] ],
-         ])
+          [[:id,  Integer]],
+          [[:age, Integer]],
+        ])
       end
 
       it { should be_instance_of(described_class) }
 
       its(:to_ary) { should == other_attributes }
 
-      its(:keys) { should == [ [ [ :id, Integer ] ] ] }
+      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_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 ] ] ])
+        Relation::Keys.coerce([[[:name, String], [:age, Integer]]])
       end
 
       it { should be_instance_of(described_class) }