axiom 0.1.0 → 0.1.1

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

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

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

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

data/spec/unit/axiom/function/numeric/unary_minus/methods/unary_minus_spec.rb

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

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

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

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

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

data/spec/unit/axiom/function/numeric/unary_plus/methods/unary_plus_spec.rb

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

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

@@ -6,13 +6,13 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Function::Predicate, '#call' do
   subject { object.call(tuple) }
 
-  let(:header) { Relation::Header.coerce([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                      }
-  let(:object) { described_class.new(header[:id], 1)           }
+  let(:header) { Relation::Header.coerce([[:id, Integer]]) }
+  let(:tuple)  { Tuple.new(header, [1])                    }
+  let(:object) { described_class.new(header[:id], 1)       }
 
   it 'sends the left and right value to self.class.call' do
-    response = mock('#call response')
+    response = double('#call response')
     described_class.should_receive(:call).with(1, 1).and_return(response)
-    should equal(response)
+    should be(response)
   end
 end

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

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

data/spec/unit/axiom/function/predicate/enumerable/call_spec.rb

@@ -6,31 +6,31 @@ describe Function::Predicate::Enumerable, '#call' do
   subject { object.call(tuple) }
 
   let(:described_class) { Class.new(Function) { include Function::Binary } }
-  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ])    }
-  let(:tuple)           { Tuple.new(header, [ 1 ])                         }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]])        }
+  let(:tuple)           { Tuple.new(header, [1])                           }
 
   before do
     described_class.class_eval { include Function::Predicate::Enumerable }
   end
 
   context 'with an enumerable of non-callable objects' do
-    let(:object) { described_class.new(header[:id], [ 1 ]) }
+    let(:object) { described_class.new(header[:id], [1]) }
 
     it 'sends the left and right value to self.class.call' do
-      response = mock('#call response')
-      described_class.should_receive(:call).with(1, [ 1 ]).and_return(response)
-      should equal(response)
+      response = double('#call response')
+      described_class.should_receive(:call).with(1, [1]).and_return(response)
+      should be(response)
     end
   end
 
   context 'with an enumerable of callable objects' do
-    let(:callable) { proc { 1 }                                     }
-    let(:object)   { described_class.new(header[:id], [ callable ]) }
+    let(:callable) { proc { 1 }                                   }
+    let(:object)   { described_class.new(header[:id], [callable]) }
 
     it 'sends the left and right value to self.class.call' do
-      response = mock('#call response')
-      described_class.should_receive(:call).with(1, [ 1 ]).and_return(response)
-      should equal(response)
+      response = double('#call response')
+      described_class.should_receive(:call).with(1, [1]).and_return(response)
+      should be(response)
     end
   end
 end

data/spec/unit/axiom/function/predicate/enumerable/class_methods/compare_method_spec.rb

@@ -14,7 +14,7 @@ describe Function::Predicate::Enumerable, '.compare_method' do
   end
 
   context 'the enumerable is an Array' do
-    let(:enumerable) { [ 1, 2 ] }
+    let(:enumerable) { [1, 2] }
 
     it { should == :include? }
   end

data/spec/unit/axiom/function/predicate/equality/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/equality/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::Equality, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(object) }
+  it { should be(object) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::Equality, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::Inequality) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/exclusion/class_methods/call_spec.rb

@@ -8,15 +8,15 @@ describe Function::Predicate::Exclusion, '.call' do
   let(:object) { described_class }
 
   context 'when left is excluded from right' do
-    let(:left)  { 1     }
-    let(:right) { [ 0 ] }
+    let(:left)  { 1   }
+    let(:right) { [0] }
 
     it { should be(true) }
   end
 
   context 'when left is not excluded from right' do
