axiom-optimizer 0.1.1 → 0.2.0

data/spec/unit/axiom/optimizer/algebra/summarization/{order_operand → sorted_operand}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Summarization::OrderOperand, '#optimize' do
+describe Optimizer::Algebra::Summarization::SortedOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }

data/spec/unit/axiom/optimizer/algebra/summarization/summarize_per_spec.rb

@@ -20,7 +20,7 @@ describe Optimizer::Algebra::Summarization, '#summarize_per' do
   end
 
   context 'when summarize_per is not not optimized' do
-   let(:summarize_per) { TABLE_DEE.rename({}) }
+    let(:summarize_per) { TABLE_DEE.rename({}) }
 
     it { should_not be(summarize_per) }
 

data/spec/unit/axiom/optimizer/function/binary/constant_operands/optimizable_predicate_spec.rb

@@ -21,15 +21,15 @@ describe Optimizer::Function::Binary::ConstantOperands, '#optimizable?' do
   end
 
   context 'when left is a constant, and right is not a constant' do
-    let(:left)  { 1       }
-    let(:right) { proc {} }
+    let(:left)  { 1        }
+    let(:right) { proc {}  }
 
     it { should be(false) }
   end
 
   context 'when left is not a constant, and right is a constant' do
-    let(:left)  { proc {} }
-    let(:right) { 1       }
+    let(:left)  { proc {}  }
+    let(:right) { 1        }
 
     it { should be(false) }
   end

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

@@ -42,8 +42,8 @@ describe Optimizer::Function::Connective::Conjunction::Contradiction, '#optimiza
   end
 
   context 'when left and right are procs' do
-    let(:left)  { proc {} }
-    let(:right) { proc {} }
+    let(:left)  { proc {}  }
+    let(:right) { proc {}  }
 
     it { should be(false) }
   end

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

@@ -42,8 +42,8 @@ describe Optimizer::Function::Connective::Disjunction::Tautology, '#optimizable?
   end
 
   context 'when left and right are procs' do
-    let(:left)  { proc {} }
-    let(:right) { proc {} }
+    let(:left)  { proc {}  }
+    let(:right) { proc {}  }
 
     it { should be(false) }
   end

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

@@ -20,7 +20,7 @@ describe Optimizer::Function::Unary::ConstantOperand, '#optimizable?' do
   end
 
   context 'when the operand is not a constant' do
-    let(:operand) { proc {} }
+    let(:operand) { proc {}  }
 
     it { should be(false) }
   end

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

@@ -14,7 +14,7 @@ describe Optimizer::Function::Util, '.max' do
   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, minimum_length: 1, maximum_length: 10) }
 
     it { should == 10 }
   end

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

@@ -14,7 +14,7 @@ describe Optimizer::Function::Util, '.min' do
   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, minimum_length: 1, maximum_length: 10) }
 
     it { should == 1 }
   end

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

@@ -20,18 +20,18 @@ describe Optimizer::Optimizable, '#optimize' do
 
     before do
       described_class.optimizer = optimizer
-      optimized.stub(:optimize).and_return(optimized)
+      allow(optimized).to receive(:optimize).and_return(optimized)
     end
 
     it { should be(optimized) }
 
     it 'calls the optimizer with the object' do
-      optimizer.should_receive(:call).with(object).and_return(optimized)
+      expect(optimizer).to receive(:call).with(object).and_return(optimized)
       should be(optimized)
     end
 
     it '#optimize the optimized object' do
-      optimized.should_receive(:optimize).with(no_args).and_return(optimized)
+      expect(optimized).to receive(:optimize).with(no_args).and_return(optimized)
       should be(optimized)
     end
   end

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

@@ -9,9 +9,5 @@ describe Optimizer, '#optimizable?' do
   let(:operation)       { double('Operation')            }
   let(:object)          { described_class.new(operation) }
 
-  before do
-    described_class.stub(:to_s).and_return('Optimizer')
-  end
-
-  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimizable? must be implemented') }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#optimizable? is not implemented") }
 end

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

@@ -9,9 +9,5 @@ describe Optimizer, '#optimize' do
   let(:operation)       { double('Operation')            }
   let(:object)          { described_class.new(operation) }
 
-  before do
-    described_class.stub(:to_s).and_return('Optimizer')
-  end
-
-  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimize must be implemented') }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#optimize is not implemented") }
 end

data/spec/unit/axiom/optimizer/relation/operation/binary/{order_left → sorted_left}/optimizable_predicate_spec.rb

