axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/algebra/restriction/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Restriction, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:predicate) { proc { true }                                 }
-  let(:object)    { described_class.new(operand, predicate)       }
+  let(:operand)   { Relation.new([[:id, Integer]], [[1]])   }
+  let(:predicate) { proc { true }                           }
+  let(:object)    { described_class.new(operand, predicate) }
 
   context 'with the same object' do
     let(:other) { object }
@@ -40,7 +40,7 @@ describe Algebra::Restriction, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand)   { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ])       }
+    let(:other_operand)   { Relation.new([[:id, Integer]], [[2]])               }
     let(:other_predicate) { predicate                                           }
     let(:other)           { described_class.new(other_operand, other_predicate) }
 

data/spec/unit/axiom/algebra/restriction/hash_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Restriction, '#hash' do
   subject { object.hash }
 
-  let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:predicate) { proc { true }                                 }
-  let(:object)    { described_class.new(operand, predicate)       }
+  let(:operand)   { Relation.new([[:id, Integer]], [[1]])   }
+  let(:predicate) { proc { true }                           }
+  let(:object)    { described_class.new(operand, predicate) }
 
   it_should_behave_like 'a hash method'
 

data/spec/unit/axiom/algebra/restriction/insert_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Restriction, '#insert' do
   subject { object.insert(other) }
 
-  let(:object)         { described_class.new(operand, predicate)                           }
-  let(:operand)        { Relation.new([ attribute ], LazyEnumerable.new([ [ 1 ] ]))        }
-  let(:other_relation) { Relation.new([ attribute ], LazyEnumerable.new([ [ 0 ], [ 2 ] ])) }
-  let(:attribute)      { Attribute::Integer.new(:id)                                       }
-  let(:predicate)      { attribute.gte(1)                                                  }
+  let(:object)         { described_class.new(operand, predicate)                   }
+  let(:operand)        { Relation.new([attribute], LazyEnumerable.new([[1]]))      }
+  let(:other_relation) { Relation.new([attribute], LazyEnumerable.new([[0], [2]])) }
+  let(:attribute)      { Attribute::Integer.new(:id)                               }
+  let(:predicate)      { attribute.gte(1)                                          }
 
   shared_examples_for 'Algebra::Restrict#insert' do
     it { should be_instance_of(described_class) }
@@ -18,15 +18,15 @@ describe Algebra::Restriction, '#insert' do
 
     it 'passes expected relations into the insertion' do
       subject = self.subject.operand
-      subject.left.should equal(operand)
+      subject.left.should be(operand)
       subject.right.should be_kind_of(described_class)
-      subject.right.predicate.should equal(predicate)
+      subject.right.predicate.should be(predicate)
     end
 
-    its(:predicate) { should equal(predicate) }
+    its(:predicate) { should be(predicate) }
 
     it 'filters out tuples from the other relation not matching the predicate' do
-      should == [ [ 1 ], [ 2 ] ]
+      should == [[1], [2]]
     end
   end
 

data/spec/unit/axiom/algebra/restriction/methods/restrict_spec.rb

@@ -3,11 +3,11 @@
 require 'spec_helper'
 
 describe Algebra::Restriction::Methods, '#restrict' do
-  let(:object)          { described_class.new(header, body)                             }
-  let(:header)          { [ [ :id, Integer ], [ :name, String ] ]                       }
-  let(:body)            { LazyEnumerable.new([ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ]) }
-  let(:described_class) { Relation                                                      }
-  let(:tautology)       { Function::Proposition::Tautology.instance                     }
+  let(:object)          { described_class.new(header, body)                       }
+  let(:header)          { [[:id, Integer], [:name, String]]                       }
+  let(:body)            { LazyEnumerable.new([[1, 'Dan Kubb'], [2, 'Alex Kubb']]) }
+  let(:described_class) { Relation                                                }
+  let(:tautology)       { Function::Proposition::Tautology.instance               }
 
   context 'with a predicate' do
     subject { object.restrict(predicate) }
@@ -17,7 +17,7 @@ describe Algebra::Restriction::Methods, '#restrict' do
     it { should be_instance_of(Algebra::Restriction) }
 
     it 'sets the predicate' do
-      subject.predicate.should equal(predicate)
+      subject.predicate.should be(predicate)
     end
 
     it 'behaves the same as Enumerable#select' do
@@ -44,26 +44,23 @@ describe Algebra::Restriction::Methods, '#restrict' do
   context 'with a Hash' do
     subject { object.restrict(predicate) }
 
-    let(:predicate) { { :id => 1, :name => 'Dan Kubb' } }
+    let(:predicate) { { id: 1, name: 'Dan Kubb' } }
 
     it { should be_instance_of(Algebra::Restriction) }
 
