axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/attribute/string/{valid_value_predicate_spec.rb → include_predicate_spec.rb}

@@ -2,10 +2,10 @@
 
 require 'spec_helper'
 
-describe Attribute::String, '#valid_value?' do
-  subject { object.valid_value?(value) }
+describe Attribute::String, '#include?' do
+  subject { object.include?(value) }
 
-  let(:object) { described_class.new(:string, :min_length => 1, :max_length => 50) }
+  let(:object) { described_class.new(:string, minimum_length: 1, maximum_length: 50) }
 
   context 'with a string value' do
     context 'that is within the allowed length range' do

data/spec/unit/axiom/attribute/time/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Time, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Time) }
+end

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

@@ -2,11 +2,11 @@
 
 require 'spec_helper'
 
-describe Aggregate, '#type' do
+describe Attribute, '#type' do
   subject { object.type }
 
-  let(:described_class) { Class.new(Attribute)       }
-  let(:object)          { described_class.new(:name) }
+  let(:described_class) { Class.new(Attribute) }
+  let(:object)          { described_class      }
 
-  it { should equal(described_class) }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{object}.type is not implemented") }
 end

data/spec/unit/axiom/equalizer/class_method/new_spec.rb

@@ -12,7 +12,7 @@ describe Axiom::Equalizer, '.new' do
 
     before do
       # specify the class #name method
-      klass.stub(:name => name)
+      klass.stub(name: name)
       klass.send(:include, subject)
     end
 
@@ -21,7 +21,7 @@ describe Axiom::Equalizer, '.new' do
     it { should be_instance_of(object) }
 
     it 'defines #hash and #inspect methods dynamically' do
-      subject.public_instance_methods(false).map(&:to_s).should =~ %w[ hash inspect ]
+      subject.public_instance_methods(false).map(&:to_s).should =~ %w[hash inspect]
     end
 
     describe '#eql?' do
@@ -32,7 +32,7 @@ describe Axiom::Equalizer, '.new' do
       end
 
       context 'when the objects are different' do
-        let(:other) { stub('other') }
+        let(:other) { double('other') }
 
         it { instance.eql?(other).should be(false) }
       end
@@ -46,7 +46,7 @@ describe Axiom::Equalizer, '.new' do
       end
 
       context 'when the objects are different' do
-        let(:other) { stub('other') }
+        let(:other) { double('other') }
 
         it { (instance == other).should be(false) }
       end
@@ -68,9 +68,9 @@ describe Axiom::Equalizer, '.new' do
   context 'with keys' do
     subject { object.new(*keys) }
 
-    let(:keys)       { [ :first_name ].freeze }
-    let(:first_name) { 'John'                 }
-    let(:instance)   { klass.new(first_name)  }
+    let(:keys)       { [:first_name].freeze  }
+    let(:first_name) { 'John'                }
+    let(:instance)   { klass.new(first_name) }
 
     let(:klass) do
       ::Class.new do
@@ -84,14 +84,14 @@ describe Axiom::Equalizer, '.new' do
 
     before do
       # specify the class #inspect method
-      klass.stub(:name => nil, :inspect => name)
+      klass.stub(name: nil, inspect: name)
       klass.send(:include, subject)
     end
 
     it { should be_instance_of(object) }
 
     it 'defines #hash and #inspect methods dynamically' do
-      subject.public_instance_methods(false).map(&:to_s).should =~ %w[ hash inspect ]
+      subject.public_instance_methods(false).map(&:to_s).should =~ %w[hash inspect]
     end
 
     describe '#eql?' do
@@ -102,7 +102,7 @@ describe Axiom::Equalizer, '.new' do
       end
 
       context 'when the objects are different' do
-        let(:other) { stub('other') }
+        let(:other) { double('other') }
 
         it { instance.eql?(other).should be(false) }
       end
@@ -116,7 +116,7 @@ describe Axiom::Equalizer, '.new' do
       end
 
       context 'when the objects are different' do
-        let(:other) { stub('other') }
+        let(:other) { double('other') }
 
         it { (instance == other).should be(false) }
       end

data/spec/unit/axiom/equalizer/methods/eql_spec.rb

@@ -12,7 +12,7 @@ describe Axiom::Equalizer::Methods, '#eql?' do
       include Axiom::Equalizer::Methods
 
       def cmp?(comparator, other)
-        !!(comparator and other)
+        !!(comparator && other)
       end
     end
   end

data/spec/unit/axiom/evaluator/context/add_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 
 describe Evaluator::Context, '#add' do
