axiom-optimizer 0.1.1 → 0.2.0

data/spec/integration/axiom/relation/operation/reverse/optimize_spec.rb

@@ -7,13 +7,13 @@ describe Relation::Operation::Reverse, '#optimize' do
 
   let(:body)     { LazyEnumerable.new([[1], [2], [3]])  }
   let(:relation) { Relation.new([[:id, Integer]], body) }
-  let(:order)    { relation.sort_by { |r| r.id }        }
-  let(:operand)  { order                                }
+  let(:sorted)   { relation.sort_by { |r| r.id }        }
+  let(:operand)  { sorted                               }
   let(:object)   { described_class.new(operand)         }
 
   context 'with a object operation' do
-    let(:limit)   { order.take(2) }
-    let(:operand) { limit.reverse }
+    let(:limit)   { sorted.take(2) }
+    let(:operand) { limit.reverse  }
 
     it 'cancels out the operations and return the contained operation' do
       should be(limit)
@@ -24,7 +24,7 @@ describe Relation::Operation::Reverse, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -32,7 +32,7 @@ describe Relation::Operation::Reverse, '#optimize' do
   end
 
   context 'with a object operation when optimized' do
-    let(:limit)   { order.take(2)            }
+    let(:limit)   { sorted.take(2)           }
     let(:operand) { limit.reverse.rename({}) }
 
     it 'cancels out the operations and return the contained operation' do
@@ -44,14 +44,14 @@ describe Relation::Operation::Reverse, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
     it_should_behave_like 'an optimize method'
   end
 
-  context 'with an order operation' do
+  context 'with a sorted operation' do
     it { should eql(relation.sort_by { object.directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -59,15 +59,15 @@ describe Relation::Operation::Reverse, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
     it_should_behave_like 'an optimize method'
   end
 
-  context 'with an order operation when optimized' do
-    let(:operand) { order.rename({}) }
+  context 'with a sorted operation when optimized' do
+    let(:operand) { sorted.rename({}) }
 
     it { should eql(relation.sort_by { object.directions }) }
 
@@ -76,7 +76,7 @@ describe Relation::Operation::Reverse, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -84,17 +84,17 @@ describe Relation::Operation::Reverse, '#optimize' do
   end
 
   context 'with an optimizable operation' do
-    let(:limit)   { order.take(2)    }
+    let(:limit)   { sorted.take(2)   }
     let(:operand) { limit.rename({}) }
 
-    it { should eql(order.take(2).reverse) }
+    it { should eql(sorted.take(2).reverse) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 

data/spec/integration/axiom/relation/operation/{order → sorted}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Relation::Operation::Order, '#optimize' do
+describe Relation::Operation::Sorted, '#optimize' do
   subject { object.optimize }
 
   let(:body)       { LazyEnumerable.new([[1], [2], [3]])      }
@@ -15,7 +15,7 @@ describe Relation::Operation::Order, '#optimize' do
     it { should be(object) }
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -32,7 +32,7 @@ describe Relation::Operation::Order, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -49,7 +49,7 @@ describe Relation::Operation::Order, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -66,7 +66,7 @@ describe Relation::Operation::Order, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 
@@ -83,7 +83,7 @@ describe Relation::Operation::Order, '#optimize' do
     end
 
     it 'does not execute body#each' do
-      body.should_not_receive(:each)
+      expect(body).not_to receive(:each)
       subject
     end
 

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

@@ -13,7 +13,7 @@ describe Relation, '#optimize' do
   end
 
   it 'calls self.class.optimizer' do
-    described_class.should_receive(:optimizer).and_return(nil)
+    expect(described_class).to receive(:optimizer).and_return(nil)
     subject
   end
 

data/spec/shared/function_connective_binary_optimize_behavior.rb

@@ -79,7 +79,10 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:right) { double('Binary', class: described_class, left: left, :optimized? => true) }
 
     before do
-      right.stub(optimize: right, :frozen? => true, memoize: right, memoized: right)
+      allow(right).to receive(:optimize).and_return(right)
+      allow(right).to receive(:frozen?).and_return(true)
+      allow(right).to receive(:memoize).and_return(right)
+      allow(right).to receive(:memoized).and_return(right)
     end
 
     it { should be(right) }
@@ -92,7 +95,10 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:right) { attribute.eq(1)                                                             }
 
     before do
-      left.stub(optimize: left, :frozen? => true, memoize: left, memoized: left)
+      allow(left).to receive(:optimize).and_return(left)
+      allow(left).to receive(:frozen?).and_return(true)
+      allow(left).to receive(:memoize).and_return(left)
+      allow(left).to receive(:memoized).and_return(left)
     end
 
     it { should be(left) }

data/spec/shared/optimize_method_behavior.rb

@@ -2,15 +2,4 @@
 
 shared_examples_for 'an optimize method' do
   it_should_behave_like 'an idempotent method'
-
-  it 'it memoizes itself for #optimize' do
-    optimized = subject
-    expect(optimized.memoized(:optimize)).to be(optimized)
-  end
-
-  it 'does not optimize further' do
-    optimized = subject
-    optimized.memoize(:optimize, nil)  # clear memoized value
-    expect(optimized.optimize).to eql(optimized)
-  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'devtools/spec_helper'
-
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
   require 'coveralls'
@@ -12,21 +10,23 @@ if ENV['COVERAGE'] == 'true'
   ]
 
   SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+    add_filter 'vendor'
+
     minimum_coverage 100
   end
 end
 
+require 'ice_nine'
+require 'devtools/spec_helper'
 require 'axiom-optimizer'
 
 include Axiom
 
-# Require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file.chomp('.rb')
-end
+Types.finalize
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expect_with|

data/spec/support/config_alias.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rbconfig'
 
 ::Config = RbConfig unless defined?(::Config)

data/spec/unit/axiom/optimizer/algebra/extension/{order_operand → sorted_operand}/optimizable_predicate_spec.rb

@@ -2,20 +2,20 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Extension::OrderOperand, '#optimizable?' do
+describe Optimizer::Algebra::Extension::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
   let(:relation) { operand.extend {}                                  }
   let(:object)   { described_class.new(relation)                      }
 
-  context 'when operand is an order' do
+  context 'when operand is sorted' do
     let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when operand is not an order' do
+  context 'when operand is not sorted' do
     let(:operand) { base }
 
     it { should be(false) }

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

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

data/spec/unit/axiom/optimizer/algebra/rename/limit_operand/optimize_spec.rb

@@ -7,8 +7,8 @@ describe Optimizer::Algebra::Rename::LimitOperand, '#optimize' do
 
   let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
   let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
-  let(:order)    { base.sort_by { |r| r.id }                       }
-  let(:relation) { order.take(2).rename(id: :other_id)             }
+  let(:sorted)   { base.sort_by { |r| r.id }                       }
+  let(:relation) { sorted.take(2).rename(id: :other_id)            }
   let(:object)   { described_class.new(relation)                   }
 
   before do
@@ -17,7 +17,7 @@ describe Optimizer::Algebra::Rename::LimitOperand, '#optimize' do
 
   it { should be_kind_of(Relation::Operation::Limit) }
 
-  its(:operand) { should eql(order.rename(id: :other_id)) }
+  its(:operand) { should eql(sorted.rename(id: :other_id)) }
 
   its(:limit) { should == 2 }
 end

data/spec/unit/axiom/optimizer/algebra/rename/offset_operand/optimize_spec.rb

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

data/spec/unit/axiom/optimizer/algebra/rename/{order_operand → sorted_operand}/optimizable_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Rename::OrderOperand, '#optimizable?' do
+describe Optimizer::Algebra::Rename::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -14,13 +14,13 @@ describe Optimizer::Algebra::Rename::OrderOperand, '#optimizable?' do
     expect(object.operation).to be_kind_of(Algebra::Rename)
   end
 
-  context 'when the operand is an order operation' 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 an order operation' do
+  context 'when the operand is not sorted' do
     let(:operand) { base }
 
     it { should be(false) }

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Rename::OrderOperand, '#optimize' do
+describe Optimizer::Algebra::Rename::SortedOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -14,7 +14,7 @@ describe Optimizer::Algebra::Rename::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 eql(base.rename(id: :other_id)) }
 