-    # Hash order is not guaranteed except under 1.9+
-    if RUBY_VERSION >= '1.9'
-      it 'sets the predicate' do
-        subject.predicate.should eql(tautology.and(object[:id].eq(1).and(object[:name].eq('Dan Kubb'))))
-      end
+    it 'sets the predicate' do
+      subject.predicate.should eql(tautology.and(object[:id].eq(1).and(object[:name].eq('Dan Kubb'))))
     end
 
     it 'behaves the same as Enumerable#select' do
-      should == object.select { |tuple| tuple[:id] == 1 and tuple[:name] == 'Dan Kubb' }
+      should == object.select { |tuple| tuple[:id] == 1 && tuple[:name] == 'Dan Kubb' }
     end
   end
 
   context 'with an Array' do
     subject { object.restrict(predicate) }
 
-    let(:predicate) { [ [ :id, 1 ], [ :name, 'Dan Kubb' ] ] }
+    let(:predicate) { [[:id, 1], [:name, 'Dan Kubb']] }
 
     it { should be_instance_of(Algebra::Restriction) }
 
@@ -72,7 +69,7 @@ describe Algebra::Restriction::Methods, '#restrict' do
     end
 
     it 'behaves the same as Enumerable#select' do
-      should == object.select { |tuple| tuple[:id] == 1 and tuple[:name] == 'Dan Kubb' }
+      should == object.select { |tuple| tuple[:id] == 1 && tuple[:name] == 'Dan Kubb' }
     end
   end
 end

data/spec/unit/axiom/algebra/restriction/predicate_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Restriction, '#predicate' do
   subject { object.predicate }
 
-  let(:relation)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:predicate) { relation[:id].ne(0)                           }
-  let(:object)    { described_class.new(relation, predicate)      }
+  let(:relation)  { Relation.new([[:id, Integer]], [[1]])    }
+  let(:predicate) { relation[:id].ne(0)                      }
+  let(:object)    { described_class.new(relation, predicate) }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(predicate) }
+  it { should be(predicate) }
 end

data/spec/unit/axiom/algebra/summarization/class_methods/new_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Summarization, '.new' do
   subject { object.new(operand, summarize_per, summarizers) }
 
-  let(:header)      { [ [ :id, Integer ], [ :name, String ] ]                        }
-  let(:operand)     { Relation.new(header, [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]) }
-  let(:summarizers) { {}                                                             }
-  let(:object)      { described_class                                                }
+  let(:header)      { [[:id, Integer], [:name, String]]                        }
+  let(:operand)     { Relation.new(header, [[1, 'John Doe'], [2, 'Jane Doe']]) }
+  let(:summarizers) { {}                                                       }
+  let(:object)      { described_class                                          }
 
   context 'with a summarize_per that has a subset of the headers in the operand' do
-    let(:summarize_per) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+    let(:summarize_per) { Relation.new([[:id, Integer]], [[1], [2]]) }
 
     it { should be_instance_of(object) }
   end
@@ -23,7 +23,7 @@ describe Algebra::Summarization, '.new' do
   end
 
   context 'with a summarize_per that has a superset of the headers in the operand' do
-    let(:summarize_per) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+    let(:summarize_per) { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']]) }
 
     specify { expect { subject }.to raise_error(InvalidHeaderError, 'the summarize_per header must be a proper subset of the operand header') }
   end

data/spec/unit/axiom/algebra/summarization/delete_spec.rb

@@ -6,10 +6,10 @@ describe Algebra::Summarization, '#delete' do
   subject { object.delete(other) }
 
   let(:object)       { described_class.new(operand, summarize_by, summarizers) }
-  let(:other)        { stub('other')                                           }
-  let(:operand)      { Relation.new([ [ :id, Integer ] ], [])                  }
+  let(:other)        { double('other')                                         }
+  let(:operand)      { Relation.new([[:id, Integer]], [])                      }
   let(:summarize_by) { operand.project([])                                     }
-  let(:summarizers)  { { :test => 1 }                                          }
+  let(:summarizers)  { { test: 1 }                                             }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'deleting from a summarization is impossible') }
 end

data/spec/unit/axiom/algebra/summarization/each_spec.rb

@@ -6,8 +6,8 @@ describe Algebra::Summarization, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:object)      { described_class.new(operand, operand.project([]), summarizers) }
-  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])           }
-  let(:summarizers) { { :count => lambda { |acc, tuple| acc.to_i + 1 } }             }
+  let(:operand)     { Relation.new([[:id, Integer]], [[1], [2]])                     }
+  let(:summarizers) { { count: ->(acc, tuple) { acc.to_i + 1 } }                     }
   let(:yields)      { []                                                             }
 
   it_should_behave_like 'an #each method'
