axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/function/predicate/less_than_or_equal_to/contradiction/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::LessThanOrEqualTo::Contradiction, '#opt
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::LessThanOrEqualTo)
+    expect(predicate).to be_kind_of(Function::Predicate::LessThanOrEqualTo)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::LessThanOrEqualTo::Contradiction, '#opt
   end
 
   context 'when left is always greater than right' do
-    let(:left)  { Attribute::Integer.new(:id, :size => 10..20) }
-    let(:right) { Attribute::Integer.new(:id, :size => 1..9)   }
+    let(:left)  { Attribute::Integer.new(:id, size: 10..20) }
+    let(:right) { Attribute::Integer.new(:id, size: 1..9)   }
 
     it { should be(true) }
   end

data/spec/unit/axiom/optimizer/function/predicate/less_than_or_equal_to/tautology/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::LessThanOrEqualTo::Tautology, '#optimiz
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::LessThanOrEqualTo)
+    expect(predicate).to be_kind_of(Function::Predicate::LessThanOrEqualTo)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::LessThanOrEqualTo::Tautology, '#optimiz
   end
 
   context 'when left is always less than right' do
-    let(:left)  { Attribute::Integer.new(:id, :size => 1..9)   }
-    let(:right) { Attribute::Integer.new(:id, :size => 10..20) }
+    let(:left)  { Attribute::Integer.new(:id, size: 1..9)   }
+    let(:right) { Attribute::Integer.new(:id, size: 10..20) }
 
     it { should be(true) }
   end

data/spec/unit/axiom/optimizer/function/predicate/tautology/optimize_spec.rb

@@ -14,5 +14,5 @@ describe Optimizer::Function::Predicate::Tautology, '#optimize' do
     described_class.class_eval { include Optimizer::Function::Predicate::Tautology }
   end
 
-  it { should equal(Function::Proposition::Tautology.instance) }
+  it { should be(Function::Proposition::Tautology.instance) }
 end

data/spec/unit/axiom/optimizer/function/unary/constant_operand/optimize_spec.rb

@@ -11,7 +11,7 @@ describe Optimizer::Function::Unary::ConstantOperand, '#optimize' do
 
   before do
     described_class.class_eval { include Optimizer::Function::Unary::ConstantOperand }
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be(1) }

data/spec/unit/axiom/optimizer/function/unary/operand_spec.rb

@@ -12,13 +12,13 @@ describe Optimizer::Function::Unary, '#operand' do
   context 'when the operand is frozen' do
     let(:operand) { 'Operand'.freeze }
 
-    it { should equal(operand) }
+    it { should be(operand) }
   end
 
   context 'when the operand is not frozen' do
     let(:operand) { 'Operand' }
 
-    it { should_not equal(operand) }
+    it { should_not be(operand) }
 
     it { should be_frozen }
 

data/spec/unit/axiom/optimizer/function/unary/unoptimized_operand/optimize_spec.rb

@@ -11,7 +11,7 @@ describe Optimizer::Function::Unary::UnoptimizedOperand, '#optimize' do
 
   before do
     described_class.class_eval { include Optimizer::Function::Unary::UnoptimizedOperand }
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should eql(Function::Numeric::Absolute.new(1)) }

data/spec/unit/axiom/optimizer/function/util/class_methods/max_spec.rb

@@ -8,13 +8,13 @@ describe Optimizer::Function::Util, '.max' do
   let(:object) { Optimizer::Function::Util }
 
   context 'with an Integer attribute' do
-    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+    let(:operand) { Attribute::Integer.new(:id, size: 1..10) }
 
     it { should == 10 }
   end
 
   context 'with a String attribute' do
-    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+    let(:operand) { Attribute::String.new(:id, min_length: 1, max_length: 10) }
 
     it { should == 10 }
   end

data/spec/unit/axiom/optimizer/function/util/class_methods/min_spec.rb

@@ -8,13 +8,13 @@ describe Optimizer::Function::Util, '.min' do
   let(:object) { Optimizer::Function::Util }
 
   context 'with an Integer attribute' do
-    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+    let(:operand) { Attribute::Integer.new(:id, size: 1..10) }
 
     it { should == 1 }
   end
 
   context 'with a String attribute' do
