axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/function/class_methods/extract_value_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Function, '.extract_value' do
   subject { object.extract_value(operand, tuple) }
 
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                      }
-  let(:object) { described_class                               }
+  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
+  let(:tuple)  { Tuple.new(header, [1])                    }
+  let(:object) { described_class                           }
 
   context 'when the operand responds to #call' do
     let(:operand) { header[:id] }
@@ -16,8 +16,8 @@ describe Function, '.extract_value' do
   end
 
   context 'when the operand does not respond to #call' do
-    let(:operand) { mock('Value') }
+    let(:operand) { double('Value') }
 
-    it { should equal(operand) }
+    it { should be(operand) }
   end
 end

data/spec/unit/axiom/function/class_methods/rename_attributes_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Function, '.rename_attributes' do
   subject { object.rename_attributes(operand, aliases) }
 
-  let(:object)  { described_class                                           }
-  let(:header)  { Relation::Header.coerce([ [ :id, Integer ] ])             }
-  let(:aliases) { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
+  let(:object)  { described_class                                        }
+  let(:header)  { Relation::Header.coerce([[:id, Integer]])              }
+  let(:aliases) { Algebra::Rename::Aliases.coerce(header, id: :other_id) }
 
   context 'with an attribute' do
     let(:operand) { header[:id] }

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe Function, '.type' do
+  subject { object.type }
+
+  let(:object) { FunctionSpecs::Object }
+
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{object}.type is not implemented") }
+end

data/spec/unit/axiom/function/comparable/class_methods/included_spec.rb

@@ -16,11 +16,11 @@ describe Function::Comparable, '.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/connective/class_methods/type_spec.rb

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

data/spec/unit/axiom/function/connective/conjunction/methods/and_spec.rb

@@ -3,14 +3,14 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-[ :and, :& ].each do |method|
+[:and, :&].each do |method|
   describe Function::Connective::Conjunction::Methods, "##{method}" do
     subject { object.send(method, predicate) }
 
-    let(:described_class) { ConjunctionMethodsSpecs::Object               }
-    let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ]) }
-    let(:predicate)       { header[:id].eq(1)                             }
-    let(:object)          { described_class.new.freeze                    }
+    let(:described_class) { ConjunctionMethodsSpecs::Object           }
+    let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+    let(:predicate)       { header[:id].eq(1)                         }
+    let(:object)          { described_class.new.freeze                }
 
     it 'returns a conjunction of the proposition and predicate' do
       should eql(Function::Connective::Conjunction.new(object, predicate))

data/spec/unit/axiom/function/connective/disjunction/methods/or_spec.rb

@@ -3,14 +3,14 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-[ :or, :| ].each do |method|
+[:or, :|].each do |method|
   describe Function::Connective::Disjunction::Methods, "##{method}" do
     subject { object.send(method, predicate) }
 
-    let(:described_class) { DisjunctionMethodsSpecs::Object               }
-    let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ]) }
-    let(:predicate)       { header[:id].eq(1)                             }
-    let(:object)          { described_class.new.freeze                    }
+    let(:described_class) { DisjunctionMethodsSpecs::Object           }
+    let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+    let(:predicate)       { header[:id].eq(1)                         }
+    let(:object)          { described_class.new.freeze                }
 
     it 'returns a disjunction of the proposition and predicate' do
       should eql(Function::Connective::Disjunction.new(object, predicate))

data/spec/unit/axiom/function/connective/negation/class_methods/operation_spec.rb

@@ -7,5 +7,5 @@ describe Function::Connective::Negation, '.operation' do
 
   let(:object) { described_class }
 
-  it { should equal(:'!') }
+  it { should be(:'!') }
 end

data/spec/unit/axiom/function/connective/negation/inverse_spec.rb

@@ -12,7 +12,7 @@ describe Function::Connective::Negation, '#inverse' do
   it_should_behave_like 'an idempotent method'
 
   it 'returns the operand' do
-    should equal(operand)
+    should be(operand)
   end
 
   it 'is not invertible' do

data/spec/unit/axiom/function/connective/negation/methods/not_spec.rb

@@ -3,11 +3,11 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-[ :not, :- ].each do |method|
+[:not, :-].each do |method|
   describe Function::Connective::Negation::Methods, "##{method}" do
-    let(:described_class) { NegationMethodsSpecs::Object                  }
-    let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ]) }
-    let(:object)          { described_class.new                           }
+    let(:described_class) { NegationMethodsSpecs::Object              }
+    let(:header)          { Relation::Header.coerce([[:id, Integer]]) }
+    let(:object)          { described_class.new                       }
 
     before do
       def object.eql?(other)
@@ -21,7 +21,7 @@ require File.expand_path('../fixtures/classes', __FILE__)
 
       it { should be_instance_of(Function::Connective::Negation) }
 
-      its(:operand) { should equal(object) }
+      its(:operand) { should be(object) }
     end
 
     context 'when a function is provided' do
@@ -31,7 +31,7 @@ require File.expand_path('../fixtures/classes', __FILE__)
 
       it { should be_instance_of(Function::Connective::Conjunction) }
 
-      its(:left) { should equal(object) }
+      its(:left) { should be(object) }
 
       its(:right) { should eql(Function::Connective::Negation.new(predicate)) }
     end

data/spec/unit/axiom/function/numeric/absolute/class_methods/operation_spec.rb