-  let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:header)    { Relation::Header.new([ attribute ]) }
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:header)    { Relation::Header.new([attribute]) }
 
   context 'when an aggregate is provided' do
     subject { described_class.new(header) { |object| object.add(:aggregate, aggregate) } }
@@ -31,11 +31,11 @@ describe Evaluator::Context, '#add' do
   end
 
   context 'when a proc is provided' do
-    subject { described_class.new(header) { |object| object.add(:proc, proc) } }
+    subject { described_class.new(header) { |object| object.add(:block, block) } }
 
-    let(:proc) { Proc.new {} }
+    let(:block) { proc {} }
 
-    its(:functions) { should eql(Attribute::Object.new(:proc) => proc) }
+    its(:functions) { should eql(Attribute::Object.new(:block) => block) }
 
     it 'returns self' do
       subject.yield.equal?(subject).should be(true)

data/spec/unit/axiom/evaluator/context/element_reader_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Evaluator::Context, '#[]' do
   subject { object[name] }
 
-  let(:name)      { :id                                 }
-  let(:attribute) { Attribute::Integer.new(name)        }
-  let(:header)    { Relation::Header.new([ attribute ]) }
-  let(:object)    { described_class.new(header) {}      }
+  let(:name)      { :id                               }
+  let(:attribute) { Attribute::Integer.new(name)      }
+  let(:header)    { Relation::Header.new([attribute]) }
+  let(:object)    { described_class.new(header) {}    }
 
-  it { should equal(attribute) }
+  it { should be(attribute) }
 end

data/spec/unit/axiom/evaluator/context/functions_spec.rb

@@ -6,7 +6,7 @@ describe Evaluator::Context, '#functions' do
   subject { object.functions }
 
   let(:attribute) { Attribute::Integer.new(:id)                                              }
-  let(:header)    { Relation::Header.new([ attribute ])                                      }
+  let(:header)    { Relation::Header.new([attribute])                                        }
   let(:function)  { proc {}                                                                  }
   let(:object)    { described_class.new(header) { |object| object.add(attribute, function) } }
 

data/spec/unit/axiom/evaluator/context/method_missing_spec.rb

@@ -3,20 +3,20 @@
 require 'spec_helper'
 
 describe Evaluator::Context, '#method_missing' do
-  let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:header)    { Relation::Header.new([ attribute ]) }
-  let(:object)    { described_class.new(header) {}      }
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:header)    { Relation::Header.new([attribute]) }
+  let(:object)    { described_class.new(header) {}    }
 
   context 'with a valid attribute' do
     subject { object.id }
 
-    it { should equal(attribute) }
+    it { should be(attribute) }
   end
 
   context 'with a valid attribute and extra arguments' do
     subject { object.id(args) }
 
-    let(:args) { mock('Arguments') }
+    let(:args) { double('Arguments') }
 
     specify { expect { subject }.to raise_error(ArgumentError, 'wrong number of arguments (1 for 0)') }
   end

data/spec/unit/axiom/evaluator/context/respond_to_predicate_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Evaluator::Context, '#respond_to?' do
   subject { object.respond_to?(method, include_private) }
 
-  let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:header)    { Relation::Header.new([ attribute ]) }
-  let(:object)    { described_class.new(header) {}      }
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:header)    { Relation::Header.new([attribute]) }
+  let(:object)    { described_class.new(header) {}    }
 
   context 'when the method is an attribute name and include_private is true' do
     let(:method)          { attribute.name }

data/spec/unit/axiom/evaluator/context/send_spec.rb

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Evaluator::Context, '#send' do
   subject { object.send(method, args, &block) }
 
-  let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:header)    { Relation::Header.new([ attribute ]) }
-  let(:object)    { described_class.new(header) {}      }
-  let(:method)    { :test                               }
-  let(:args)      { mock('Arguments')                   }
-  let(:block)     { proc {}                             }
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:header)    { Relation::Header.new([attribute]) }
+  let(:object)    { described_class.new(header) {}    }
+  let(:method)    { :test                             }
+  let(:args)      { double('Arguments')               }
+  let(:block)     { proc {}                           }
 
   before do
     def object.test(args, &block)
-      return args, block
+      [args, block]
     end
   end
 
   it 'delegates the arguments to the method' do
-    subject[0].should equal(args)
+    subject[0].should be(args)
   end
 
   it 'delegates the block to the method' do
-    subject[1].should equal(block)
+    subject[1].should be(block)
   end
 end

data/spec/unit/axiom/evaluator/context/yield_spec.rb