-    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+    let(:operand) { Attribute::String.new(:id, min_length: 1, max_length: 10) }
 
     it { should == 1 }
   end

data/spec/unit/axiom/optimizer/operation_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer, '#operation' do
   subject { object.operation }
 
   let(:described_class) { Class.new(Optimizer)           }
-  let(:operation)       { mock('Operation')              }
+  let(:operation)       { double('Operation')            }
   let(:object)          { described_class.new(operation) }
 
-  it { should equal(operation) }
+  it { should be(operation) }
 end

data/spec/unit/axiom/optimizer/optimizable/class_methods/optimizer_spec.rb

@@ -12,20 +12,20 @@ describe Optimizer::Optimizable::ClassMethods, '#optimizer' do
   end
 
   context 'when the optimizer is set' do
-    let(:optimizer) { mock('Optimizer') }
+    let(:optimizer) { double('Optimizer') }
 
     before do
       object.optimizer = optimizer
     end
 
-    it { should equal(optimizer) }
+    it { should be(optimizer) }
   end
 end
 
 describe Optimizer::Optimizable::ClassMethods, '#optimizer=' do
   subject { object.optimizer = optimizer }
 
-  let(:optimizer) { mock('Optimizer')                                        }
+  let(:optimizer) { double('Optimizer')                                      }
   let(:object)    { Class.new { include Optimizer::Optimizable, Adamantium } }
 
   it 'sets the optimizer' do

data/spec/unit/axiom/optimizer/optimizable/optimize_spec.rb

@@ -9,30 +9,30 @@ describe Optimizer::Optimizable, '#optimize' do
   let(:object)          { described_class.new                                      }
 
   context 'when there is no optimizer for the class' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'when there is an optimizer for the class' do
-    let(:optimized) { mock('Optimized', :frozen? => true)   }
-    let(:optimizer) { mock('Optimizer', :call => optimized) }
+    let(:optimized) { double('Optimized', :frozen? => true) }
+    let(:optimizer) { double('Optimizer', call: optimized)  }
 
     before do
       described_class.optimizer = optimizer
-      optimized.stub!(:optimize).and_return(optimized)
+      optimized.stub(:optimize).and_return(optimized)
     end
 
-    it { should equal(optimized) }
+    it { should be(optimized) }
 
     it 'calls the optimizer with the object' do
       optimizer.should_receive(:call).with(object).and_return(optimized)
-      should equal(optimized)
+      should be(optimized)
     end
 
     it '#optimize the optimized object' do
       optimized.should_receive(:optimize).with(no_args).and_return(optimized)
-      should equal(optimized)
+      should be(optimized)
     end
   end
 end

data/spec/unit/axiom/optimizer/optimizable_predicate_spec.rb

@@ -6,11 +6,11 @@ describe Optimizer, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:described_class) { Class.new(Optimizer)           }
-  let(:operation)       { mock('Operation')              }
+  let(:operation)       { double('Operation')            }
   let(:object)          { described_class.new(operation) }
 
   before do
-    described_class.stub!(:to_s).and_return('Optimizer')
+    described_class.stub(:to_s).and_return('Optimizer')
   end
 
   specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimizable? must be implemented') }

data/spec/unit/axiom/optimizer/optimize_spec.rb

@@ -6,11 +6,11 @@ describe Optimizer, '#optimize' do
   subject { object.optimize }
 
   let(:described_class) { Class.new(Optimizer)           }
-  let(:operation)       { mock('Operation')              }
+  let(:operation)       { double('Operation')            }
   let(:object)          { described_class.new(operation) }
 
   before do
-    described_class.stub!(:to_s).and_return('Optimizer')
+    described_class.stub(:to_s).and_return('Optimizer')
   end
 
   specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimize must be implemented') }

data/spec/unit/axiom/optimizer/predicate_partition/left_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::PredicatePartition, '#left' do
   subject { object.left }
 