data/spec/unit/axiom/optimizer/algebra/restriction/combination_operand/optimize_spec.rb

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Restriction::CombinationOperand, '#optimize' do
     expect(object).to be_optimizable
   end
 
-  specify { expect { subject }.to raise_error(NotImplementedError, 'Axiom::Optimizer::Algebra::Restriction::CombinationOperand#relation_method must be implemented') }
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Axiom::Optimizer::Algebra::Restriction::CombinationOperand#relation_method is not implemented') }
 
   context 'with a defined relation_method' do
     let(:described_class) { Class.new(Optimizer::Algebra::Restriction::CombinationOperand) }

data/spec/unit/axiom/optimizer/algebra/restriction/predicate_spec.rb

@@ -5,10 +5,11 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction, '#predicate' do
   subject { object.predicate }
 
-  let(:base)      { Relation.new([[:id, Integer]], [[1]]) }
-  let(:predicate) { base[:id].eq(1)                       }
-  let(:relation)  { base.restrict { predicate }           }
-  let(:object)    { described_class.new(relation)         }
+  let(:object)          { described_class.new(relation)              }
+  let(:described_class) { Class.new(Optimizer::Algebra::Restriction) }
+  let(:base)            { Relation.new([[:id, Integer]], [[1]])      }
+  let(:predicate)       { base[:id].eq(1)                            }
+  let(:relation)        { base.restrict { predicate }                }
 
   before do
     expect(object.operation).to be_kind_of(Algebra::Restriction)

data/spec/unit/axiom/optimizer/algebra/restriction/{order_operand → sorted_operand}/optimizable_predicate_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Restriction::OrderOperand, '#optimizable?' do
+describe Optimizer::Algebra::Restriction::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)      { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
@@ -14,13 +14,13 @@ describe Optimizer::Algebra::Restriction::OrderOperand, '#optimizable?' do
     expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
-  context 'when the operand is an order operation' 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 an order operation' do
+  context 'when the operand is not sorted' do
     let(:operand) { base }
 
     it { should be(false) }

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

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

data/spec/unit/axiom/optimizer/algebra/summarization/empty_operand/class_methods/extension_default_spec.rb

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Summarization::EmptyOperand, '.extension_default' d
   end
 
   context 'when the function does not have a default' do
-    let(:function) { proc {} }
+    let(:function) { proc {}  }
 
     it { should be_nil }
   end

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

@@ -2,20 +2,20 @@
 
 require 'spec_helper'
 
-describe Optimizer::Algebra::Summarization::OrderOperand, '#optimizable?' do
+describe Optimizer::Algebra::Summarization::SortedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
   let(:relation) { operand.summarize([]) {}                           }
   let(:object)   { described_class.new(relation)                      }
 
-  context 'when operand is an order' do
+  context 'when operand is sorted' do
     let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end
 
-  context 'when operand is not an order' do
+  context 'when operand is not sorted' do
     let(:operand) { base }
 
     it { should be(false) }