@@ -2,20 +2,20 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::OrderLeft, '#optimizable?' do
+describe Optimizer::Relation::Operation::Binary::SortedLeft, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:relation) { double('Relation', left: left, right: right) }
   let(:right)    { double('Right')                              }
   let(:object)   { described_class.new(relation)                }
 
-  context 'when left is an order' do
+  context 'when left is sorted' do
     let(:left) { Relation.new([[:id, Integer]], LazyEnumerable.new).sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when left is not an order' do
+  context 'when left is not sorted' do
     let(:left) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
 
     it { should be(false) }

data/spec/unit/axiom/optimizer/relation/operation/binary/{order_left → sorted_left}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::OrderLeft, '#optimize' do
+describe Optimizer::Relation::Operation::Binary::SortedLeft, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }

data/spec/unit/axiom/optimizer/relation/operation/binary/{order_right → sorted_right}/optimizable_predicate_spec.rb

@@ -2,20 +2,20 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::OrderRight, '#optimizable?' do
+describe Optimizer::Relation::Operation::Binary::SortedRight, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:relation) { double('Relation', left: left, right: right) }
   let(:left)     { double('Left')                               }
   let(:object)   { described_class.new(relation)                }
 
-  context 'when right is an order' do
+  context 'when right is sorted' do
     let(:right) { Relation.new([[:id, Integer]], LazyEnumerable.new).sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when right is not an order' do
+  context 'when right is not sorted' do
     let(:right) { Relation.new([[:id, Integer]], LazyEnumerable.new) }
 
     it { should be(false) }

data/spec/unit/axiom/optimizer/relation/operation/binary/{order_right → sorted_right}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::OrderRight, '#optimize' do
+describe Optimizer::Relation::Operation::Binary::SortedRight, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }

data/spec/unit/axiom/optimizer/relation/operation/limit/equal_limit_operand/optimize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:limit)    { order.take(1)                                                                  }
+  let(:sorted)   { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:limit)    { sorted.take(1)                                                                 }
   let(:relation) { limit.take(1)                                                                  }
   let(:object)   { described_class.new(relation)                                                  }
 

data/spec/unit/axiom/optimizer/relation/operation/limit/limit_operand/optimize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)  { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:limit)  { order.take(2)                                                                  }
+  let(:sorted) { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:limit)  { sorted.take(2)                                                                 }
   let(:object) { described_class.new(relation)                                                  }
 
   before do
@@ -18,7 +18,7 @@ describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
 
     it { should be_kind_of(Relation::Operation::Limit) }
 
-    its(:operand) { should be(order) }
+    its(:operand) { should be(sorted) }
 
     its(:limit) { should == 1 }
   end
@@ -28,7 +28,7 @@ describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
 
     it { should be_kind_of(Relation::Operation::Limit) }
 
-    its(:operand) { should be(order) }
+    its(:operand) { should be(sorted) }
 
     its(:limit) { should == 2 }
   end

data/spec/unit/axiom/optimizer/relation/operation/limit/unoptimized_operand/optimize_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimize'
   subject { object.optimize }
 
   let(:header)   { Relation::Header.coerce([[:id, Integer]])                            }
-  let(:order)    { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:relation) { order.rename({}).take(1)                                             }
+  let(:sorted)   { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:relation) { sorted.rename({}).take(1)                                            }
   let(:object)   { described_class.new(relation)                                        }
 
   before do
@@ -16,7 +16,7 @@ describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimize'
 
   it { should be_kind_of(Relation::Operation::Limit) }
 
-  its(:operand) { should be(order) }
+  its(:operand) { should be(sorted) }
 
   its(:limit) { should == 1 }
 end

data/spec/unit/axiom/optimizer/relation/operation/limit/zero_limit/optimize_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimize' do
   subject { object.optimize }
 
   let(:header)   { Relation::Header.coerce([[:id, Integer]])                            }
-  let(:order)    { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:relation) { order.take(0)                                                        }
+  let(:sorted)   { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:relation) { sorted.take(0)                                                       }
   let(:object)   { described_class.new(relation)                                        }
 
   before do

data/spec/unit/axiom/optimizer/relation/operation/offset/offset_operand/optimize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:relation) { order.drop(1).drop(2)                                                          }
+  let(:sorted)   { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:relation) { sorted.drop(1).drop(2)                                                         }
   let(:object)   { described_class.new(relation)                                                  }
 
   before do
@@ -15,7 +15,7 @@ describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimize' do
 
   it { should be_kind_of(Relation::Operation::Offset) }
 
-  its(:operand) { should be(order) }
+  its(:operand) { should be(sorted) }
 
   its(:offset) { should == 3 }
 end

