axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/relation/operation/order/descending/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Relation::Operation::Order::Descending, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Relation::Operation::Order::Ascending) }
+  it { should be(Relation::Operation::Order::Ascending) }
 end

data/spec/unit/axiom/relation/operation/order/descending/reverse_spec.rb

@@ -10,5 +10,5 @@ describe Relation::Operation::Order::Descending, '#reverse' do
 
   it { should be_instance_of(Relation::Operation::Order::Ascending) }
 
-  its(:attribute) { should equal(attribute) }
+  its(:attribute) { should be(attribute) }
 end

data/spec/unit/axiom/relation/operation/order/direction/attribute_spec.rb

@@ -9,5 +9,5 @@ describe Relation::Operation::Order::Direction, '#attribute' do
   let(:attribute)       { Attribute::Integer.new(:id)                      }
   let(:object)          { described_class.new(attribute)                   }
 
-  it { should equal(attribute) }
+  it { should be(attribute) }
 end

data/spec/unit/axiom/relation/operation/order/direction/call_spec.rb

@@ -6,14 +6,14 @@ describe Relation::Operation::Order::Direction, '#call' do
   subject { object.call(left, right) }
 
   let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
-  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ])    }
-  let(:left)            { Tuple.new(header, [ 1 ])                         }
-  let(:right)           { Tuple.new(header, [ 2 ])                         }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]])        }
+  let(:left)            { Tuple.new(header, [1])                           }
+  let(:right)           { Tuple.new(header, [2])                           }
   let(:object)          { described_class.new(header[:id])                 }
 
   it 'sends the tuple value to self.class.call' do
-    response = mock('#call response')
+    response = double('#call response')
     described_class.should_receive(:call).with(1, 2).and_return(response)
-    should equal(response)
+    should be(response)
   end
 end

data/spec/unit/axiom/relation/operation/order/direction/class_methods/coerce_spec.rb

@@ -11,7 +11,7 @@ describe Relation::Operation::Order::Direction, '.coerce' do
   context 'when the argument is a Direction' do
     let(:argument) { Relation::Operation::Order::Ascending.new(attribute) }
 
-    it { should equal(argument) }
+    it { should be(argument) }
   end
 
   context 'when the argument is an Attribute' do
@@ -19,11 +19,11 @@ describe Relation::Operation::Order::Direction, '.coerce' do
 
     it { should be_instance_of(object) }
 
-    its(:attribute) { should equal(attribute) }
+    its(:attribute) { should be(attribute) }
   end
 
   context 'when the argument is an Array' do
-    let(:argument) { [ :id, Integer ] }
+    let(:argument) { [:id, Integer] }
 
     it { should be_instance_of(object) }
 

data/spec/unit/axiom/relation/operation/order/direction/eql_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :eql?, :== ].each do |method|
+[:eql?, :==].each do |method|
   describe Relation::Operation::Order::Direction, "##{method}" do
     subject { object.send(method, other) }
 

data/spec/unit/axiom/relation/operation/order/direction/name_spec.rb

@@ -9,5 +9,5 @@ describe Relation::Operation::Order::Direction, '#name' do
   let(:attribute)       { Attribute::Integer.new(:id)                      }
   let(:object)          { described_class.new(attribute)                   }
 
-  it { should equal(:id) }
+  it { should be(:id) }
 end

data/spec/unit/axiom/relation/operation/order/direction/rename_spec.rb

@@ -7,11 +7,11 @@ describe Relation::Operation::Order::Direction, '#rename' do
 
   let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
   let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:header)          { Relation::Header.new([ attribute ])              }
+  let(:header)          { Relation::Header.new([attribute])                }
   let(:object)          { described_class.new(attribute)                   }
 
   context 'with aliases matching the attribute' do