@@ -7,5 +7,5 @@ describe Function::Numeric::Absolute, '.operation' do
 
   let(:object) { described_class }
 
-  it { should equal(:abs) }
+  it { should be(:abs) }
 end

data/spec/unit/axiom/function/numeric/absolute/methods/absolute_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :absolute, :abs ].each do |method|
+[:absolute, :abs].each do |method|
   describe Function::Numeric::Absolute::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Function::Numeric::Absolute) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

data/spec/unit/axiom/function/numeric/addition/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/numeric/addition/methods/add_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :add, :+ ].each do |method|
+[:add, :+].each do |method|
   describe Function::Numeric::Addition::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Addition::Methods } }
     let(:object)          { described_class.new.freeze                                 }
-    let(:other)           { mock('Other').freeze                                       }
+    let(:other)           { double('Other').freeze                                     }
 
     it { should be_instance_of(Function::Numeric::Addition) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end

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

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

data/spec/unit/axiom/function/numeric/division/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/numeric/division/class_methods/type_spec.rb

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

data/spec/unit/axiom/function/numeric/division/methods/divide_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :divide, :/ ].each do |method|
+[:divide, :/].each do |method|
   describe Function::Numeric::Division::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Division::Methods } }
     let(:object)          { described_class.new.freeze                                 }
-    let(:other)           { mock('Other').freeze                                       }
+    let(:other)           { double('Other').freeze                                     }
 
     it { should be_instance_of(Function::Numeric::Division) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end

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

@@ -7,5 +7,5 @@ describe Function::Numeric::Division, '#type' do
 
   let(:object) { described_class.new(1, 1) }
 
-  it { should equal(Attribute::Float) }
+  it { should be(Types::Float) }
 end

data/spec/unit/axiom/function/numeric/exponentiation/inverse_spec.rb

@@ -13,6 +13,6 @@ describe Function::Numeric::Exponentiation, '#inverse' do
 
   it { should be_instance_of(Function::Numeric::Exponentiation) }
 
-  its(:left)  { should equal(left)                                    }
+  its(:left)  { should be(left)                                       }
   its(:right) { should eql(Function::Numeric::Division.new(1, right)) }
 end

data/spec/unit/axiom/function/numeric/exponentiation/methods/exponent_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :exponent, :**, :pow ].each do |method|
+[:exponent, :**, :pow].each do |method|
   describe Function::Numeric::Exponentiation::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Exponentiation::Methods } }
     let(:object)          { described_class.new.freeze                                       }
-    let(:other)           { mock('Other').freeze                                             }
+    let(:other)           { double('Other').freeze                                           }
 
     it { should be_instance_of(Function::Numeric::Exponentiation) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end

data/spec/unit/axiom/function/numeric/modulo/methods/modulo_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :modulo, :mod, :% ].each do |method|
+[:modulo, :mod, :%].each do |method|
   describe Function::Numeric::Modulo::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Modulo::Methods } }
     let(:object)          { described_class.new.freeze                               }
-    let(:other)           { mock('Other').freeze                                     }
+    let(:other)           { double('Other').freeze                                   }
 
     it { should be_instance_of(Function::Numeric::Modulo) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end

data/spec/unit/axiom/function/numeric/multiplication/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/numeric/multiplication/methods/multiply_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :multiply, :* ].each do |method|
+[:multiply, :*].each do |method|
   describe Function::Numeric::Multiplication::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Multiplication::Methods } }
     let(:object)          { described_class.new.freeze                                       }
-    let(:other)           { mock('Other').freeze                                             }
+    let(:other)           { double('Other').freeze                                           }
 
     it { should be_instance_of(Function::Numeric::Multiplication) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end

data/spec/unit/axiom/function/numeric/square_root/class_methods/type_spec.rb

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

data/spec/unit/axiom/function/numeric/square_root/methods/square_root_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[ :square_root, :sqrt ].each do |method|
+[:square_root, :sqrt].each do |method|
   describe Function::Numeric::SquareRoot::Methods, "##{method}" do
     subject { object.send(method) }
 
@@ -11,6 +11,6 @@ require 'spec_helper'
 
     it { should be_instance_of(Function::Numeric::SquareRoot) }
 
-    its(:operand) { should equal(object) }
+    its(:operand) { should be(object) }
   end
 end

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

@@ -7,5 +7,5 @@ describe Function::Numeric::SquareRoot, '#type' do
 
   let(:object) { described_class.new(4) }
 
-  it { should equal(Attribute::Float) }
+  it { should be(Types::Float) }
 end

data/spec/unit/axiom/function/numeric/subtraction/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/numeric/subtraction/methods/subtract_spec.rb

@@ -2,18 +2,18 @@
 
 require 'spec_helper'
 
-[ :subtract, :- ].each do |method|
+[:subtract, :-].each do |method|
   describe Function::Numeric::Subtraction::Methods, "##{method}" do
     subject { object.send(method, other) }
 
     let(:described_class) { Class.new { include Function::Numeric::Subtraction::Methods } }
     let(:object)          { described_class.new.freeze                                    }
-    let(:other)           { mock('Other').freeze                                          }
+    let(:other)           { double('Other').freeze                                        }
 
     it { should be_instance_of(Function::Numeric::Subtraction) }
 
-    its(:left) { should equal(object) }
+    its(:left) { should be(object) }
 
-    its(:right) { should equal(other) }
+    its(:right) { should be(other) }
   end
 end