@@ -23,8 +23,8 @@ describe Algebra::Summarization, '#each' do
   end
 
   it 'yields only tuples with the expected data' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 2 ] ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([[2]])
   end
 end

data/spec/unit/axiom/algebra/summarization/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Summarization, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])    }
+  let(:operand)      { Relation.new([[:id, Integer]], [[1], [2]])              }
   let(:summarize_by) { operand.project([])                                     }
-  let(:summarizers)  { { :count => lambda { |acc, tuple| acc.to_i + 1 } }      }
+  let(:summarizers)  { { count: ->(acc, tuple) { acc.to_i + 1 } }              }
   let(:object)       { described_class.new(operand, summarize_by, summarizers) }
 
   context 'with the same object' do
@@ -41,7 +41,7 @@ describe Algebra::Summarization, '#eql?' do
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand)      { Relation.new([ [ :id, Integer ] ], [ [ 3 ] ])                             }
+    let(:other_operand)      { Relation.new([[:id, Integer]], [[3]])                                     }
     let(:other_summarize_by) { summarize_by                                                              }
     let(:other_summarizers)  { summarizers                                                               }
     let(:other)              { described_class.new(other_operand, other_summarize_by, other_summarizers) }

data/spec/unit/axiom/algebra/summarization/hash_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Algebra::Summarization, '#hash' do
   subject { object.hash }
 
-  let(:operand)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])    }
+  let(:operand)      { Relation.new([[:id, Integer]], [[1], [2]])              }
   let(:summarize_by) { operand.project([])                                     }
-  let(:summarizers)  { { :count => lambda { |acc, tuple| acc.to_i + 1 } }      }
+  let(:summarizers)  { { count: ->(acc, tuple) { acc.to_i + 1 } }              }
   let(:object)       { described_class.new(operand, summarize_by, summarizers) }
 
   it_should_behave_like 'a hash method'

data/spec/unit/axiom/algebra/summarization/header_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Summarization, '#header' do
   subject { object.header }
 
-  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:operand)     { Relation.new([[:id, Integer]], [[1], [2]])           }
+  let(:summarizers) { { test: ->(acc, tuple) { 1 } }                       }
   let(:object)      { described_class.new(operand, TABLE_DEE, summarizers) }
 
   it_should_behave_like 'an idempotent method'
 
   it { should be_instance_of(Relation::Header) }
 
-  it { should == [ [ :test, Object ] ] }
+  it { should == [[:test, Object]] }
 end

data/spec/unit/axiom/algebra/summarization/insert_spec.rb

@@ -6,10 +6,10 @@ describe Algebra::Summarization, '#insert' do
   subject { object.insert(other) }
 
   let(:object)       { described_class.new(operand, summarize_by, summarizers) }
-  let(:other)        { stub('other')                                           }
-  let(:operand)      { Relation.new([ [ :id, Integer ] ], [])                  }
+  let(:other)        { double('other')                                         }
+  let(:operand)      { Relation.new([[:id, Integer]], [])                      }
   let(:summarize_by) { operand.project([])                                     }
-  let(:summarizers)  { { :test => 1 }                                          }
+  let(:summarizers)  { { test: 1 }                                             }
 
   specify { expect { subject }.to raise_error(ImmutableRelationError, 'inserting into a summarization is impossible') }
 end

data/spec/unit/axiom/algebra/summarization/methods/summarize_spec.rb

@@ -5,20 +5,20 @@ require 'spec_helper'
 describe Algebra::Summarization::Methods, '#summarize' do
   subject { object.summarize(summarize_with, &block) }
 
