axiom 0.1.0 → 0.1.1

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

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

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

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

data/spec/unit/axiom/relation/empty/size_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Relation::Empty, '#size' do
   subject { object.size }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ]) }
+  let(:object) { described_class.new([[:id, Integer]]) }
 
   it { should eql(0) }
 end

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

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

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

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:header) { [ [ :id, Integer ] ]              }
-  let(:body)   { LazyEnumerable.new([ [ 1 ] ])     }
+  let(:header) { [[:id, Integer]]                  }
+  let(:body)   { LazyEnumerable.new([[1]])         }
   let(:object) { described_class.new(header, body) }
 
   before do
@@ -44,7 +44,7 @@ describe Relation, '#eql?' do
   end
 
   context 'with an object having a different header' do
-    let(:other_header) { [ [ :id, Numeric ] ]                          }
+    let(:other_header) { [[:id, Numeric]]                              }
     let(:other_body)   { body                                          }
     let(:other)        { described_class.new(other_header, other_body) }
 
@@ -57,7 +57,7 @@ describe Relation, '#eql?' do
 
   context 'with an object having a different body' do
     let(:other_header) { header                                        }
-    let(:other_body)   { LazyEnumerable.new([ [ 2 ] ])                 }
+    let(:other_body)   { LazyEnumerable.new([[2]])                     }
     let(:other)        { described_class.new(other_header, other_body) }
 
     it { should be(false) }
@@ -68,12 +68,12 @@ describe Relation, '#eql?' do
   end
 
   context 'with an object having an equivalent header in a different order' do
-    let(:attribute1) { [ :id,   Integer ]                                                      }
-    let(:attribute2) { [ :name, String  ]                                                      }
-    let(:header1)    { [ attribute1, attribute2 ]                                              }
-    let(:header2)    { [ attribute2, attribute1 ]                                              }
-    let(:object)     { described_class.new(header1, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:other)      { described_class.new(header2, LazyEnumerable.new([ [ 'Dan Kubb', 1 ] ])) }
+    let(:attribute1) { [:id,   Integer]                                                    }
+    let(:attribute2) { [:name, String]                                                     }
+    let(:header1)    { [attribute1, attribute2]                                            }
+    let(:header2)    { [attribute2, attribute1]                                            }
+    let(:object)     { described_class.new(header1, LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:other)      { described_class.new(header2, LazyEnumerable.new([['Dan Kubb', 1]])) }
 
     it { should be(true) }
 

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

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Relation, '#==' do
   subject { object == other }
 
-  let(:header) { [ [ :id, Integer ] ]              }
-  let(:body)   { LazyEnumerable.new([ [ 1 ] ])     }
+  let(:header) { [[:id, Integer]]                  }
+  let(:body)   { LazyEnumerable.new([[1]])         }
   let(:object) { described_class.new(header, body) }
 
   before do
@@ -44,7 +44,7 @@ describe Relation, '#==' do
   end
 
   context 'with an object having a different header' do
-    let(:other_header) { [ [ :id, Numeric ] ]                          }
+    let(:other_header) { [[:id, Numeric]]                              }
     let(:other_body)   { body                                          }
     let(:other)        { described_class.new(other_header, other_body) }
 
@@ -57,7 +57,7 @@ describe Relation, '#==' do
 
   context 'with an object having a different body' do
     let(:other_header) { header                                        }
-    let(:other_body)   { LazyEnumerable.new([ [ 2 ] ])                 }
+    let(:other_body)   { LazyEnumerable.new([[2]])                     }
     let(:other)        { described_class.new(other_header, other_body) }
 
     it { should be(false) }
@@ -68,12 +68,12 @@ describe Relation, '#==' do
   end
 
   context 'with an object having an equivalent header in a different order' do
-    let(:attribute1) { [ :id,   Integer ]                                                      }
-    let(:attribute2) { [ :name, String  ]                                                      }
-    let(:header1)    { [ attribute1, attribute2 ]                                              }
-    let(:header2)    { [ attribute2, attribute1 ]                                              }
-    let(:object)     { described_class.new(header1, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:other)      { described_class.new(header2, LazyEnumerable.new([ [ 'Dan Kubb', 1 ] ])) }
+    let(:attribute1) { [:id,   Integer]                                                    }
+    let(:attribute2) { [:name, String]                                                     }
+    let(:header1)    { [attribute1, attribute2]                                            }
+    let(:header2)    { [attribute2, attribute1]                                            }
+    let(:object)     { described_class.new(header1, LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:other)      { described_class.new(header2, LazyEnumerable.new([['Dan Kubb', 1]])) }
 
     it { should be(true) }
 
@@ -83,7 +83,7 @@ describe Relation, '#==' do
   end
 
   context 'with an equivalent object responding to #to_set' do
-    let(:other) { Set[ [ 1 ] ] }
+    let(:other) { Set[[1]] }
 
     it { should be(true) }
 
@@ -95,7 +95,17 @@ describe Relation, '#==' do
   end
 
   context 'with a different object responding to #to_set' do
-    let(:other) { Set[ [ 2 ] ] }
+    let(:other) { Set[[2]] }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with a different object not responding to #to_set' do
+    let(:other) { Object.new }
 
     it { should be(false) }
 
@@ -105,8 +115,8 @@ describe Relation, '#==' do
   end
 
   context 'with a different object having a superset of the headers' do
-    let(:other_header) { [ [ :id, Integer ], [ :name, String ] ]       }
-    let(:other_body)   { LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])     }
+    let(:other_header) { [[:id, Integer], [:name, String]]             }
+    let(:other_body)   { LazyEnumerable.new([[1, 'Dan Kubb']])         }
     let(:other)        { described_class.new(other_header, other_body) }
 
     it { should be(false) }

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

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation, '#hash' do
   subject { object.hash }
 
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:body)   { LazyEnumerable.new                            }
-  let(:object) { described_class.new(header, body)             }
+  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
+  let(:body)   { LazyEnumerable.new                        }
+  let(:object) { described_class.new(header, body)         }
 
   before do
     object.should be_instance_of(described_class)

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

@@ -2,23 +2,23 @@
 
 require 'spec_helper'
 
-[ :call, :[] ].each do |method|
+[:call, :[]].each do |method|
   describe Relation::Header, "##{method}" do
     subject { object.send(method, name) }
 
-    let(:object)    { described_class.coerce([ attribute ]) }
-    let(:attribute) { Attribute::Integer.new(:id)           }
+    let(:object)    { described_class.coerce([attribute]) }
+    let(:attribute) { Attribute::Integer.new(:id)         }
 
     context 'with a known attribute' do
       let(:name) { attribute }
 
-      it { should == [ :id, Integer ] }
+      it { should == [:id, Integer] }
     end
 
     context 'with a known attribute name' do
       let(:name) { :id }
 
-      it { should == [ :id, Integer ] }
+      it { should == [:id, Integer] }
     end
 
     context 'with an unknown attribute' do

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

@@ -4,9 +4,9 @@ require 'spec_helper'
 
 describe Relation::Header, '.coerce' do
   let(:object)    { described_class             }
-  let(:header)    { object.new([ attribute ])   }
+  let(:header)    { object.new([attribute])     }
   let(:attribute) { Attribute::Integer.new(:id) }
-  let(:array)     { [ [ :id, Integer ] ]        }
+  let(:array)     { [[:id, Integer]]            }
 
   context 'with a block' do
     subject { object.coerce(argument, &block) }
@@ -15,25 +15,25 @@ describe Relation::Header, '.coerce' do
       let(:argument) { header                            }
       let(:block)    { proc { raise 'should not raise' } }
 
-      it { should equal(header) }
+      it { should be(header) }
     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(:other) { Attribute::Object.new(:id)   }
+        let(:block) { ->(attribute) { other }    }
+        let(:other) { Attribute::Object.new(:id) }
 
         it { should be_instance_of(object) }
 
-        it { should eql(object.new([ other ])) }
+        it { should eql(object.new([other])) }
 
         its(:keys) { should be_empty }
       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) }
 
