axiom-optimizer 0.1.0 → 0.1.1

data/spec/integration/axiom/function/connective/negation/optimize_spec.rb

@@ -28,7 +28,7 @@ describe Function::Connective::Negation, '#optimize' do
   context 'operand is a tautology' do
     let(:operand) { Function::Proposition::Tautology.instance }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -36,7 +36,7 @@ describe Function::Connective::Negation, '#optimize' do
   context 'operand is a contradiction' do
     let(:operand) { Function::Proposition::Contradiction.instance }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/axiom/function/optimize_spec.rb

@@ -23,7 +23,7 @@ describe Function, '#optimize' do
   end
 
   it 'returns self' do
-    should equal(object)
+    should be(object)
   end
 
   it_should_behave_like 'an optimize method'

data/spec/integration/axiom/function/predicate/equality/optimize_spec.rb

@@ -12,7 +12,7 @@ describe Function::Predicate::Equality, '#optimize' do
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,7 +20,7 @@ describe Function::Predicate::Equality, '#optimize' do
     context 'and are not joinable' do
       let(:right) { Attribute::String.new(:other) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -28,7 +28,7 @@ describe Function::Predicate::Equality, '#optimize' do
     context 'and are joinable' do
       let(:right) { Attribute::Integer.new(:other) }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -38,7 +38,7 @@ describe Function::Predicate::Equality, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 1 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -46,7 +46,7 @@ describe Function::Predicate::Equality, '#optimize' do
     context 'right is an invalid value' do
       let(:right) { 'a' }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -64,7 +64,7 @@ describe Function::Predicate::Equality, '#optimize' do
     context 'left is an invalid value' do
       let(:left) { 'a' }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -75,7 +75,7 @@ describe Function::Predicate::Equality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -84,7 +84,7 @@ describe Function::Predicate::Equality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/function/predicate/exclusion/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Function::Predicate::Exclusion, '#optimize' do
   subject { object.optimize }
 
-  let(:left)   { Attribute::Integer.new(:id, :size => 1..2**31-1) }
-  let(:object) { described_class.new(left, right)                 }
+  let(:left)   { Attribute::Integer.new(:id, size: 1..2**31 - 1) }
+  let(:object) { described_class.new(left, right)                }
 
   context 'right is a Range' do
     context 'that is inclusive' do
       context 'and empty' do
         let(:right) { 1..0 }
 
-        it { should equal(Function::Proposition::Tautology.instance) }
+        it { should be(Function::Proposition::Tautology.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -21,7 +21,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
       context 'and not empty' do
         let(:right) { 1..10 }
 
-        it { should equal(object) }
+        it { should be(object) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -31,7 +31,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
       context 'and empty' do
         let(:right) { 1...1 }
 
-        it { should equal(Function::Proposition::Tautology.instance) }
+        it { should be(Function::Proposition::Tautology.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -51,7 +51,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
       let(:left)  { Attribute::String.new(:string) }
       let(:right) { 'a'..'z'                       }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -59,7 +59,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
     context 'that is greater than the left range' do
       let(:right) { 2**31..2**31 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -67,7 +67,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
     context 'that is less than the left range' do
       let(:right) { -1..-1 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -77,37 +77,37 @@ describe Function::Predicate::Exclusion, '#optimize' do
     context 'that is empty' do
       let(:right) { [] }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that is empty after filtering invalid entries' do
-      let(:right) { [ 'a' ] }
+      let(:right) { ['a'] }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that is not empty after filtering invalid entries' do
-      let(:right) { [ 'a', 1, 2 ] }
+      let(:right) { ['a', 1, 2] }
 
-      it { should eql(left.exclude([ 1, 2 ])) }
+      it { should eql(left.exclude([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that has duplicate entries' do
-      let(:right) { [ 1, 2, 2 ] }
+      let(:right) { [1, 2, 2] }
 
-      it { should eql(left.exclude([ 1, 2 ])) }
+      it { should eql(left.exclude([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that has one entry' do
-      let(:right) { [ 1 ] }
+      let(:right) { [1] }
 
       it { should eql(left.ne(1)) }
 
@@ -115,9 +115,9 @@ describe Function::Predicate::Exclusion, '#optimize' do
     end
 
     context 'that has unsorted entries' do
-      let(:right) { [ 2, 1 ] }
+      let(:right) { [2, 1] }
 
-      it { should eql(left.exclude([ 1, 2 ])) }
+      it { should eql(left.exclude([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -126,7 +126,7 @@ describe Function::Predicate::Exclusion, '#optimize' do
   context 'right is a nil' do
     let(:right) { nil }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/axiom/function/predicate/greater_than/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Function::Predicate::GreaterThan, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
-  let(:left)      { attribute                                                            }
-  let(:right)     { attribute                                                            }
-  let(:object)    { described_class.new(left, right)                                     }
+  let(:attribute) { Attribute::Integer.new(:id, required: false, size: 1..2**31 - 1) }
+  let(:left)      { attribute                                                        }
+  let(:right)     { attribute                                                        }
+  let(:object)    { described_class.new(left, right)                                 }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,25 +20,25 @@ describe Function::Predicate::GreaterThan, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always less than or equal to right' do
-      let(:left)  { attribute                                                 }
-      let(:right) { Attribute::Integer.new(:right, :size => 2**31-1..2**31-1) }
+      let(:left)  { attribute                                                  }
+      let(:right) { Attribute::Integer.new(:right, size: 2**31 - 1..2**31 - 1) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always greater than right' do
-      let(:left)  { attribute                                       }
-      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+      let(:left)  { attribute                                    }
+      let(:right) { Attribute::Integer.new(:right, size: -1..-1) }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -48,7 +48,7 @@ describe Function::Predicate::GreaterThan, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 1 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -56,7 +56,7 @@ describe Function::Predicate::GreaterThan, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -74,7 +74,7 @@ describe Function::Predicate::GreaterThan, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -85,7 +85,7 @@ describe Function::Predicate::GreaterThan, '#optimize' do
       let(:left)  { 2 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -94,7 +94,7 @@ describe Function::Predicate::GreaterThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/function/predicate/greater_than_or_equal_to/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
-  let(:left)      { attribute                                                            }
-  let(:right)     { attribute                                                            }
-  let(:object)    { described_class.new(left, right)                                     }
+  let(:attribute) { Attribute::Integer.new(:id, required: false, size: 1..2**31 - 1) }
+  let(:left)      { attribute                                                        }
+  let(:right)     { attribute                                                        }
+  let(:object)    { described_class.new(left, right)                                 }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -20,25 +20,25 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always less than right' do
-      let(:left)  { attribute                                             }
-      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+      let(:left)  { attribute                                          }
+      let(:right) { Attribute::Integer.new(:right, size: 2**31..2**31) }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'and left is always greater than right' do
-      let(:left)  { attribute                                       }
-      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+      let(:left)  { attribute                                    }
+      let(:right) { Attribute::Integer.new(:right, size: -1..-1) }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -48,7 +48,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'right is a valid value' do
       let(:right) { 2 }
 
-      it { should equal(object) }
+      it { should be(object) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -56,7 +56,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -74,7 +74,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -85,7 +85,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Function::Proposition::Tautology.instance) }
+      it { should be(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -94,7 +94,7 @@ describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/axiom/function/predicate/inclusion/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Function::Predicate::Inclusion, '#optimize' do
   subject { object.optimize }
 
-  let(:left)   { Attribute::Integer.new(:id, :size => 1..2**31-1) }
-  let(:object) { described_class.new(left, right)                 }
+  let(:left)   { Attribute::Integer.new(:id, size: 1..2**31 - 1) }
+  let(:object) { described_class.new(left, right)                }
 
   context 'right is a Range' do
     context 'that is inclusive' do
       context 'and empty' do
         let(:right) { 1..0 }
 
-        it { should equal(Function::Proposition::Contradiction.instance) }
+        it { should be(Function::Proposition::Contradiction.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -21,7 +21,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
       context 'and not empty' do
         let(:right) { 1..10 }
 
-        it { should equal(object) }
+        it { should be(object) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -31,7 +31,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
       context 'and empty' do
         let(:right) { 1...1 }
 
-        it { should equal(Function::Proposition::Contradiction.instance) }
+        it { should be(Function::Proposition::Contradiction.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -51,7 +51,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
       let(:left)  { Attribute::String.new(:string) }
       let(:right) { 'a'..'z'                       }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -59,7 +59,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
     context 'that is greater than the left range' do
       let(:right) { 2**31..2**31 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -67,7 +67,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
     context 'that is less than the left range' do
       let(:right) { -1..-1 }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -77,37 +77,37 @@ describe Function::Predicate::Inclusion, '#optimize' do
     context 'that is empty' do
       let(:right) { [] }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that is empty after filtering invalid entries' do
-      let(:right) { [ 'a' ] }
+      let(:right) { ['a'] }
 
-      it { should equal(Function::Proposition::Contradiction.instance) }
+      it { should be(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that is not empty after filtering invalid entries' do
-      let(:right) { [ 'a', 1, 2 ] }
+      let(:right) { ['a', 1, 2] }
 
-      it { should eql(left.include([ 1, 2 ])) }
+      it { should eql(left.include([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that has duplicate entries' do
-      let(:right) { [ 1, 2, 2 ] }
+      let(:right) { [1, 2, 2] }
 
-      it { should eql(left.include([ 1, 2 ])) }
+      it { should eql(left.include([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
 
     context 'that has one entry' do
-      let(:right) { [ 1 ] }
+      let(:right) { [1] }
 
       it { should eql(left.eq(1)) }
 
@@ -115,9 +115,9 @@ describe Function::Predicate::Inclusion, '#optimize' do
     end
 
     context 'that has unsorted entries' do
-      let(:right) { [ 2, 1 ] }
+      let(:right) { [2, 1] }
 
-      it { should eql(left.include([ 1, 2 ])) }
+      it { should eql(left.include([1, 2])) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -126,7 +126,7 @@ describe Function::Predicate::Inclusion, '#optimize' do
   context 'right is a nil' do
     let(:right) { nil }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end