-  let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:described_class) { Relation                                                                                                }
-  let(:block)           { lambda { |r| r.add(:test, r.id.count) }                                                                 }
-  let(:summarizers)     { [ :test, function ]                                                                                     }
-  let(:function)        { object[:id].count                                                                                       }
+  let(:object)          { described_class.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+  let(:described_class) { Relation                                                                                      }
+  let(:block)           { ->(r) { r.add(:test, r.id.count) }                                                            }
+  let(:summarizers)     { [:test, function]                                                                             }
+  let(:function)        { object[:id].count                                                                             }
 
   context 'with no arguments' do
     subject { object.summarize(&block) }
 
     it { should be_instance_of(Algebra::Summarization) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
-    its(:summarize_per) { should equal(TABLE_DEE) }
+    its(:summarize_per) { should be(TABLE_DEE) }
 
     its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
   end
@@ -28,9 +28,9 @@ describe Algebra::Summarization::Methods, '#summarize' do
 
     it { should be_instance_of(Algebra::Summarization) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
-    its(:summarize_per) { should equal(summarize_with) }
+    its(:summarize_per) { should be(summarize_with) }
 
     its(:summarizers) { should eql(Attribute::Integer.new(:test) => function) }
   end
@@ -40,7 +40,7 @@ describe Algebra::Summarization::Methods, '#summarize' do
 
     it { should be_instance_of(Algebra::Summarization) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
     its(:summarize_per) { should eql(object.project(summarize_with)) }
 
@@ -48,11 +48,11 @@ describe Algebra::Summarization::Methods, '#summarize' do
   end
 
   context 'with attributes' do
-    let(:summarize_with) { [ :name ] }
+    let(:summarize_with) { [:name] }
 
     it { should be_instance_of(Algebra::Summarization) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
     its(:summarize_per) { should eql(object.project(summarize_with)) }
 
@@ -65,7 +65,7 @@ describe Algebra::Summarization::Methods, '#summarize' do
     let(:summarize_with) { object.project([])                           }
     let(:summarizers)    { { Attribute::Object.new(:test) => function } }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
 
     its(:summarize_per) { should eql(summarize_with) }
 
@@ -73,8 +73,8 @@ describe Algebra::Summarization::Methods, '#summarize' do
   end
 
   context 'with a header containing an attribute used in the context block' do
-    let(:summarize_with) { object.project([ :id ])                  }
-    let(:block)          { lambda { |r| r.add(:count, r.id.count) } }
+    let(:summarize_with) { object.project([:id])               }
+    let(:block)          { ->(r) { r.add(:count, r.id.count) } }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/axiom/algebra/summarization/summaries/summarize_by_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Algebra::Summarization::Summaries, '#summarize_by' do
   subject { object.summarize_by(tuple) }
 
-  let(:object)       { described_class.new(header, summarizers)                         }
-  let(:summarizers)  { { :count => summarizer }                                         }
-  let(:summarizer)   { mock('Summarizer', :call => 1)                                   }
-  let(:header)       { Relation::Header.coerce([ [ :id, Integer ] ])                    }
-  let(:tuple_header) { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:tuple)        { Tuple.new(tuple_header, [ 1, 'Dan Kubb' ])                       }
+  let(:object)       { described_class.new(header, summarizers)                   }
+  let(:summarizers)  { { count: summarizer }                                      }
+  let(:summarizer)   { double('Summarizer', call: 1)                              }
+  let(:header)       { Relation::Header.coerce([[:id, Integer]])                  }
+  let(:tuple_header) { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:tuple)        { Tuple.new(tuple_header, [1, 'Dan Kubb'])                   }
 
   it_should_behave_like 'a command method'
 

data/spec/unit/axiom/algebra/summarization/summaries/to_hash_spec.rb

@@ -6,8 +6,8 @@ describe Algebra::Summarization::Summaries, '#to_hash' do
   subject { object.to_hash }
 
   let(:object)      { described_class.new(header, summarizers) }
-  let(:header)      { mock('Header')                           }
-  let(:summarizers) { { :count => mock('Summarizer') }         }
+  let(:header)      { double('Header')                         }
+  let(:summarizers) { { count: double('Summarizer') }          }
 
   it 'matches the expected value' do
     key, value = subject.first

data/spec/unit/axiom/algebra/summarization/summarize_per_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Summarization, '#summarize_per' do
   subject { object.summarize_per }
 
-  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:operand)     { Relation.new([[:id, Integer]], [[1], [2]])           }
+  let(:summarizers) { { test: ->(acc, tuple) { 1 } }                       }
   let(:object)      { described_class.new(operand, TABLE_DEE, summarizers) }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(TABLE_DEE) }
+  it { should be(TABLE_DEE) }
 end

data/spec/unit/axiom/algebra/summarization/summarizers_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Summarization, '#summarizers' do
   subject { object.summarizers }
 
-  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
-  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:operand)     { Relation.new([[:id, Integer]], [[1], [2]])           }
+  let(:summarizers) { { test: ->(acc, tuple) { 1 } }                       }
   let(:object)      { described_class.new(operand, TABLE_DEE, summarizers) }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(summarizers) }
+  it { should be(summarizers) }
 end

data/spec/unit/axiom/algebra/summarization/summary/call_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Algebra::Summarization::Summary, '#call' do
   subject { object.call(tuple) }
 
-  let(:object) { described_class.new(summarizer)               }
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                      }
+  let(:object) { described_class.new(summarizer)           }
+  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
+  let(:tuple)  { Tuple.new(header, [1])                    }
 
   context 'when the summarizer is a Proc' do
-    let(:summarizer) { lambda { |accumulator, tuple| accumulator.to_i.succ } }
+    let(:summarizer) { ->(accumulator, tuple) { accumulator.to_i.succ } }
 
     context 'when there is no summary' do
       it { should be_nil }