-    let(:aliases) { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
+    let(:aliases) { Algebra::Rename::Aliases.coerce(header, id: :other_id) }
 
     it { should be_instance_of(described_class) }
 
@@ -19,10 +19,10 @@ describe Relation::Operation::Order::Direction, '#rename' do
   end
 
   context 'with aliases not matching the attribute' do
-    let(:other_attribute) { Attribute::String.new(:name)                                        }
-    let(:other_header)    { Relation::Header.new([ other_attribute ])                           }
-    let(:aliases)         { Algebra::Rename::Aliases.coerce(other_header, :name => :other_name) }
+    let(:other_attribute) { Attribute::String.new(:name)                                     }
+    let(:other_header)    { Relation::Header.new([other_attribute])                          }
+    let(:aliases)         { Algebra::Rename::Aliases.coerce(other_header, name: :other_name) }
 
-    it { should equal(object) }
+    it { should be(object) }
   end
 end

data/spec/unit/axiom/relation/operation/order/direction/reverse_spec.rb

@@ -7,12 +7,12 @@ describe Relation::Operation::Order::Direction, '#reverse' do
 
   let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
   let(:attribute)       { Attribute::Integer.new(:id)                      }
-  let(:reverse_class)   { mock('Reverse Class', :new => reverse)           }
-  let(:reverse)         { mock('Reverse Instance')                         }
+  let(:reverse_class)   { double('Reverse Class', new: reverse)            }
+  let(:reverse)         { double('Reverse Instance')                       }
   let(:object)          { described_class.new(attribute)                   }
 
   before do
-    described_class.stub(:reverse => reverse_class)
+    described_class.stub(reverse: reverse_class)
   end
 
   it 'calls .reverse on the class' do
@@ -25,5 +25,5 @@ describe Relation::Operation::Order::Direction, '#reverse' do
     subject
   end
 
-  it { should equal(reverse) }
+  it { should be(reverse) }
 end

data/spec/unit/axiom/relation/operation/order/direction_set/attributes_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#attributes' do
   subject { object.attributes }
 
-  let(:attribute) { Attribute::Integer.new(:id)           }
-  let(:object)    { described_class.coerce([ attribute ]) }
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:object)    { described_class.coerce([attribute]) }
 
   it { should be_instance_of(Array) }
 
-  it { should == [ attribute ] }
+  it { should == [attribute] }
 end

data/spec/unit/axiom/relation/operation/order/direction_set/class_methods/coerce_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '.coerce' do
   subject { object.coerce(argument) }
 
-  let(:object)        { described_class               }
-  let(:direction_set) { object.new([ attribute.asc ]) }
-  let(:array)         { [ [ :id, Integer ] ]          }
-  let(:attribute)     { Attribute::Integer.new(:id)   }
+  let(:object)        { described_class             }
+  let(:direction_set) { object.new([attribute.asc]) }
+  let(:array)         { [[:id, Integer]]            }
+  let(:attribute)     { Attribute::Integer.new(:id) }
 
   context 'with a block' do
     subject { object.coerce(argument, &block) }
@@ -17,23 +17,23 @@ describe Relation::Operation::Order::DirectionSet, '.coerce' do
       let(:argument) { direction_set                     }
       let(:block)    { proc { raise 'should not raise' } }
 
-      it { should equal(direction_set) }
+      it { should be(direction_set) }
     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(:block) { ->(attribute) { other }        }
         let(:other) { Attribute::String.new(:id).asc }
 
         it { should be_instance_of(object) }
 
-        it { should eql(object.new([ other ])) }
+        it { should eql(object.new([other])) }
       end
 
       context 'and the block does not match another attribute' do
-        let(:block) { lambda { |attribute| nil } }
+        let(:block) { ->(attribute) { nil } }
 
         it { should be_instance_of(object) }
 
@@ -42,8 +42,8 @@ describe Relation::Operation::Order::DirectionSet, '.coerce' do
     end
 
     context 'when the argument is not a DirectionSet and does not respond to #to_ary' do
-      let(:argument) { Object.new                 }
-      let(:block)    { lambda { |attribute| nil } }
+      let(:argument) { Object.new            }
+      let(:block)    { ->(attribute) { nil } }
 
       specify { expect { subject }.to raise_error(NoMethodError) }
     end
@@ -55,7 +55,7 @@ describe Relation::Operation::Order::DirectionSet, '.coerce' do
     context 'when the argument is a DirectionSet' do
       let(:argument) { direction_set }
 
-      it { should equal(direction_set) }
+      it { should be(direction_set) }
     end
 
     context 'when the argument responds to #to_ary' do

