axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/function/connective/conjunction/tautology_right/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Conjunction::TautologyRight, '#optimiz
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Conjunction)
+    expect(object.operation).to be_kind_of(Function::Connective::Conjunction)
   end
 
   context 'when right is a tautology' do

data/spec/unit/axiom/optimizer/function/connective/conjunction/tautology_right/optimize_spec.rb

@@ -12,8 +12,8 @@ describe Optimizer::Function::Connective::Conjunction::TautologyRight, '#optimiz
   let(:object)     { described_class.new(connective)           }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/function/connective/disjunction/contradiction_left/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Disjunction::ContradictionLeft, '#opti
   let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Disjunction)
+    expect(object.operation).to be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when right is a tautology' do

data/spec/unit/axiom/optimizer/function/connective/disjunction/contradiction_left/optimize_spec.rb

@@ -12,8 +12,8 @@ describe Optimizer::Function::Connective::Disjunction::ContradictionLeft, '#opti
   let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(right) }
+  it { should be(right) }
 end

data/spec/unit/axiom/optimizer/function/connective/disjunction/contradiction_right/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Disjunction::ContradictionRight, '#opt
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Disjunction)
+    expect(object.operation).to be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when right is a contradiction' do

data/spec/unit/axiom/optimizer/function/connective/disjunction/contradiction_right/optimize_spec.rb

@@ -12,8 +12,8 @@ describe Optimizer::Function::Connective::Disjunction::ContradictionRight, '#opt
   let(:object)     { described_class.new(connective)               }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Disjunction)
+    expect(object.operation).to be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when the operands are optimizable' do
@@ -22,22 +22,22 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
     end
 
     context 'when the left is an equality predicate and the right is an inclusion predicate' do
-      let(:left)  { attribute.eq(2)             }
-      let(:right) { attribute.include([ 1, 3 ]) }
+      let(:left)  { attribute.eq(2)           }
+      let(:right) { attribute.include([1, 3]) }
 
       it { should be(true) }
     end
 
     context 'when the left is an inclusion predicate and the right is an equality predicate' do
-      let(:left)  { attribute.include([ 2, 3 ]) }
-      let(:right) { attribute.eq(1)             }
+      let(:left)  { attribute.include([2, 3]) }
+      let(:right) { attribute.eq(1)           }
 
       it { should be(true) }
     end
 
     context 'when the left and right are inclusion predicatess' do
-      let(:left)  { attribute.include([ 2, 3 ]) }
-      let(:right) { attribute.include([ 1, 3 ]) }
+      let(:left)  { attribute.include([2, 3]) }
+      let(:right) { attribute.include([1, 3]) }
 
       it { should be(true) }
     end
@@ -52,8 +52,8 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
     end
 
     context 'when the left is an exclusion predicate and the right is an equality predicate' do
-      let(:left)  { attribute.exclude([ 1, 3 ]) }
-      let(:right) { attribute.eq(2)             }
+      let(:left)  { attribute.exclude([1, 3]) }
+      let(:right) { attribute.eq(2)           }
 
       it { should be(false) }
     end

data/spec/unit/axiom/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimize_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
   let(:object)     { described_class.new(connective) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the right operands are optimizable' do
@@ -20,46 +20,46 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
 
       it { should be_kind_of(Function::Predicate::Inclusion) }
 
-      its(:left) { should equal(attribute) }
+      its(:left) { should be(attribute) }
 
       # enumerable order is normalized
-      its(:right) { should == [ 1, 2 ] }
+      its(:right) { should == [1, 2] }
     end
 
     context 'when the left is an equality predicate and the right is an inclusion predicate' do
-      let(:left)  { attribute.eq(2)          }
-      let(:right) { attribute.include([ 1 ]) }
+      let(:left)  { attribute.eq(2)        }
+      let(:right) { attribute.include([1]) }
 
       it { should be_kind_of(Function::Predicate::Inclusion) }
 
-      its(:left) { should equal(attribute) }
+      its(:left) { should be(attribute) }
 
       # enumerable order is normalized
-      its(:right) { should == [ 1, 2 ] }
+      its(:right) { should == [1, 2] }
     end
 
     context 'when the left is an inclusion predicate and the right is an equality predicate' do
-      let(:left)  { attribute.include([ 2 ]) }
-      let(:right) { attribute.eq(1)          }
+      let(:left)  { attribute.include([2]) }
+      let(:right) { attribute.eq(1)        }
 
       it { should be_kind_of(Function::Predicate::Inclusion) }
 
-      its(:left) { should equal(attribute) }
+      its(:left) { should be(attribute) }
 
       # enumerable order is normalized
-      its(:right) { should == [ 1, 2 ] }
+      its(:right) { should == [1, 2] }
     end
 
     context 'when the left and right are inclusion predicatess' do
-      let(:left)  { attribute.include([ 2 ]) }
-      let(:right) { attribute.include([ 1 ]) }
+      let(:left)  { attribute.include([2]) }
+      let(:right) { attribute.include([1]) }
 
       it { should be_kind_of(Function::Predicate::Inclusion) }
 
-      its(:left) { should equal(attribute) }
+      its(:left) { should be(attribute) }
 
       # enumerable order is normalized
-      its(:right) { should == [ 1, 2 ] }
+      its(:right) { should == [1, 2] }
     end
   end
 
@@ -69,8 +69,8 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
 
     it { should be_kind_of(Function::Predicate::Inclusion) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
-    its(:right) { should == [ 1, 2 ] }
+    its(:right) { should == [1, 2] }
   end
 end

data/spec/unit/axiom/optimizer/function/connective/disjunction/tautology/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Disjunction::Tautology, '#optimizable?
   let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Disjunction)
+    expect(object.operation).to be_kind_of(Function::Connective::Disjunction)
   end
 
   context 'when left is a tautology' do

data/spec/unit/axiom/optimizer/function/connective/disjunction/tautology/optimize_spec.rb

@@ -12,8 +12,8 @@ describe Optimizer::Function::Connective::Disjunction::Tautology, '#optimize' do
   let(:object)     { described_class.new(connective)                    }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(Function::Proposition::Tautology.instance) }