@@ -6,9 +6,9 @@ describe Evaluator::Context, '#yield' do
   subject { object.yield }
 
   let(:attribute)    { Attribute::Integer.new(:id)                  }
-  let(:header)       { Relation::Header.new([ attribute ])          }
-  let(:return_value) { mock('Return Value')                         }
+  let(:header)       { Relation::Header.new([attribute])            }
+  let(:return_value) { double('Return Value')                       }
   let(:object)       { described_class.new(header) { return_value } }
 
-  it { should equal(return_value) }
+  it { should be(return_value) }
 end

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

@@ -7,16 +7,16 @@ describe Function::Binary, '#call' do
   subject { object.call(tuple) }
 
   let(:described_class) { BinarySpecs::Object                               }
-  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ])     }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]])         }
   let(:left)            { Function::Predicate::Equality.new(header[:id], 1) }
   let(:right)           { Function::Predicate::Equality.new(header[:id], 2) }
-  let(:tuple)           { Tuple.new(header, [ 1 ])                          }
-  let(:response)        { mock('#call response')                            }
+  let(:tuple)           { Tuple.new(header, [1])                            }
+  let(:response)        { double('#call response')                          }
   let(:object)          { described_class.new(left, right)                  }
 
   before do
     described_class.should_receive(:call).with(true, false).and_return(response)
   end
 
-  it { should equal(response) }
+  it { should be(response) }
 end

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

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

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

@@ -19,11 +19,11 @@ describe Function::Binary::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/binary/invertible/inverse_spec.rb

@@ -6,8 +6,8 @@ describe Function::Binary::Invertible, '#inverse' do
   subject { object.inverse }
 
   let(:described_class) { Class.new(Function) { include Function::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)                 }
 
   let(:inverse_class) do
@@ -16,7 +16,7 @@ describe Function::Binary::Invertible, '#inverse' do
     end
   end
 
- before do
+  before do
     described_class.class_eval do
       include Function::Binary::Invertible
 
@@ -42,6 +42,6 @@ describe Function::Binary::Invertible, '#inverse' do
 
   it { should be_instance_of(InverseClass) }
 
-  its(:left)  { should equal(left)  }
-  its(:right) { should equal(right) }
+  its(:left)  { should be(left)  }
+  its(:right) { should be(right) }
 end

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

@@ -6,12 +6,12 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Binary, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:described_class) { BinarySpecs::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(left, right)                          }
+  let(:described_class) { BinarySpecs::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(left, right)                       }
 
   context 'left and right are renamed' do
     let(:left)  { attribute.eq(1) }
@@ -32,7 +32,7 @@ describe Function::Binary, '#rename' do
 
     its(:left) { should == other.eq(1) }
 
-    its(:right) { should equal(right) }
+    its(:right) { should be(right) }
   end
 
   context 'right is renamed' do
@@ -41,7 +41,7 @@ describe Function::Binary, '#rename' do
 
     it { should be_instance_of(described_class) }
 
-    its(:left) { should equal(left) }
+    its(:left) { should be(left) }
 
     its(:right) { should == other.eq(2) }
   end
@@ -50,6 +50,6 @@ describe Function::Binary, '#rename' do
     let(:left)  { other.eq(1) }
     let(:right) { other.eq(2) }
 
-    it { should equal(object) }
+    it { should be(object) }
   end
 end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Binary, '#type' do
+  subject { object.type }
+
+  let(:object)          { described_class.new(*operands) }
+  let(:described_class) { Class.new(Function::Numeric)   }
+
+  let(:operands) do
+    types.map { |type| double(type: type, frozen?: true) }
+  end
+
+  before do
+    described_class.class_eval { include Function::Binary }
+  end
+
+  context 'when the operands are from the same class' do
+    let(:types) { [Types::Integer, Types::Integer] }
+
+    it { should be(Types::Integer) }
+  end
+
+  context 'when the operands are sibling classes' do
+    let(:types) { [Types::Integer, Types::Float] }
+
+    it { should be(Types::Numeric) }
+  end
+
+  context 'when the operands are parent and child' do
+    let(:types) { [Types::Numeric, Types::Integer] }
+
+    it { should be(Types::Numeric) }
+  end
+
+  context 'when the operands are not related' do
+    let(:types) { [Types::String, Types::Integer] }
+
+    it { should be_nil }
+  end
+
+  context 'when an operand is a primitive' do
+    let(:operands) do
+      [
+        double(type: Types::Integer, frozen?: true),
+        1,
+      ]
+    end
+
+    it { should be(Types::Integer) }
+  end
+end