-    let(:left)  { 1     }
-    let(:right) { [ 1 ] }
+    let(:left)  { 1   }
+    let(:right) { [1] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/function/predicate/exclusion/class_methods/inverse_spec.rb

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

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

@@ -6,14 +6,14 @@ describe Function::Predicate::Exclusion, '#inverse' do
   subject { object.inverse }
 
   let(:attribute)  { Attribute::Integer.new(:id)                }
-  let(:enumerable) { [ 1 ].freeze                               }
+  let(:enumerable) { [1].freeze                                 }
   let(:object)     { described_class.new(attribute, enumerable) }
 
   it_should_behave_like 'an invertible method'
 
   it { should be_instance_of(Function::Predicate::Inclusion) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
-  its(:right) { should equal(enumerable) }
+  its(:right) { should be(enumerable) }
 end

data/spec/unit/axiom/function/predicate/exclusion/methods/exclude_spec.rb

@@ -7,7 +7,7 @@ describe Function::Predicate::Exclusion::Methods, '#exclude' do
   subject { object.exclude(other) }
 
   let(:described_class) { ExclusionMethodsSpecs::Object }
-  let(:other)           { [ true, false ]               }
+  let(:other)           { [true, false]                 }
   let(:object)          { described_class.new           }
 
   it { should be_instance_of(Function::Predicate::Exclusion) }

data/spec/unit/axiom/function/predicate/greater_than/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/greater_than/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::GreaterThan, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Function::Predicate::LessThan) }
+  it { should be(Function::Predicate::LessThan) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::GreaterThan, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::LessThanOrEqualTo) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/greater_than_or_equal_to/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/greater_than_or_equal_to/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::GreaterThanOrEqualTo, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Function::Predicate::LessThanOrEqualTo) }
+  it { should be(Function::Predicate::LessThanOrEqualTo) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::LessThan) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/inclusion/class_methods/call_spec.rb

@@ -8,15 +8,15 @@ describe Function::Predicate::Inclusion, '.call' do
   let(:object) { described_class }
 
   context 'when left is included in right' do
-    let(:left)  { 1     }
-    let(:right) { [ 1 ] }
+    let(:left)  { 1   }
+    let(:right) { [1] }
 
     it { should be(true) }
   end
 
   context 'when left is not included in right' do
-    let(:left)  { 1     }
-    let(:right) { [ 0 ] }
+    let(:left)  { 1   }
+    let(:right) { [0] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/function/predicate/inclusion/class_methods/inverse_spec.rb

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

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

@@ -6,14 +6,14 @@ describe Function::Predicate::Inclusion, '#inverse' do
   subject { object.inverse }
 
   let(:attribute)  { Attribute::Integer.new(:id)                }
-  let(:enumerable) { [ 1 ].freeze                               }
+  let(:enumerable) { [1].freeze                                 }
   let(:object)     { described_class.new(attribute, enumerable) }
 
   it_should_behave_like 'an invertible method'
 
   it { should be_instance_of(Function::Predicate::Exclusion) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
-  its(:right) { should equal(enumerable) }
+  its(:right) { should be(enumerable) }
 end

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

@@ -7,7 +7,7 @@ describe Function::Predicate::Inclusion::Methods, '#include' do
   subject { object.include(other) }
 
   let(:described_class) { InclusionMethodsSpecs::Object }
-  let(:other)           { [ true, false ]               }
+  let(:other)           { [true, false]                 }
   let(:object)          { described_class.new           }
 
   it { should be_instance_of(Function::Predicate::Inclusion) }

data/spec/unit/axiom/function/predicate/inequality/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/inequality/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::Inequality, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Function::Predicate::Inequality) }
+  it { should be(Function::Predicate::Inequality) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::Inequality, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::Equality) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/less_than/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/less_than/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::LessThan, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Function::Predicate::GreaterThan) }
+  it { should be(Function::Predicate::GreaterThan) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::LessThan, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::GreaterThanOrEqualTo) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/less_than_or_equal_to/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/less_than_or_equal_to/class_methods/reverse_spec.rb

@@ -7,5 +7,5 @@ describe Function::Predicate::LessThanOrEqualTo, '.reverse' do
 
   let(:object) { described_class }
 
-  it { should equal(Function::Predicate::GreaterThanOrEqualTo) }
+  it { should be(Function::Predicate::GreaterThanOrEqualTo) }
 end

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

@@ -12,7 +12,7 @@ describe Function::Predicate::LessThanOrEqualTo, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::GreaterThan) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/function/predicate/match/class_methods/inverse_spec.rb

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

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

@@ -13,7 +13,7 @@ describe Function::Predicate::Match, '#inverse' do
 
   it { should be_instance_of(Function::Predicate::NoMatch) }
 
-  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/predicate/no_match/class_methods/inverse_spec.rb

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