-  let(:left_header)  { Relation::Header.coerce([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
-  let(:right_header) { Relation::Header.coerce([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
-  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                            }
+  let(:left_header)  { Relation::Header.coerce([[:id, Integer], [:user_name, String], Attribute::Boolean.new(:active_user), Attribute::Boolean.new(:active)])         }
+  let(:right_header) { Relation::Header.coerce([[:id, Integer], [:employee_name, String], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active)]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                      }
 
   context 'when the predicate is a tautology' do
     let(:predicate) { Function::Proposition::Tautology.instance }
 
     it 'partitions the predicate to the left' do
-      should equal(Function::Proposition::Tautology.instance)
+      should be(Function::Proposition::Tautology.instance)
     end
   end
 
@@ -21,7 +21,7 @@ describe Optimizer::PredicatePartition, '#left' do
     let(:predicate) { Function::Proposition::Contradiction.instance }
 
     it 'partitions the predicate to the left' do
-      should equal(Function::Proposition::Contradiction.instance)
+      should be(Function::Proposition::Contradiction.instance)
     end
   end
 
@@ -30,7 +30,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:active_user] }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -38,7 +38,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { right_header[:active_employee] }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -46,7 +46,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:active] }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
   end
@@ -56,7 +56,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -64,7 +64,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -72,7 +72,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:id].eq(1) }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -80,7 +80,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -88,7 +88,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -96,7 +96,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
   end
@@ -106,7 +106,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
 
@@ -114,7 +114,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
 
       it 'does not partition the predicate to the left' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -122,7 +122,7 @@ describe Optimizer::PredicatePartition, '#left' do
       let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
 
       it 'partitions the predicate to the left' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
   end
@@ -133,7 +133,7 @@ describe Optimizer::PredicatePartition, '#left' do
     let(:predicate)       { left_predicate.and(right_predicate)         }
 
     it 'partitions the predicate to the left that reference the left header' do
-      should equal(left_predicate)
+      should be(left_predicate)
     end
   end
 

data/spec/unit/axiom/optimizer/predicate_partition/remainder_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::PredicatePartition, '#remainder' do
   subject { object.remainder }
 
-  let(:left_header)  { Relation::Header.coerce([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
-  let(:right_header) { Relation::Header.coerce([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
-  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                            }
+  let(:left_header)  { Relation::Header.coerce([[:id, Integer], [:user_name, String], Attribute::Boolean.new(:active_user), Attribute::Boolean.new(:active)])         }
+  let(:right_header) { Relation::Header.coerce([[:id, Integer], [:employee_name, String], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active)]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                      }
 
   context 'when the predicate is a tautology' do
     let(:predicate) { Function::Proposition::Tautology.instance }
 
     it 'partitions the predicate to the remainder' do
-      should equal(Function::Proposition::Tautology.instance)
+      should be(Function::Proposition::Tautology.instance)
     end
   end
 
@@ -21,7 +21,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
     let(:predicate) { Function::Proposition::Contradiction.instance }
 
     it 'partitions the predicate to the remainder' do
-      should equal(Function::Proposition::Contradiction.instance)
+      should be(Function::Proposition::Contradiction.instance)
     end
   end
 
@@ -30,7 +30,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:active_user] }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -38,7 +38,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { right_header[:active_employee] }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -46,7 +46,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:active] }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
   end
@@ -56,7 +56,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -64,7 +64,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -72,7 +72,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:id].eq(1) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -80,7 +80,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -88,7 +88,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -96,7 +96,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
 
       it 'partitions the predicate to the remainder' do
-        should equal(predicate)
+        should be(predicate)
       end
     end
   end
@@ -106,7 +106,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -114,7 +114,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
 
@@ -122,7 +122,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
       let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
 
       it 'does not partition the predicate to the remainder' do
-        should equal(Function::Proposition::Tautology.instance)
+        should be(Function::Proposition::Tautology.instance)
       end
     end
   end
@@ -133,7 +133,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
     let(:predicate)       { left_predicate.and(right_predicate)         }
 
     it 'does not partition the predicate to the remainder' do
-      should equal(Function::Proposition::Tautology.instance)
+      should be(Function::Proposition::Tautology.instance)
     end
   end
 
@@ -143,7 +143,7 @@ describe Optimizer::PredicatePartition, '#remainder' do
     let(:predicate)       { left_predicate.or(right_predicate)          }
 
     it 'does not partition the predicate to the remainder' do
-      should equal(Function::Proposition::Tautology.instance)
+      should be(Function::Proposition::Tautology.instance)
     end
   end
 end