veritas-optimizer 0.0.3

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:relation) { order.drop(1).drop(2)                                    }
+  let(:object)   { described_class.new(relation)                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Offset) }
+
+  its(:operand) { should equal(order) }
+
+  its(:offset) { should == 3 }
+end

data/spec/unit/veritas/optimizer/relation/operation/offset/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each).order }
+  let(:relation) { operand.drop(1)                            }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Offset)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { base.rename({}) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
+  let(:relation) { order.rename({}).drop(1)                   }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Offset) }
+
+  its(:operand) { should equal(order) }
+
+  its(:offset) { should == 1 }
+end

data/spec/unit/veritas/optimizer/relation/operation/offset/zero_offset/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:relation) { base.drop(offset)                                        }
+  let(:object)   { described_class.new(relation)                            }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Offset)
+  end
+
+  context 'when the operation offset is 0' do
+    let(:offset) { 0 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operation offset is not 0' do
+    let(:offset) { 1 }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:relation) { order.drop(0)                                            }
+  let(:object)   { described_class.new(relation)                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(order) }
+end

data/spec/unit/veritas/optimizer/relation/operation/order/one_limit_operand/optimizable_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { operand.order                                      }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Order)
+  end
+
+  context 'when the operand is limited to 1' do
+    let(:operand) { base.order.take(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not limited to 1' do
+    let(:operand) { base.order.take(2) }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is not limited' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/order/one_limit_operand/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:limit)    { base.order.take(1)                                 }
+  let(:relation) { limit.order                                        }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(limit) }
+end

data/spec/unit/veritas/optimizer/relation/operation/order/order_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { operand.order                                      }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Order)
+  end
+
+  context 'when the operand is ordered' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not ordered' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/order/order_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:order)    { base.order                                         }
+  let(:relation) { order.order(order.directions.reverse)              }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  its(:operand) { should equal(base) }
+
+  its(:directions) { should eql(order.directions.reverse) }
+end

data/spec/unit/veritas/optimizer/relation/operation/order/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:relation) { operand.order                              }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Order)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { base.rename({}) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/order/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Order::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { base.rename({}).order                              }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  it { should_not equal(relation) }
+
+  its(:operand) { should equal(base) }
+
+  its(:directions) { should equal(relation.directions) }
+end

data/spec/unit/veritas/optimizer/relation/operation/reverse/order_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { operand.reverse                                    }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Reverse)
+  end
+
+  context 'when the operand is ordered' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not ordered' do
+    let(:operand) { base.order.take(2) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/reverse/order_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:operand)  { base.order                                         }
+  let(:relation) { operand.reverse                                    }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  its(:operand) { should equal(base) }
+
+  its(:directions) { should equal(relation.directions) }
+end

data/spec/unit/veritas/optimizer/relation/operation/reverse/reverse_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::ReverseOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:relation) { operand.reverse                                          }
+  let(:object)   { described_class.new(relation)                            }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Reverse)
+  end
+
+  context 'when the operand is reversed' do
+    let(:operand) { base.drop(1).reverse }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not reversed' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/reverse/reverse_operand/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::ReverseOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:limit)    { base.order.take(2)                                 }
+  let(:operand)  { limit.reverse                                      }
+  let(:relation) { operand.reverse                                    }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(limit) }
+end

data/spec/unit/veritas/optimizer/relation/operation/reverse/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:relation) { operand.reverse                                          }
+  let(:object)   { described_class.new(relation)                            }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Reverse)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { base.reverse }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Reverse::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:order)    { base.order                                         }
+  let(:relation) { order.rename({}).reverse                           }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  it { should_not equal(relation) }
+
+  its(:operand) { should equal(order) }
+
+  its(:directions) { should eql(relation.directions) }
+end

