axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/function/predicate/no_match/inverse_spec.rb

@@ -13,7 +13,7 @@ describe Function::Predicate::NoMatch, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::Match) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
-  its(:right) { should equal(regexp) }
+  its(:right) { should be(regexp) }
 end

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

@@ -9,8 +9,8 @@ describe Function::Proposition, '#call' do
   let(:object)          { described_class.new              }
 
   it 'calls self.class.call' do
-    response = mock('#call response')
+    response = double('#call response')
     described_class.should_receive(:call).and_return(response)
-    should equal(response)
+    should be(response)
   end
 end

data/spec/unit/axiom/function/proposition/class_methods/new_spec.rb

@@ -10,7 +10,7 @@ describe Function::Proposition, '.new' do
 
     let(:argument) { true }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'with false argument' do
@@ -18,7 +18,7 @@ describe Function::Proposition, '.new' do
 
     let(:argument) { false }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'with a truthy argument' do
@@ -26,7 +26,7 @@ describe Function::Proposition, '.new' do
 
     let(:argument) { 1 }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'with a falsey argument' do
@@ -34,7 +34,7 @@ describe Function::Proposition, '.new' do
 
     let(:argument) { nil }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'with no arguments' do

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Proposition, '.type' do
+  subject { object.type }
+
+  let(:object) { Class.new(Function::Proposition) }
+
+  it { should be(Types::Boolean) }
+end

data/spec/unit/axiom/function/proposition/contradiction/and_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Function::Proposition::Contradiction, '#and' do
   subject { object.and(other) }
 
-  let(:other)  { mock('other')            }
+  let(:other)  { double('other')          }
   let(:object) { described_class.instance }
 
-  it { should equal(object) }
+  it { should be(object) }
 end

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

@@ -9,5 +9,5 @@ describe Function::Proposition::Contradiction, '.inverse' do
 
   it_should_behave_like 'an invertible method'
 
-  it { should equal(Function::Proposition::Tautology) }
+  it { should be(Function::Proposition::Tautology) }
 end

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

@@ -9,5 +9,5 @@ describe Function::Proposition::Contradiction, '#inverse' do
 
   it_should_behave_like 'an invertible method'
 
-  it { should equal(Function::Proposition::Tautology.instance) }
+  it { should be(Function::Proposition::Tautology.instance) }
 end

data/spec/unit/axiom/function/proposition/contradiction/or_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Function::Proposition::Contradiction, '#or' do
   subject { object.or(other) }
 
-  let(:other)  { mock('other')            }
+  let(:other)  { double('other')          }
   let(:object) { described_class.instance }
 
-  it { should equal(other) }
+  it { should be(other) }
 end

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Function::Proposition, '#inverse' do
   subject { object.inverse }
 
-  let(:described_class)  { Class.new(Function::Proposition)                     }
-  let(:inverse_class)    { mock('Inverse Class', :instance => inverse_instance) }
-  let(:inverse_instance) { mock('Inverse Instance')                             }
-  let(:object)           { described_class.new                                  }
+  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)
+    described_class.stub(inverse: inverse_class)
   end
 
   it 'calls .inverse on the class' do
@@ -24,5 +24,5 @@ describe Function::Proposition, '#inverse' do
     subject
   end
 
-  it { should equal(inverse_instance) }
+  it { should be(inverse_instance) }
 end

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

@@ -11,6 +11,6 @@ describe Function::Proposition, '#rename' do
   let(:object)          { described_class.new              }
 
   it 'returns self' do
-    should equal(object)
+    should be(object)
   end
 end

data/spec/unit/axiom/function/proposition/tautology/and_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Function::Proposition::Tautology, '#and' do
   subject { object.and(other) }
 
-  let(:other)  { mock('other')            }
+  let(:other)  { double('other')          }
   let(:object) { described_class.instance }
 
-  it { should equal(other) }
+  it { should be(other) }
 end

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

@@ -9,5 +9,5 @@ describe Function::Proposition::Tautology, '.inverse' do
 
   it_should_behave_like 'an invertible method'
 
-  it { should equal(Function::Proposition::Contradiction) }
+  it { should be(Function::Proposition::Contradiction) }
 end

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

@@ -9,5 +9,5 @@ describe Function::Proposition::Tautology, '#inverse' do
 
   it_should_behave_like 'an invertible method'
 
-  it { should equal(Function::Proposition::Contradiction.instance) }
+  it { should be(Function::Proposition::Contradiction.instance) }
 end

data/spec/unit/axiom/function/proposition/tautology/or_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Function::Proposition::Tautology, '#or' do
   subject { object.or(other) }
 
-  let(:other)  { mock('other')            }
+  let(:other)  { double('other')          }
   let(:object) { described_class.instance }
 
