axiom-optimizer 0.1.0 → 0.1.1

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

@@ -10,11 +10,11 @@ describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#opti
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::Enumerable)
+    expect(predicate).to be_kind_of(Function::Predicate::Enumerable)
   end
 
   context 'when the operand contains an unsorted Enumerable' do
-    let(:operand) { [ 2, 1 ] }
+    let(:operand) { [2, 1] }
 
     it { should be(true) }
   end
@@ -26,19 +26,19 @@ describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#opti
   end
 
   context 'when the operand contains an Enumerable after filtering invalid entries' do
-    let(:operand) { [ 'a', 1, 2 ] }
+    let(:operand) { ['a', 1, 2] }
 
     it { should be(true) }
   end
 
   context 'when the operand contains an Enumerable after filtering duplicate entries' do
-    let(:operand) { [ 1, 1, 2, 2 ] }
+    let(:operand) { [1, 1, 2, 2] }
 
     it { should be(true) }
   end
 
   context 'when the operand contains a sorted Enumerable' do
-    let(:operand) { [ 1, 2 ] }
+    let(:operand) { [1, 2] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/function/predicate/enumerable/unoptimized_operands/optimize_spec.rb

@@ -10,28 +10,28 @@ describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#opti
   let(:object)    { described_class.new(predicate) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the operand contains an unsorted Enumerable' do
-    let(:operand) { [ 2, 1 ] }
+    let(:operand) { [2, 1] }
 
     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
 
   context 'when the operand contains an Enumerable with boolean values' do
     let(:attribute) { Attribute::Boolean.new(:status) }
-    let(:operand)   { [ true, false ]                 }
+    let(:operand)   { [true, false]                   }
 
     it { should be_kind_of(Function::Predicate::Inclusion) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
-    its(:right) { should == [ false, true ] }
+    its(:right) { should == [false, true] }
   end
 
   context 'when the operand contains an exclusive Range' do
@@ -39,28 +39,28 @@ describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#opti
 
     it { should be_kind_of(Function::Predicate::Inclusion) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == (1..2) }
   end
 
   context 'when the operand contains an Enumerable after filtering invalid entries' do
-    let(:operand) { [ 'a', 1, 2 ] }
+    let(:operand) { ['a', 1, 2] }
 
     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
 
   context 'when the operand contains an Enumerable after filtering duplicate entries' do
-    let(:operand) { [ 1, 1, 2, 2 ] }
+    let(:operand) { [1, 1, 2, 2] }
 
     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/predicate/equality/tautology/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::Equality::Tautology, '#optimizable?' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::Equality)
+    expect(predicate).to be_kind_of(Function::Predicate::Equality)
   end
 
   context 'when left and right are equal' do

data/spec/unit/axiom/optimizer/function/predicate/exclusion/empty_right/optimize_spec.rb

@@ -10,36 +10,36 @@ describe Optimizer::Function::Predicate::Exclusion::EmptyRight, '#optimize' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the operand contains a nil' do
     let(:operand) { nil }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'when the operand contains an empty Enumerable' do
     let(:operand) { [] }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'when the operand contains an empty inclusive Range' do
     let(:operand) { 1..0 }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'when the operand contains an empty exclusive Range' do
     let(:operand) { 1...1 }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 
   context 'when the operand is empty after filtering invalid entries' do
-    let(:operand) { [ 'a' ] }
+    let(:operand) { ['a'] }
 
-    it { should equal(Function::Proposition::Tautology.instance) }
+    it { should be(Function::Proposition::Tautology.instance) }
   end
 end

data/spec/unit/axiom/optimizer/function/predicate/exclusion/one_right/optimize_spec.rb

@@ -10,15 +10,15 @@ describe Optimizer::Function::Predicate::Exclusion::OneRight, '#optimize' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the operand contains a one entry Enumerable' do
-    let(:operand) { [ 1 ] }
+    let(:operand) { [1] }
 
     it { should be_kind_of(Function::Predicate::Inequality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
@@ -28,7 +28,7 @@ describe Optimizer::Function::Predicate::Exclusion::OneRight, '#optimize' do
 
     it { should be_kind_of(Function::Predicate::Inequality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
@@ -38,27 +38,27 @@ describe Optimizer::Function::Predicate::Exclusion::OneRight, '#optimize' do
 
     it { should be_kind_of(Function::Predicate::Inequality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
 
   context 'when the operand contains one entry after filtering invalid entries' do
-    let(:operand) { [ 'a', 1 ] }
+    let(:operand) { ['a', 1] }
 
     it { should be_kind_of(Function::Predicate::Inequality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
 
   context 'when the operand contains one entry after filtering duplicate entries' do
-    let(:operand) { [ 1, 1 ] }
+    let(:operand) { [1, 1] }
 
     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/predicate/greater_than/contradiction/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::GreaterThan::Contradiction, '#optimizab
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::GreaterThan)
+    expect(predicate).to be_kind_of(Function::Predicate::GreaterThan)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::GreaterThan::Contradiction, '#optimizab
   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/greater_than/tautology/optimizable_predicate_spec.rb

@@ -9,12 +9,12 @@ describe Optimizer::Function::Predicate::GreaterThan::Tautology, '#optimizable?'
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::GreaterThan)
+    expect(predicate).to be_kind_of(Function::Predicate::GreaterThan)
   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/greater_than_or_equal_to/contradiction/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Contradiction, '#
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::GreaterThanOrEqualTo)
+    expect(predicate).to be_kind_of(Function::Predicate::GreaterThanOrEqualTo)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Contradiction, '#
   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/greater_than_or_equal_to/tautology/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Tautology, '#opti
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::GreaterThan)
+    expect(predicate).to be_kind_of(Function::Predicate::GreaterThan)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::GreaterThanOrEqualTo::Tautology, '#opti
   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/inclusion/empty_right/optimize_spec.rb

@@ -10,36 +10,36 @@ describe Optimizer::Function::Predicate::Inclusion::EmptyRight, '#optimize' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the operand contains a nil' do
     let(:operand) { nil }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty Enumerable' do
     let(:operand) { [] }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty inclusive Range' do
     let(:operand) { 1..0 }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty exclusive Range' do
     let(:operand) { 1...1 }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand is empty after filtering invalid entries' do
-    let(:operand) { [ 'a' ] }
+    let(:operand) { ['a'] }
 
-    it { should equal(Function::Proposition::Contradiction.instance) }
+    it { should be(Function::Proposition::Contradiction.instance) }
   end
 end

data/spec/unit/axiom/optimizer/function/predicate/inclusion/one_right/optimize_spec.rb

@@ -10,15 +10,15 @@ describe Optimizer::Function::Predicate::Inclusion::OneRight, '#optimize' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'when the operand contains a one entry Enumerable' do
-    let(:operand) { [ 1 ] }
+    let(:operand) { [1] }
 
     it { should be_kind_of(Function::Predicate::Equality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
 
@@ -29,7 +29,7 @@ describe Optimizer::Function::Predicate::Inclusion::OneRight, '#optimize' do
 
     it { should be_kind_of(Function::Predicate::Equality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
@@ -39,27 +39,27 @@ describe Optimizer::Function::Predicate::Inclusion::OneRight, '#optimize' do
 
     it { should be_kind_of(Function::Predicate::Equality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
 
   context 'when the operand contains one entry after filtering invalid entries' do
-    let(:operand) { [ 'a', 1 ] }
+    let(:operand) { ['a', 1] }
 
     it { should be_kind_of(Function::Predicate::Equality) }
 
-    its(:left) { should equal(attribute) }
+    its(:left) { should be(attribute) }
 
     its(:right) { should == 1 }
   end
 
   context 'when the operand contains one entry after filtering duplicate entries' do
-    let(:operand) { [ 1, 1 ] }
+    let(:operand) { [1, 1] }
 
     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/inequality/contradiction/optimizable_predicate_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::Inequality::Contradiction, '#optimizabl
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::Inequality)
+    expect(predicate).to be_kind_of(Function::Predicate::Inequality)
   end
 
   context 'when left and right are equal' do

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

@@ -10,7 +10,7 @@ describe Optimizer::Function::Predicate::LessThan::Contradiction, '#optimizable?
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::LessThan)
+    expect(predicate).to be_kind_of(Function::Predicate::LessThan)
   end
 
   context 'when left and right are equal' do
@@ -28,8 +28,8 @@ describe Optimizer::Function::Predicate::LessThan::Contradiction, '#optimizable?
   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/tautology/optimizable_predicate_spec.rb

@@ -9,12 +9,12 @@ describe Optimizer::Function::Predicate::LessThan::Tautology, '#optimizable?' do
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Function::Predicate::LessThan)
+    expect(predicate).to be_kind_of(Function::Predicate::LessThan)
   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