+  it { should be(Function::Proposition::Tautology.instance) }
 end

data/spec/unit/axiom/optimizer/function/connective/negation/constant_operand/optimize_spec.rb

@@ -9,8 +9,8 @@ describe Optimizer::Function::Connective::Negation::ConstantOperand, '#optimize'
   let(:object)   { described_class.new(negation)             }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(Function::Proposition::Tautology.instance) }
+  it { should be(Function::Proposition::Tautology.instance) }
 end

data/spec/unit/axiom/optimizer/function/connective/negation/invertible_operand/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Connective::Negation::InvertibleOperand, '#optimiz
   let(:object)    { described_class.new(negation)               }
 
   before do
-    object.operation.should be_kind_of(Function::Connective::Negation)
+    expect(object.operation).to be_kind_of(Function::Connective::Negation)
   end
 
   context 'when operand is invertible' do

data/spec/unit/axiom/optimizer/function/connective/negation/invertible_operand/optimize_spec.rb

@@ -11,12 +11,12 @@ describe Optimizer::Function::Connective::Negation::InvertibleOperand, '#optimiz
   let(:object)    { described_class.new(negation)               }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Function::Predicate::Inequality) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

data/spec/unit/axiom/optimizer/function/connective/negation/operand_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Function::Connective::Negation, '#operand' do
   subject { object.operand }
 
-  let(:optimized_operand) { mock('Optimized Operand')                       }
-  let(:operand)           { mock('Operand', :optimize => optimized_operand) }
-  let(:negation)          { mock('Negation', :operand => operand)           }
-  let(:object)            { described_class.new(negation)                   }
+  let(:optimized_operand) { double('Optimized Operand')                    }
+  let(:operand)           { double('Operand', optimize: optimized_operand) }
+  let(:negation)          { double('Negation', operand: operand)           }
+  let(:object)            { described_class.new(negation)                  }
 
-  it { should equal(optimized_operand) }
+  it { should be(optimized_operand) }
 end

data/spec/unit/axiom/optimizer/function/predicate/comparable/never_comparable/optimizable_predicate_spec.rb

@@ -13,7 +13,7 @@ describe Optimizer::Function::Predicate::Comparable::NeverComparable, '#optimiza
   before do
     described_class.class_eval { include Optimizer::Function::Predicate::Comparable::NeverComparable }
 
-    predicate.should be_kind_of(Function::Predicate::Comparable)
+    expect(predicate).to be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left is a constant and is valid' do

data/spec/unit/axiom/optimizer/function/predicate/comparable/never_equivalent/optimizable_predicate_spec.rb

@@ -6,14 +6,14 @@ describe Optimizer::Function::Predicate::Comparable::NeverEquivalent, '#optimiza
   subject { object.optimizable? }
 
   let(:described_class) { Class.new(Optimizer::Function::Predicate)      }
-  let(:attribute)       { Attribute::Integer.new(:id, :size => 1..10)    }
+  let(:attribute)       { Attribute::Integer.new(:id, size: 1..10)       }
   let(:predicate)       { Function::Predicate::Equality.new(left, right) }
   let(:object)          { described_class.new(predicate)                 }
 
   before do
     described_class.class_eval { include Optimizer::Function::Predicate::Comparable::NeverEquivalent }
 
-    predicate.should be_kind_of(Function::Predicate::Comparable)
+    expect(predicate).to be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left is a constant and is valid' do
@@ -52,8 +52,8 @@ describe Optimizer::Function::Predicate::Comparable::NeverEquivalent, '#optimiza
   end
 
   context 'when left and right are not joinable' do
-    let(:left)  { attribute                                    }
-    let(:right) { Attribute::Integer.new(:id, :size => -10..0) }
+    let(:left)  { attribute                                 }
+    let(:right) { Attribute::Integer.new(:id, size: -10..0) }
 
     it { should be(true) }
   end

data/spec/unit/axiom/optimizer/function/predicate/comparable/normalizable_operands/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::Comparable::NormalizableOperands, '#opt
   let(:object)    { described_class.new(predicate)                 }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::Comparable)
