axiom-optimizer 0.1.0 → 0.1.1

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

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Relation::Operation::Reverse, '#optimize' do
   subject { object.optimize }
 
-  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(:object)   { described_class.new(operand)                }
+  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(:object)   { described_class.new(operand)         }
 
   context 'with a object operation' do
     let(:limit)   { order.take(2) }
     let(:operand) { limit.reverse }
 
     it 'cancels out the operations and return the contained operation' do
-      should equal(limit)
+      should be(limit)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -36,7 +36,7 @@ describe Relation::Operation::Reverse, '#optimize' do
     let(:operand) { limit.reverse.rename({}) }
 
     it 'cancels out the operations and return the contained operation' do
-      should equal(limit)
+      should be(limit)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -102,9 +102,9 @@ describe Relation::Operation::Reverse, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+    let(:relation) { Relation.new([[:id, Integer]], [[1], [2], [3]]) }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 3 ], [ 2 ], [ 1 ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer]], [[3], [2], [1]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Relation, '#optimize' do
   subject { object.optimize(*args) }
 
-  let(:object) { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:args)   { []                                                                       }
+  let(:object) { described_class.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:args)   { []                                                               }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it 'calls self.class.optimizer' do
@@ -17,7 +17,7 @@ describe Relation, '#optimize' do
     subject
   end
 
-  it { should equal(object) }
+  it { should be(object) }
 
   it_should_behave_like 'an optimize method'
 end

data/spec/shared/function_connective_binary_optimize_behavior.rb

@@ -5,7 +5,7 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.gt(1) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -15,7 +15,7 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:left)          { original_left.and(Function::Proposition::Tautology.instance) }
     let(:right)         { attribute.gt(1)                                              }
 
-    it { should equal(original_left) }
+    it { should be(original_left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -24,7 +24,7 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:left)  { attribute.gt(1)                                                }
     let(:right) { attribute.gt(1).and(Function::Proposition::Tautology.instance) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -33,7 +33,7 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
     let(:left)  { attribute.gt(1) }
     let(:right) { attribute.lt(1) }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -45,13 +45,13 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
 
     add_method_missing
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
-    its(:left) { should equal(original_left) }
+    its(:left) { should be(original_left) }
 
-    its(:right) { should equal(right) }
+    its(:right) { should be(right) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -63,39 +63,39 @@ shared_examples_for 'Function::Connective::Binary#optimize' do
 
     add_method_missing
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
-    its(:left) { should equal(left) }
+    its(:left) { should be(left) }
 
-    its(:right) { should equal(original_right) }
+    its(:right) { should be(original_right) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'self and right are the same, and left and right.left are the same' do
-    let(:left)  { attribute.eq(1)                                                               }
-    let(:right) { mock('Binary', :class => described_class, :left => left, :optimized? => true) }
+    let(:left)  { attribute.eq(1)                                                           }
+    let(:right) { double('Binary', class: described_class, left: left, :optimized? => true) }
 
     before do
-      right.stub!(:optimize => right, :frozen? => true, :memoize => right, :memoized => right)
+      right.stub(optimize: right, :frozen? => true, memoize: right, memoized: right)
     end
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'self and left are the same, and right and left.right are the same' do
-    let(:left)  { mock('Binary', :class => described_class, :right => right, :optimized? => true) }
-    let(:right) { attribute.eq(1)                                                                 }
+    let(:left)  { double('Binary', class: described_class, right: right, :optimized? => true) }
+    let(:right) { attribute.eq(1)                                                             }
 
     before do
-      left.stub!(:optimize => left, :frozen? => true, :memoize => left, :memoized => left)
+      left.stub(optimize: left, :frozen? => true, memoize: left, memoized: left)
     end
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/shared/optimize_method_behavior.rb

@@ -5,12 +5,12 @@ shared_examples_for 'an optimize method' do
 
   it 'it memoizes itself for #optimize' do
     optimized = subject
-    optimized.memoized(:optimize).should equal(optimized)
+    expect(optimized.memoized(:optimize)).to be(optimized)
   end
 
   it 'does not optimize further' do
     optimized = subject
     optimized.memoize(:optimize, nil)  # clear memoized value
-    optimized.optimize.should eql(optimized)
+    expect(optimized.optimize).to eql(optimized)
   end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,6 @@
 # encoding: utf-8
 
-require 'backports'
-require 'backports/basic_object' unless defined?(::BasicObject)
-require 'devtools'
-require 'ice_nine'
-
-Devtools.init_spec_helper
+require 'devtools/spec_helper'
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
@@ -28,11 +23,15 @@ require 'axiom-optimizer'
 
 include Axiom
 
-# require spec support files and shared behavior
+# Require spec support files and shared behavior
 Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
+  require file.chomp('.rb')
 end
 
 RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
+
   config.extend AddMethodMissing
 end

data/spec/support/add_method_missing.rb

@@ -5,10 +5,9 @@ module AddMethodMissing
     before do
       # when #optimize delegates to super, it would normally
       # explode, so define method_missing to return self
-      send(name).class_eval do
-        def method_missing(*)
-          self
-        end
+      public_send(name).class_eval do
+        undef_method :method_missing
+        define_method(:method_missing) { self }
       end
     end
   end

data/spec/unit/axiom/optimizer/algebra/difference/empty_left/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Difference::EmptyLeft, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation::Empty.new(header)                         }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.difference(right)                              }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation::Empty.new(header)                     }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { left.difference(right)                          }
+  let(:object)   { described_class.new(relation)                   }
 
   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/algebra/difference/empty_right/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Difference::EmptyRight, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation::Empty.new(header)                         }