data/spec/unit/axiom/relation/operation/order/direction_set/class_methods/new_spec.rb

@@ -11,7 +11,7 @@ describe Relation::Operation::Order::DirectionSet, '.new' do
   let(:object) { described_class                  }
 
   context 'with an argument that responds to #to_ary and do not contain duplicates' do
-    let(:argument) { [ id, name ] }
+    let(:argument) { [id, name] }
 
     it { should be_instance_of(object) }
 
@@ -19,7 +19,7 @@ describe Relation::Operation::Order::DirectionSet, '.new' do
   end
 
   context 'with an argument that responds to #to_ary and contain duplicates' do
-    let(:argument) { [ id, id, name, name, age ] }
+    let(:argument) { [id, id, name, name, age] }
 
     specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: [:id, :name]') }
   end

data/spec/unit/axiom/relation/operation/order/direction_set/eql_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:attributes) { [ Attribute::Integer.new(:id) ]    }
+  let(:attributes) { [Attribute::Integer.new(:id)]      }
   let(:object)     { described_class.coerce(attributes) }
 
   context 'with the same object' do
@@ -39,7 +39,7 @@ describe Relation::Operation::Order::DirectionSet, '#eql?' do
   end
 
   context 'with an object having different attributes' do
-    let(:other_attributes) { [ Attribute::Integer.new(:other_id) ] }
+    let(:other_attributes) { [Attribute::Integer.new(:other_id)]   }
     let(:other)            { described_class.new(other_attributes) }
 
     it { should be(false) }

data/spec/unit/axiom/relation/operation/order/direction_set/equality_operator_spec.rb

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

data/spec/unit/axiom/relation/operation/order/direction_set/hash_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Order::DirectionSet, '#hash' do
   subject { object.hash }
 
   let(:attribute)  { Attribute::Integer.new(:id)     }
-  let(:directions) { [ attribute.asc ]               }
+  let(:directions) { [attribute.asc]                 }
   let(:object)     { described_class.new(directions) }
 
   it_should_behave_like 'a hash method'

data/spec/unit/axiom/relation/operation/order/direction_set/project_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#project' do
   subject { object.project(attributes) }
 
-  let(:header)     { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:attributes) { [ header[:id] ]                                                  }
-  let(:object)     { described_class.coerce(header)                                   }
+  let(:header)     { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:attributes) { [header[:id]]                                              }
+  let(:object)     { described_class.coerce(header)                             }
 
-  it { should_not equal(object) }
+  it { should_not be(object) }
 
   it { should be_instance_of(described_class) }
 
-  it { should == [ header[:id] ] }
+  it { should == [header[:id]] }
 end

data/spec/unit/axiom/relation/operation/order/direction_set/rename_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:attribute) { Attribute::Integer.new(:id)                               }
-  let(:header)    { Relation::Header.new([ attribute ])                       }
-  let(:aliases)   { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
-  let(:object)    { described_class.coerce([ attribute ])                     }
+  let(:attribute) { Attribute::Integer.new(:id)                            }
+  let(:header)    { Relation::Header.new([attribute])                      }
+  let(:aliases)   { Algebra::Rename::Aliases.coerce(header, id: :other_id) }
+  let(:object)    { described_class.coerce([attribute])                    }
 
-  it { should_not equal(object) }
+  it { should_not be(object) }
 
   it { should be_instance_of(described_class) }
 
-  it { should == [ Attribute::Integer.new(:other_id) ] }
+  it { should == [Attribute::Integer.new(:other_id)] }
 end

data/spec/unit/axiom/relation/operation/order/direction_set/reverse_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#reverse' do
   subject { object.reverse }
 
-  let(:attribute1) { Attribute::Integer.new(:id)                        }
-  let(:attribute2) { Attribute::String.new(:name)                       }
-  let(:object)     { described_class.coerce([ attribute1, attribute2 ]) }
+  let(:attribute1) { Attribute::Integer.new(:id)                      }
+  let(:attribute2) { Attribute::String.new(:name)                     }
+  let(:object)     { described_class.coerce([attribute1, attribute2]) }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(described_class) }
 
   it 'reverses each direction' do