+    expect(predicate).to be_kind_of(Function::Predicate::Comparable)
   end
 
   context 'when left and right is a constant' do

data/spec/unit/axiom/optimizer/function/predicate/comparable/normalizable_operands/optimize_spec.rb

@@ -10,12 +10,12 @@ describe Optimizer::Function::Predicate::Comparable::NormalizableOperands, '#opt
   let(:object)    { described_class.new(predicate)                  }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Function::Predicate::Equality) }
 
-  its(:left) { should equal(attribute) }
+  its(:left) { should be(attribute) }
 
   its(:right) { should == 1 }
 end

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

@@ -9,8 +9,8 @@ describe Optimizer::Function::Predicate::ConstantOperands, '#optimize' do
   let(:object)    { described_class.new(predicate)          }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(Function::Proposition::Tautology.instance) }
+  it { should be(Function::Proposition::Tautology.instance) }
 end

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

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

data/spec/unit/axiom/optimizer/function/predicate/enumerable/class_methods/sort_by_value_spec.rb

@@ -22,6 +22,6 @@ describe Optimizer::Function::Predicate::Enumerable, '.sort_by_value' do
   context 'when the value is an object' do
     let(:value) { Object.new }
 
-    it { should equal(value) }
+    it { should be(value) }
   end
 end

data/spec/unit/axiom/optimizer/function/predicate/enumerable/empty_right/optimizable_predicate_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Function::Predicate::Enumerable::EmptyRight, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:described_class) { Class.new(Optimizer::Function::Predicate)  }
-  let(:attribute)       { Attribute::Integer.new(:id, :size => 1..9) }
-  let(:predicate)       { attribute.include(operand)                 }
-  let(:object)          { described_class.new(predicate)             }
+  let(:described_class) { Class.new(Optimizer::Function::Predicate) }
+  let(:attribute)       { Attribute::Integer.new(:id, size: 1..9)   }
+  let(:predicate)       { attribute.include(operand)                }
+  let(:object)          { described_class.new(predicate)            }
 
   before do
     described_class.class_eval { include Optimizer::Function::Predicate::Enumerable::EmptyRight }
 
-    predicate.should be_kind_of(Function::Predicate::Enumerable)
+    expect(predicate).to be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains a nil' do
@@ -41,13 +41,13 @@ describe Optimizer::Function::Predicate::Enumerable::EmptyRight, '#optimizable?'
   end
 
   context 'when the operand is empty after filtering invalid entries' do
-    let(:operand) { [ 'a' ] }
+    let(:operand) { ['a'] }
 
     it { should be(true) }
   end
 
   context 'when the operand contains an not empty Enumerable' do
-    let(:operand) { [ 1 ] }
+    let(:operand) { [1] }
 
     it { should be(false) }
   end
@@ -65,7 +65,7 @@ describe Optimizer::Function::Predicate::Enumerable::EmptyRight, '#optimizable?'
   end
 
   context 'when the operand is not empty after filtering invalid entries' do
-    let(:operand) { [ 'a', 1 ] }
+    let(:operand) { ['a', 1] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/function/predicate/enumerable/one_right/optimizable_predicate_spec.rb

@@ -13,11 +13,11 @@ describe Optimizer::Function::Predicate::Enumerable::OneRight, '#optimizable?' d
   before do
     described_class.class_eval { include Optimizer::Function::Predicate::Enumerable::OneRight }
 
-    predicate.should be_kind_of(Function::Predicate::Enumerable)
+    expect(predicate).to be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains a one entry Enumerable' do
-    let(:operand) { [ 1 ] }
+    let(:operand) { [1] }
 
     it { should be(true) }
   end
@@ -35,19 +35,19 @@ describe Optimizer::Function::Predicate::Enumerable::OneRight, '#optimizable?' d
   end
 
   context 'when the operand contains one entry after filtering invalid entries' do
-    let(:operand) { [ 'a', 1 ] }
+    let(:operand) { ['a', 1] }
 
     it { should be(true) }
   end
 
   context 'when the operand contains one entry after filtering duplicate entries' do
-    let(:operand) { [ 1, 1 ] }
+    let(:operand) { [1, 1] }
 
     it { should be(true) }
   end
 
   context 'when the operand contains a more than one entry Enumerable' do
-    let(:operand) { [ 2, 1 ] }
+    let(:operand) { [2, 1] }
 
     it { should be(false) }
   end
@@ -65,13 +65,13 @@ describe Optimizer::Function::Predicate::Enumerable::OneRight, '#optimizable?' d
   end
 
   context 'when the operand contains more than one entry after filtering invalid entries' do
-    let(:operand) { [ 'a', 1, 2 ] }
+    let(:operand) { ['a', 1, 2] }
 
     it { should be(false) }
   end
 
   context 'when the operand contains more than one entry after filtering duplicate entries' do
-    let(:operand) { [ 2, 1, 2, 1 ] }
+    let(:operand) { [2, 1, 2, 1] }
 
     it { should be(false) }
   end