data/spec/unit/axiom/optimizer/relation/operation/offset/unoptimized_operand/optimize_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimize'
   subject { object.optimize }
 
   let(:header)   { Relation::Header.coerce([[:id, Integer]])                            }
-  let(:order)    { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:relation) { order.rename({}).drop(1)                                             }
+  let(:sorted)   { Relation.new(header, LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:relation) { sorted.rename({}).drop(1)                                            }
   let(:object)   { described_class.new(relation)                                        }
 
   before do
@@ -16,7 +16,7 @@ describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimize'
 
   it { should be_kind_of(Relation::Operation::Offset) }
 
-  its(:operand) { should be(order) }
+  its(:operand) { should be(sorted) }
 
   its(:offset) { should == 1 }
 end

data/spec/unit/axiom/optimizer/relation/operation/offset/zero_offset/optimize_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
-  let(:relation) { order.drop(0)                                                                  }
+  let(:sorted)   { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])).sort_by { |r| r.id } }
+  let(:relation) { sorted.drop(0)                                                                 }
   let(:object)   { described_class.new(relation)                                                  }
 
   before do
     expect(object).to be_optimizable
   end
 
-  it { should be(order) }
+  it { should be(sorted) }
 end

data/spec/unit/axiom/optimizer/relation/operation/reverse/{order_operand → sorted_operand}/optimizable_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimizable?' do
+describe Optimizer::Relation::Operation::Reverse::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -13,13 +13,13 @@ describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimizable?'
     expect(object.operation).to be_kind_of(Relation::Operation::Reverse)
   end
 
-  context 'when the operand is ordered' do
+  context 'when the operand is sorted' do
     let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when the operand is not ordered' do
+  context 'when the operand is not sorted' do
     let(:operand) { base.sort_by { |r| r.id }.take(2) }
 
     it { should be(false) }

data/spec/unit/axiom/optimizer/relation/operation/reverse/{order_operand → sorted_operand}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimize' do
+describe Optimizer::Relation::Operation::Reverse::SortedOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -14,7 +14,7 @@ describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimize' do
     expect(object).to be_optimizable
   end
 
-  it { should be_kind_of(Relation::Operation::Order) }
+  it { should be_kind_of(Relation::Operation::Sorted) }
 
   its(:operand) { should be(base) }
 

data/spec/unit/axiom/optimizer/relation/operation/reverse/unoptimized_operand/optimize_spec.rb

@@ -6,19 +6,19 @@ describe Optimizer::Relation::Operation::Reverse::UnoptimizedOperand, '#optimize
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
-  let(:order)    { base.sort_by { |r| r.id }                                 }
-  let(:relation) { order.rename({}).reverse                                  }
+  let(:sorted)   { base.sort_by { |r| r.id }                                 }
+  let(:relation) { sorted.rename({}).reverse                                 }
   let(:object)   { described_class.new(relation)                             }
 
   before do
     expect(object).to be_optimizable
   end
 
-  it { should be_kind_of(Relation::Operation::Order) }
+  it { should be_kind_of(Relation::Operation::Sorted) }
 
   it { should_not be(relation) }
 
-  its(:operand) { should be(order) }
+  its(:operand) { should be(sorted) }
 
   its(:directions) { should eql(relation.directions) }
 end

data/spec/unit/axiom/optimizer/relation/operation/{order → sorted}/one_limit_operand/optimizable_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimizable?' do
+describe Optimizer::Relation::Operation::Sorted::OneLimitOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -10,7 +10,7 @@ describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimizable?'
   let(:object)   { described_class.new(relation)                             }
 
   before do
-    expect(object.operation).to be_kind_of(Relation::Operation::Order)
+    expect(object.operation).to be_kind_of(Relation::Operation::Sorted)
   end
 
   context 'when the operand is limited to 1' do

data/spec/unit/axiom/optimizer/relation/operation/{order → sorted}/one_limit_operand/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimize' do
+describe Optimizer::Relation::Operation::Sorted::OneLimitOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }

data/spec/unit/axiom/optimizer/relation/operation/{order/order_operand → sorted/sorted_operand}/optimizable_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimizable?' do
+describe Optimizer::Relation::Operation::Sorted::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -10,16 +10,16 @@ describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimizable?' do
   let(:object)   { described_class.new(relation)                             }
 
   before do
-    expect(object.operation).to be_kind_of(Relation::Operation::Order)
+    expect(object.operation).to be_kind_of(Relation::Operation::Sorted)
   end
 
-  context 'when the operand is ordered' do
+  context 'when the operand is sorted' do
     let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when the operand is not ordered' do
+  context 'when the operand is not sorted' do
     let(:operand) { base }
 
     it { should be(false) }