-  it { should equal(object) }
+  it { should be(object) }
 end

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

@@ -7,7 +7,7 @@ describe Function, '#rename' do
   subject { object.rename(aliases) }
 
   let(:described_class) { FunctionSpecs::Object }
-  let(:aliases)         { mock('Aliases')       }
+  let(:aliases)         { double('Aliases')     }
   let(:object)          { described_class.new   }
 
   specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#rename is not implemented") }

data/spec/unit/axiom/function/string/length/class_methods/type_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::String::Length, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it { should be(Types::Integer) }
+end

data/spec/unit/axiom/function/string/length/methods/length_spec.rb

@@ -10,5 +10,5 @@ describe Function::String::Length::Methods, '#length' do
 
   it { should be_instance_of(Function::String::Length) }
 
-  its(:operand) { should equal(object) }
+  its(:operand) { should be(object) }
 end

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

@@ -8,6 +8,13 @@ describe Function, '#type' do
 
   let(:described_class) { FunctionSpecs::Object }
   let(:object)          { described_class.new   }
+  let(:type)            { double('type')        }
 
-  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#type is not implemented") }
+  before do
+    described_class.should_receive(:type).and_return(type)
+  end
+
+  it 'delegates to the class type' do
+    should be(type)
+  end
 end

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

@@ -6,16 +6,16 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Unary, '#call' do
   subject { object.call(tuple) }
 
-  let(:described_class) { UnarySpecs::Object                            }
-  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:operand)         { header[:id].eq(1)                             }
-  let(:tuple)           { Tuple.new(header, [ 1 ])                      }
-  let(:response)        { mock('#call response')                        }
-  let(:object)          { described_class.new(operand)                  }
+  let(:described_class) { UnarySpecs::Object                        }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+  let(:operand)         { header[:id].eq(1)                         }
+  let(:tuple)           { Tuple.new(header, [1])                    }
+  let(:response)        { double('#call response')                  }
+  let(:object)          { described_class.new(operand)              }
 
   before do
     described_class.should_receive(:call).with(true).and_return(response)
   end
 
-  it { should equal(response) }
+  it { should be(response) }
 end

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Function::Unary::Callable, '#call' do
   subject { object.call(value) }
 
-  let(:object)    { mock('object', :operation => :op).extend(self.class.described_class) }
-  let(:value)     { mock('value', :send => response)                                     }
-  let(:response)  { mock('response')                                                     }
+  let(:object)    { double('object', operation: :op).extend(self.class.described_class) }
+  let(:value)     { double('value', send: response)                                     }
+  let(:response)  { double('response')                                                  }
 
-  it { should equal(response) }
+  it { should be(response) }
 
   it 'uses the operation from the object' do
     object.should_receive(:operation)

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

@@ -7,7 +7,7 @@ describe Function::Unary::Callable, '#included' do
 
   let(:object)     { Class.new(superklass).extend(self.class.described_class) }
   let(:superklass) { Class.new                                                }
-  let(:descendant) { mock('descendant')                                       }
+  let(:descendant) { double('descendant')                                     }
 
   it_should_behave_like 'a command method'
 

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

@@ -6,11 +6,11 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Unary, '#==' do
   subject { object == other }
 
-  let(:described_class) { UnarySpecs::Object                     }
-  let(:attribute)       { Attribute::Integer.new(:id)            }
-  let(:header)          { Relation::Header.coerce([ attribute ]) }
-  let(:operand)         { attribute.eq(1)                        }
-  let(:object)          { described_class.new(operand)           }
+  let(:described_class) { UnarySpecs::Object                   }
+  let(:attribute)       { Attribute::Integer.new(:id)          }
+  let(:header)          { Relation::Header.coerce([attribute]) }
+  let(:operand)         { attribute.eq(1)                      }
+  let(:object)          { described_class.new(operand)         }
 
   context 'with the same object' do
     let(:other) { object }

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

@@ -6,11 +6,11 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Unary, '#hash' do
   subject { object.hash }
 
-  let(:described_class) { UnarySpecs::Object                     }
-  let(:attribute)       { Attribute::Integer.new(:id)            }
-  let(:header)          { Relation::Header.coerce([ attribute ]) }
-  let(:operand)         { attribute.eq(1)                        }
-  let(:object)          { described_class.new(operand)           }
+  let(:described_class) { UnarySpecs::Object                   }
+  let(:attribute)       { Attribute::Integer.new(:id)          }
+  let(:header)          { Relation::Header.coerce([attribute]) }
+  let(:operand)         { attribute.eq(1)                      }
+  let(:object)          { described_class.new(operand)         }
 
   it_should_behave_like 'a hash method'
 

data/spec/unit/axiom/function/unary/invertible/class_methods/included_spec.rb