-  let(:relation) { left.difference(right)                              }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation::Empty.new(header)                     }
+  let(:relation) { left.difference(right)                          }
+  let(:object)   { described_class.new(relation)                   }
 
   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/algebra/difference/equal_operands/optimize_spec.rb

@@ -5,19 +5,17 @@ require 'spec_helper'
 describe Optimizer::Algebra::Difference::EqualOperands, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.difference(right)                              }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { left.difference(right)                          }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Empty) }
 
-  its(:header) { should equal(header) }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should be(header) }
 end

data/spec/unit/axiom/optimizer/algebra/extension/extensions_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Extension, '#extensions' do
   subject { object.extensions }
 
-  let(:base)          { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])  }
+  let(:base)          { Relation.new([[:id, Integer]], [[1]])          }
   let(:attribute)     { Attribute::Object.new(:test)                   }
   let(:summarize_per) { TABLE_DEE                                      }
   let(:relation)      { base.extend { |r| r.add(attribute, function) } }
   let(:object)        { described_class.new(relation)                  }
 
   before do
-    object.operation.should be_kind_of(Algebra::Extension)
+    expect(object.operation).to be_kind_of(Algebra::Extension)
   end
 
   context 'when extensions are optimized' do
@@ -24,7 +24,7 @@ describe Optimizer::Algebra::Extension, '#extensions' do
   context 'when extensions are not optimized' do
     let(:function) { Function::Numeric::Absolute.new(1) }
 
-    it { should_not equal(relation.extensions) }
+    it { should_not be(relation.extensions) }
 
     it { should eql(attribute => 1) }
   end

data/spec/unit/axiom/optimizer/algebra/extension/order_operand/optimizable_predicate_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Algebra::Extension::OrderOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:relation) { operand.extend {}                                      }
-  let(:object)   { described_class.new(relation)                          }
+  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
     let(:operand) { base.sort_by { |r| r.id } }

data/spec/unit/axiom/optimizer/algebra/extension/order_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Extension::OrderOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
-  let(:operand)  { base.sort_by { |r| r.id }                              }
-  let(:relation) { operand.extend {}                                      }
-  let(:object)   { described_class.new(relation)                          }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new) }
+  let(:operand)  { base.sort_by { |r| r.id }                          }
+  let(:relation) { operand.extend {}                                  }
+  let(:object)   { described_class.new(relation)                      }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Extension) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
   its(:extensions) { should eql(relation.extensions) }
 end

data/spec/unit/axiom/optimizer/algebra/extension/unoptimized_operand/optimizable_predicate_spec.rb

@@ -5,32 +5,32 @@ require 'spec_helper'
 describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { operand.extend { |r| r.add(*extensions) }           }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { operand.extend { |r| r.add(*extensions) }       }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Extension)
+    expect(object.operation).to be_kind_of(Algebra::Extension)
   end
 
   context 'when the operand is optimizable' do
     let(:operand)    { base.rename({}) }
-    let(:extensions) { [ :text, 1 ]    }
+    let(:extensions) { [:text, 1]      }
 
     it { should be(true) }
   end
 
   context 'when the extensions are optimizable' do
-    let(:operand)    { base                                          }
-    let(:extensions) { [ :text, Function::Numeric::Absolute.new(1) ] }
+    let(:operand)    { base                                        }
+    let(:extensions) { [:text, Function::Numeric::Absolute.new(1)] }
 
     it { should be(true) }
   end
 
   context 'when the operand and extensions are not optimizable' do
-    let(:operand)    { base         }
-    let(:extensions) { [ :text, 1 ] }
+    let(:operand)    { base       }
+    let(:extensions) { [:text, 1] }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/extension/unoptimized_operand/optimize_spec.rb

@@ -5,23 +5,23 @@ require 'spec_helper'
 describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:attribute) { Attribute::Object.new(:text)                        }
-  let(:function)  { Function::Numeric::Absolute.new(1)                  }
-  let(:operand)   { base.rename({})                                     }
-  let(:relation)  { operand.extend { |r| r.add(attribute, function) }   }
-  let(:object)    { described_class.new(relation)                       }
+  let(:header)    { Relation::Header.coerce([[:id, Integer]])         }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1]]))   }
+  let(:attribute) { Attribute::Object.new(:text)                      }
+  let(:function)  { Function::Numeric::Absolute.new(1)                }
+  let(:operand)   { base.rename({})                                   }
+  let(:relation)  { operand.extend { |r| r.add(attribute, function) } }
+  let(:object)    { described_class.new(relation)                     }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should_not equal(operand) }
+  it { should_not be(operand) }
 
   it { should be_kind_of(Algebra::Extension) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
   its(:extensions) { should == { attribute => 1 } }
 end