-    should == [ attribute1.desc, attribute2.desc ]
+    should == [attribute1.desc, attribute2.desc]
   end
 
   it 'does not reverse the attribute order' do
-    subject.attributes.should eql([ attribute1, attribute2 ])
+    subject.attributes.should eql([attribute1, attribute2])
   end
 end

data/spec/unit/axiom/relation/operation/order/direction_set/sort_tuples_spec.rb

@@ -5,40 +5,40 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#sort_tuples' do
   subject { object.sort_tuples(relation) }
 
-  let(:header)   { [ [ :id, Integer ], [ :name, String ] ]                      }
-  let(:body)     { [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ] ] }
-  let(:relation) { Relation.new(header, body)                                   }
-  let(:object)   { described_class.new(header)                                  }
+  let(:header)   { [[:id, Integer], [:name, String]]                    }
+  let(:body)     { [[1, 'Dan Kubb'], [2, 'Alex Kubb'], [2, 'Dan Kubb']] }
+  let(:relation) { Relation.new(header, body)                           }
+  let(:object)   { described_class.new(header)                          }
 
   context 'sorted with ascending id and descending name' do
-    let(:object) { described_class.new([ relation[:id].asc, relation[:name].desc ]) }
+    let(:object) { described_class.new([relation[:id].asc, relation[:name].desc]) }
 
     it { should be_instance_of(Array) }
 
-    it { should == [ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ] }
+    it { should == [[1, 'Dan Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']] }
   end
 
   context 'sorted with ascending id and ascending name' do
-    let(:object) { described_class.new([ relation[:id].asc, relation[:name].asc ]) }
+    let(:object) { described_class.new([relation[:id].asc, relation[:name].asc]) }
 
     it { should be_instance_of(Array) }
 
-    it { should == [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ] ] }
+    it { should == [[1, 'Dan Kubb'], [2, 'Alex Kubb'], [2, 'Dan Kubb']] }
   end
 
   context 'sorted with descending id and ascending name' do
-    let(:object) { described_class.new([ relation[:id].desc, relation[:name].asc ]) }
+    let(:object) { described_class.new([relation[:id].desc, relation[:name].asc]) }
 
     it { should be_instance_of(Array) }
 
-    it { should == [ [ 2, 'Alex Kubb' ], [ 2, 'Dan Kubb' ], [ 1, 'Dan Kubb' ] ] }
+    it { should == [[2, 'Alex Kubb'], [2, 'Dan Kubb'], [1, 'Dan Kubb']] }
   end
 
   context 'sorted with descending id and descending name' do
-    let(:object) { described_class.new([ relation[:id].desc, relation[:name].desc ]) }
+    let(:object) { described_class.new([relation[:id].desc, relation[:name].desc]) }
 
     it { should be_instance_of(Array) }
 
-    it { should == [ [ 2, 'Dan Kubb' ], [ 2, 'Alex Kubb' ], [ 1, 'Dan Kubb' ] ] }
+    it { should == [[2, 'Dan Kubb'], [2, 'Alex Kubb'], [1, 'Dan Kubb']] }
   end
 end

data/spec/unit/axiom/relation/operation/order/direction_set/to_ary_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '#to_ary' do
   subject { object.to_ary }
 
-  let(:attribute) { Attribute::Integer.new(:id)           }
-  let(:object)    { described_class.coerce([ attribute ]) }
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:object)    { described_class.coerce([attribute]) }
 
   it { should be_instance_of(Array) }
 
-  it { should == [ attribute.asc ] }
+  it { should == [attribute.asc] }
 end

data/spec/unit/axiom/relation/operation/order/directions_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation::Operation::Order, '#directions' do
   subject { object.directions }
 
-  let(:relation)   { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:directions) { described_class::DirectionSet.coerce(relation.header)  }
-  let(:object)     { described_class.new(relation, directions)              }
+  let(:relation)   { Relation.new([[:id, Integer]], LazyEnumerable.new)    }
+  let(:directions) { described_class::DirectionSet.coerce(relation.header) }
+  let(:object)     { described_class.new(relation, directions)             }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(directions) }
+  it { should eql(directions) }
 end