@@ -19,11 +19,11 @@ describe Function::Unary::Invertible, '.included' do
 
   it 'delegates to the ancestor' do
     included_ancestor = false
-    subject.extend Module.new {
+    mod = Module.new do
       define_method(:included) { |_| included_ancestor = true }
-    }
-    expect {
-      klass.send(:include, subject)
-    }.to change { included_ancestor }.from(false).to(true)
+    end
+    subject.extend mod
+    expect { klass.send(:include, subject) }
+      .to change { included_ancestor }.from(false).to(true)
   end
 end

data/spec/unit/axiom/function/unary/invertible/inverse_spec.rb

@@ -6,7 +6,7 @@ describe Function::Unary::Invertible, '#inverse' do
   subject { object.inverse }
 
   let(:described_class) { Class.new(Function) { include Function::Unary } }
-  let(:operand)         { mock('Operand').freeze                          }
+  let(:operand)         { double('Operand').freeze                        }
   let(:object)          { described_class.new(operand)                    }
 
   let(:inverse_class) do
@@ -41,5 +41,5 @@ describe Function::Unary::Invertible, '#inverse' do
 
   it { should be_instance_of(InverseClass) }
 
-  its(:operand) { should equal(operand) }
+  its(:operand) { should be(operand) }
 end

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

@@ -6,12 +6,12 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Unary, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:described_class) { UnarySpecs::Object                                        }
-  let(:attribute)       { Attribute::Integer.new(:id)                               }
-  let(:other)           { attribute.rename(:other_id)                               }
-  let(:header)          { Relation::Header.new([ attribute ])                       }
-  let(:aliases)         { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
-  let(:object)          { described_class.new(operand)                              }
+  let(:described_class) { UnarySpecs::Object                                     }
+  let(:attribute)       { Attribute::Integer.new(:id)                            }
+  let(:other)           { attribute.rename(:other_id)                            }
+  let(:header)          { Relation::Header.new([attribute])                      }
+  let(:aliases)         { Algebra::Rename::Aliases.coerce(header, id: :other_id) }
+  let(:object)          { described_class.new(operand)                           }
 
   context 'operand is renamed' do
     let(:operand) { attribute.eq(1) }
@@ -24,6 +24,6 @@ describe Function::Unary, '#rename' do
   context 'operand is not renamed' do
     let(:operand) { other.eq(1) }
 
-    it { should equal(object) }
+    it { should be(object) }
   end
 end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Unary, '#type' do
+  subject { object.type }
+
+  let(:object)          { described_class.new(operand) }
+  let(:described_class) { Class.new(Function::Numeric) }
+
+  before do
+    described_class.class_eval { include Function::Unary }
+  end
+
+  context 'when the operand has a type' do
+    let(:operand) { double(type: Types::Integer, frozen?: true) }
+
+    it { should be(Types::Integer) }
+  end
+
+  context 'when the operand is a primitive' do
+    let(:operand) { 1 }
+
+    it { should be(Types::Integer) }
+  end
+end

data/spec/unit/axiom/operation/binary/eql_spec.rb

@@ -6,8 +6,8 @@ describe Operation::Binary, '#eql?' do
   subject { object.eql?(other) }
 
   let(:described_class) { Class.new { include Operation::Binary } }
-  let(:left)            { mock('Left')                            }
-  let(:right)           { mock('Right')                           }
+  let(:left)            { double('Left')                          }
+  let(:right)           { double('Right')                         }
   let(:object)          { described_class.new(left, right)        }
 
   context 'with the same object' do
@@ -41,7 +41,7 @@ describe Operation::Binary, '#eql?' do
   end
 
   context 'with an object having a different left operand' do
-    let(:other_left)  { mock('Other Left')                           }
+    let(:other_left)  { double('Other Left')                         }
     let(:other_right) { right                                        }
     let(:other)       { described_class.new(other_left, other_right) }
 
@@ -54,7 +54,7 @@ describe Operation::Binary, '#eql?' do
 
   context 'with an object having a different right operand' do
     let(:other_left)  { left                                         }
-    let(:other_right) { mock('Other Right')                          }
+    let(:other_right) { double('Other Right')                        }
     let(:other)       { described_class.new(other_left, other_right) }
 
     it { should be(false) }

data/spec/unit/axiom/operation/binary/hash_spec.rb

@@ -6,8 +6,8 @@ describe Operation::Binary, '#hash' do
   subject { object.hash }
 
   let(:described_class) { Class.new { include Operation::Binary } }
-  let(:left)            { mock('Left').freeze                     }
-  let(:right)           { mock('Right').freeze                    }
+  let(:left)            { double('Left').freeze                   }
+  let(:right)           { double('Right').freeze                  }
   let(:object)          { described_class.new(left, right)        }
 
   it_should_behave_like 'a hash method'