@@ -44,8 +44,8 @@ describe Relation::Header, '.coerce' do
     end
 
     context 'when the argument is not a Header 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
@@ -57,7 +57,7 @@ describe Relation::Header, '.coerce' do
     context 'when the argument is a Header' do
       let(:argument) { header }
 
-      it { should equal(header) }
+      it { should be(header) }
     end
 
     context 'when the argument responds to #to_ary' do
@@ -82,7 +82,7 @@ describe Relation::Header, '.coerce' do
 
     it { should be_instance_of(object) }
 
-    its(:to_a) { should == [ attribute ] }
+    its(:to_a) { should == [attribute] }
 
     its(:keys) { should be_empty }
   end
@@ -90,12 +90,12 @@ describe Relation::Header, '.coerce' do
   context 'with options' do
     subject { object.coerce(array, options) }
 
-    let(:options) { { :keys => [ array ] } }
+    let(:options) { { keys: [array] } }
 
     it { should be_instance_of(object) }
 
     its(:to_a) { should == array }
 
-    its(:keys) { should == [ array ] }
+    its(:keys) { should == [array] }
   end
 end

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

@@ -19,7 +19,7 @@ describe Relation::Header, '.new' do
   context 'with attributes' do
     subject { object.new(attributes) }
 
-    let(:attributes) { [ id, name ] }
+    let(:attributes) { [id, name] }
 
     it { should be_instance_of(object) }
 
@@ -34,8 +34,8 @@ describe Relation::Header, '.new' do
   context 'with attributes and options' do
     subject { object.new(attributes, options) }
 
-    let(:attributes) { [ id, name ] }
-    let(:options)    { {}           }
+    let(:attributes) { [id, name] }
+    let(:options)    { {}         }
 
     it { should be_instance_of(object) }
 
@@ -53,7 +53,7 @@ describe Relation::Header, '.new' do
   end
 
   context 'with attributes that contain duplicates' do
-    subject { object.new([ id, id, name, name, name, age ]) }
+    subject { object.new([id, id, name, name, name, age]) }
 
     specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: [:id, :name]') }
   end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Header, '#context' do
+  subject { object.context(&block) }
+
+  let(:object)    { described_class.coerce([attribute]) }
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:block)     { ->(context) { }                     }
+  let(:context)   { double('context')                   }
+
+  before do
+    Axiom::Evaluator::Context.should_receive(:new).with(object)
+      .and_yield(context)
+      .and_return(context)
+  end
+
+  it 'is an evaluator context' do
+    should be(context)
+  end
+
+  it 'yields an evaluator context' do
+    expect { |block| object.context(&block) }
+      .to yield_with_args(context)
+  end
+end

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

@@ -2,17 +2,17 @@
 
 require 'spec_helper'
 
-[ :difference, :- ].each do |method|
+[:difference, :-].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 == [ [ :name, String ] ] }
+      its(:to_ary) { should == [[: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 ] ] }
+      its(:to_ary) { should == [[:id, Integer], [:name, String]] }
 
       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,15 +55,15 @@ 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) }
@@ -74,12 +74,12 @@ require 'spec_helper'
     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) }