data/spec/unit/veritas/optimizer/relation/operation/unary/empty_operand/optimizable_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Unary::EmptyOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { mock('Relation', :operand => operand) }
+  let(:object)   { described_class.new(relation)         }
+
+  context 'when the operand is empty' do
+    let(:operand) { Relation::Empty.new([ [ :id, Integer ] ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not empty' do
+    let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/unary/empty_operand/optimize_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Unary::EmptyOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:operand)  { Relation::Empty.new([ [ :id, Integer ] ]) }
+  let(:relation) { operand.rename({})                        }
+  let(:object)   { described_class.new(relation)             }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(operand) }
+end

data/spec/unit/veritas/optimizer/relation/operation/unary/materialized_operand/optimizable_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Unary::MaterializedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { mock('Relation', :operand => operand) }
+  let(:object)   { described_class.new(relation)         }
+
+  context 'when the operand is materialized' do
+    let(:operand) { Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not materialized' do
+    let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/unary/materialized_operand/optimize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Unary::MaterializedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]).project([ :id ]) }
+  let(:object)   { described_class.new(relation)                                  }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Materialized) }
+
+  its(:header) { should equal(relation.header) }
+
+  it { should == [ [ 1 ] ] }
+end

data/spec/unit/veritas/optimizer/relation/operation/unary/operand_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Unary, '#operand' do
+  subject { object.operand }
+
+  let(:described_class) { Class.new(Optimizer::Relation::Operation::Unary) }
+  let(:optimized)       { mock('Optimized')                                }
+  let(:operand)         { mock('Operand', :optimize => optimized)          }
+  let(:relation)        { mock('Relation', :operand => operand)            }
+  let(:object)          { described_class.new(relation)                    }
+
+  it { should equal(optimized) }
+end

data/tasks/quality/ci.rake

@@ -0,0 +1,2 @@
+desc 'Heckle and run metrics'
+task :ci => [ :verify_measurements, :heckle, :flog, :flay, :reek, :roodi, 'metrics:all' ]

data/tasks/quality/flay.rake

@@ -0,0 +1,41 @@
+begin
+  require 'flay'
+  require 'yaml'
+
+  config      = YAML.load_file(File.expand_path('../../../config/flay.yml', __FILE__)).freeze
+  threshold   = config.fetch('threshold').to_i
+  total_score = config.fetch('total_score').to_f
+  files       = Flay.expand_dirs_to_files(config.fetch('path', 'lib'))
+
+  # original code by Marty Andrews:
+  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+  desc 'Analyze for code duplication'
+  task :flay do
+    # run flay once without a threshold to ensure the max mass matches the threshold
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => 0)
+    flay.process(*files)
+
+    max = (flay.masses.map { |hash, mass| mass.to_f / flay.hashes[hash].size }.max) || 0
+    unless max >= threshold
+      raise "Adjust flay threshold down to #{max}"
+    end
+
+    total = flay.masses.reduce(0.0) { |total, (hash, mass)| total + (mass.to_f / flay.hashes[hash].size) }
+    unless total == total_score
+      raise "Flay total is now #{total}, but expected #{total_score}"
+    end
+
+    # run flay a second time with the threshold set
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => threshold.succ)
+    flay.process(*files)
+
+    if flay.masses.any?
+      flay.report
+      raise "#{flay.masses.size} chunks of code have a duplicate mass > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flay do
+    abort 'Flay is not available. In order to run flay, you must: gem install flay'
+  end
+end

data/tasks/quality/flog.rake

@@ -0,0 +1,45 @@
+begin
+  require 'flog'
+  require 'yaml'
+
+  class Float
+    def round_to(n)
+      (self * 10**n).round.to_f * 10**-n
+    end
+  end
+
+  config    = YAML.load_file(File.expand_path('../../../config/flog.yml', __FILE__)).freeze
+  threshold = config.fetch('threshold').to_f.round_to(1)
+
+  # original code by Marty Andrews:
+  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+  desc 'Analyze for code complexity'
+  task :flog do
+    flog = Flog.new
+    flog.flog Array(config.fetch('path', 'lib'))
+
+    totals = flog.totals.select  { |name, score| name[-5, 5] != '#none' }.
+                         map     { |name, score| [ name, score.round_to(1) ] }.
+                         sort_by { |name, score| score }
+
+    if totals.any?
+      max = totals.last[1]
+      unless max >= threshold
+        raise "Adjust flog score down to #{max}"
+      end
+    end
+
+    bad_methods = totals.select { |name, score| score > threshold }
+    if bad_methods.any?
+      bad_methods.reverse_each do |name, score|
+        puts '%8.1f: %s' % [ score, name ]
+      end
+
+      raise "#{bad_methods.size} methods have a flog complexity > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flog do
+    abort 'Flog is not available. In order to run flog, you must: gem install flog'
+  end
+end