axiom 0.1.1 → 0.2.0

data/spec/unit/axiom/function/predicate/inclusion/methods/include_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::Inclusion::Methods, '#include' do
   subject { object.include(other) }
 
+  let(:object)          { described_class.new.freeze    }
   let(:described_class) { InclusionMethodsSpecs::Object }
-  let(:other)           { [true, false]                 }
-  let(:object)          { described_class.new           }
+  let(:other)           { [true, false].freeze          }
 
   it { should be_instance_of(Function::Predicate::Inclusion) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/inequality/methods/ne_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::Inequality::Methods, '#ne' do
   subject { object.ne(other) }
 
+  let(:object)          { described_class.new.freeze     }
   let(:described_class) { InequalityMethodsSpecs::Object }
   let(:other)           { true                           }
-  let(:object)          { described_class.new            }
 
   it { should be_instance_of(Function::Predicate::Inequality) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/less_than/methods/lt_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::LessThan::Methods, '#lt' do
   subject { object.lt(other) }
 
+  let(:object)          { described_class.new.freeze   }
   let(:described_class) { LessThanMethodsSpecs::Object }
   let(:other)           { 1                            }
-  let(:object)          { described_class.new          }
 
   it { should be_instance_of(Function::Predicate::LessThan) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/less_than_or_equal_to/methods/lte_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::LessThanOrEqualTo::Methods, '#lte' do
   subject { object.lte(other) }
 
+  let(:object)          { described_class.new.freeze            }
   let(:described_class) { LessThanOrEqualToMethodsSpecs::Object }
   let(:other)           { 1                                     }
-  let(:object)          { described_class.new                   }
 
   it { should be_instance_of(Function::Predicate::LessThanOrEqualTo) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/match/methods/match_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::Match::Methods, '#match' do
   subject { object.match(other) }
 
-  let(:described_class) { MatchMethodsSpecs::Object }
-  let(:other)           { /Dan Kubb/                }
-  let(:object)          { described_class.new       }
+  let(:object)          { described_class.new.freeze }
+  let(:described_class) { MatchMethodsSpecs::Object  }
+  let(:other)           { /Dan Kubb/.freeze          }
 
   it { should be_instance_of(Function::Predicate::Match) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/predicate/no_match/methods/no_match_spec.rb

@@ -6,9 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate::NoMatch::Methods, '#no_match' do
   subject { object.no_match(other) }
 
+  let(:object)          { described_class.new.freeze  }
   let(:described_class) { NoMatchMethodsSpecs::Object }
-  let(:other)           { /Dan Kubb/                  }
-  let(:object)          { described_class.new         }
+  let(:other)           { /Dan Kubb/.freeze           }
 
   it { should be_instance_of(Function::Predicate::NoMatch) }
+
+  its(:left) { should be(object) }
+
+  its(:right) { should be(other) }
 end

data/spec/unit/axiom/function/proposition/call_spec.rb

@@ -3,14 +3,16 @@
 require 'spec_helper'
 
 describe Function::Proposition, '#call' do
-  subject { object.call }
+  subject { object.call(tuple) }
 
-  let(:described_class) { Class.new(Function::Proposition) }
-  let(:object)          { described_class.new              }
+  let(:object)          { described_class.instance                  }
+  let(:described_class) { Class.new(Function::Proposition)          }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+  let(:tuple)           { Tuple.new(header, [1])                    }
 
   it 'calls self.class.call' do
     response = double('#call response')
-    described_class.should_receive(:call).and_return(response)
+    expect(described_class).to receive(:call).and_return(response)
     should be(response)
   end
 end

data/spec/unit/axiom/function/proposition/class_methods/{new_spec.rb → coerce_spec.rb}

@@ -2,44 +2,44 @@
 
 require 'spec_helper'
 
-describe Function::Proposition, '.new' do
+describe Function::Proposition, '.coerce' do
+  subject { object.coerce(argument) }
+
   let(:object) { described_class }
 
-  context 'with true argument' do
-    subject { object.new(argument) }
+  context 'with a tautology' do
+    let(:argument) { Function::Proposition::Tautology.instance }
+
+    it { should be(Function::Proposition::Tautology.instance) }
+  end
+
+  context 'with a contradiction' do
+    let(:argument) { Function::Proposition::Contradiction.instance }
+
+    it { should be(Function::Proposition::Contradiction.instance) }
+  end
 
+  context 'with true argument' do
     let(:argument) { true }
 
     it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'with false argument' do
-    subject { object.new(argument) }
-
     let(:argument) { false }
 
     it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'with a truthy argument' do
-    subject { object.new(argument) }
-
     let(:argument) { 1 }
 
-    it { should be(Function::Proposition::Contradiction.instance) }
+    specify { expect { subject }.to raise_error(ArgumentError, 'Invalid object 1') }
   end
 
   context 'with a falsey argument' do
-    subject { object.new(argument) }
-
     let(:argument) { nil }
 
-    it { should be(Function::Proposition::Contradiction.instance) }
-  end
-
-  context 'with no arguments' do
-    subject { object.new }
-
-    specify { pending { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract class") } }
+    specify { expect { subject }.to raise_error(ArgumentError, 'Invalid object nil') }
   end
 end

data/spec/unit/axiom/function/proposition/eql_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Function::Proposition, '#eql?' do
   subject { object.eql?(other) }
 
+  let(:object)          { described_class.instance         }
   let(:described_class) { Class.new(Function::Proposition) }
-  let(:object)          { described_class.new              }
 
   context 'with the same class' do
-    let(:other) { described_class.new }
+    let(:other) { described_class.instance }
 
     it { should be(true) }
 
@@ -19,7 +19,7 @@ describe Function::Proposition, '#eql?' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new }
+    let(:other) { Class.new(described_class).instance }
 
     it { should be(false) }
 
@@ -29,7 +29,7 @@ describe Function::Proposition, '#eql?' do
   end
 
   context 'with a different class' do
-    let(:other) { Class.new(Function::Proposition).new }
+    let(:other) { Class.new(Function::Proposition).instance }
 
     it { should be(false) }
 

data/spec/unit/axiom/function/proposition/equality_operator_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Function::Proposition, '#==' do
   subject { object == other }
 
+  let(:object)          { described_class.instance         }
   let(:described_class) { Class.new(Function::Proposition) }
-  let(:object)          { described_class.new              }
 
   context 'with the same object' do
     let(:other) { object }
@@ -19,7 +19,7 @@ describe Function::Proposition, '#==' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new }
+    let(:other) { Class.new(described_class).instance }
 
     it { should be(true) }
 
@@ -29,7 +29,7 @@ describe Function::Proposition, '#==' do
   end
 
   context 'with a different class' do
-    let(:other) { Class.new(Function::Proposition).new }
+    let(:other) { Class.new(Function::Proposition).instance }
 
     it { should be(false) }
 

data/spec/unit/axiom/function/proposition/inverse_spec.rb

@@ -5,22 +5,22 @@ require 'spec_helper'
 describe Function::Proposition, '#inverse' do
   subject { object.inverse }
 
+  let(:object)           { described_class.instance                            }
   let(:described_class)  { Class.new(Function::Proposition)                    }
   let(:inverse_class)    { double('Inverse Class', instance: inverse_instance) }
   let(:inverse_instance) { double('Inverse Instance')                          }
-  let(:object)           { described_class.new                                 }
 
   before do
-    described_class.stub(inverse: inverse_class)
+    allow(described_class).to receive(:inverse).and_return(inverse_class)
   end
 
   it 'calls .inverse on the class' do
-    described_class.should_receive(:inverse).with(no_args).and_return(inverse_class)
+    expect(described_class).to receive(:inverse).with(no_args).and_return(inverse_class)
     subject
   end
 
   it 'calls .instance on the inverse class' do
-    inverse_class.should_receive(:instance).with(no_args)
+    expect(inverse_class).to receive(:instance).with(no_args)
     subject
   end
 

data/spec/unit/axiom/function/proposition/rename_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Function::Proposition, '#rename' do
   subject { object.rename(aliases) }
 
+  let(:object)          { described_class.instance         }
   let(:described_class) { Class.new(Function::Proposition) }
   let(:header)          { TABLE_DUM.header                 }
   let(:aliases)         { Algebra::Rename::Aliases.new({}) }
-  let(:object)          { described_class.new              }
 
   it 'returns self' do
     should be(object)

data/spec/unit/axiom/function/type_spec.rb

@@ -11,7 +11,7 @@ describe Function, '#type' do
   let(:type)            { double('type')        }
 
   before do
-    described_class.should_receive(:type).and_return(type)
+    expect(described_class).to receive(:type).and_return(type)
   end
 
   it 'delegates to the class type' do

data/spec/unit/axiom/function/unary/call_spec.rb

@@ -14,7 +14,7 @@ describe Function::Unary, '#call' do
   let(:object)          { described_class.new(operand)              }
 
   before do
-    described_class.should_receive(:call).with(true).and_return(response)
+    expect(described_class).to receive(:call).with(true).and_return(response)
   end
 
   it { should be(response) }

data/spec/unit/axiom/function/unary/callable/call_spec.rb

@@ -5,19 +5,9 @@ require 'spec_helper'
 describe Function::Unary::Callable, '#call' do
   subject { object.call(value) }
 
-  let(:object)    { double('object', operation: :op).extend(self.class.described_class) }
-  let(:value)     { double('value', send: response)                                     }
-  let(:response)  { double('response')                                                  }
+  let(:object)   { double('object', operation: :op).extend(self.class.described_class) }
+  let(:value)    { double('value', op: response)                                       }
+  let(:response) { double('response')                                                  }
 
   it { should be(response) }
-
-  it 'uses the operation from the object' do
-    object.should_receive(:operation)
-    subject
-  end
-
-  it 'delegates the operation to the value' do
-    value.should_receive(:send).with(:op)
-    subject
-  end
 end

data/spec/unit/axiom/function/unary/callable/included_spec.rb

@@ -12,12 +12,12 @@ describe Function::Unary::Callable, '#included' do
   it_should_behave_like 'a command method'
 
   it 'delegates to the superclass #included method' do
-    superklass.should_receive(:included).with(descendant)
+    expect(superklass).to receive(:included).with(descendant)
     subject
   end
 
   it 'extends the descendant with Callable' do
-    descendant.should_receive(:extend).with(self.class.described_class)
+    expect(descendant).to receive(:extend).with(self.class.described_class)
     subject
   end
 end

data/spec/unit/axiom/function/unary/type_spec.rb

@@ -13,7 +13,17 @@ describe Function::Unary, '#type' do
   end
 
   context 'when the operand has a type' do
-    let(:operand) { double(type: Types::Integer, frozen?: true) }
+    let(:operand) { operand_class.new(Types::Integer) }
+
+    let(:operand_class) do
+      Class.new do
+        attr_reader :type
+
+        def initialize(type)
+          @type = type
+        end
+      end
+    end
 
     it { should be(Types::Integer) }
   end

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

@@ -11,7 +11,7 @@ describe Relation::Base, '#eql?' do
   let(:object) { described_class.new(name, header, body) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   context 'with the same object' do

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

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Base, '#==' do
+  subject { object == other }
+
+  let(:object) { described_class.new(name, header, body) }
+  let(:name)   { :users                                  }
+  let(:header) { [[:id, Integer]]                        }
+  let(:body)   { LazyEnumerable.new([[1]])               }
+
+  before do
+    expect(object).to be_instance_of(described_class)
+  end
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(name, header, body) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having a different name' do
+    let(:other_name) { :other                                        }
+    let(:other)      { described_class.new(other_name, header, body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having a different header' do
+    let(:other_header) { [[:id, Numeric]]                              }
+    let(:other)        { described_class.new(name, other_header, body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an object having a different body' do
+    let(:other_body)   { LazyEnumerable.new([[2]])                     }
+    let(:other)        { described_class.new(name, header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  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(name, header1, LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:other)      { described_class.new(name, header2, LazyEnumerable.new([['Dan Kubb', 1]])) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object responding to #to_set' do
+    let(:other) { Set[[1]] }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      pending 'Set#== should call to_set on other' do
+        should eql(other == object)
+      end
+    end
+  end
+
+  context 'with a different object responding to #to_set' do
+    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) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  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)        { described_class.new(name, other_header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+end