ruby code quality checker that could catch debugger statement

Question

I am looking for a ruby code quality checker that could catch or notify if something like a 'debugger' statement gets accidentally committed to ruby code. It would also be ideal if it could look in a rails project and scan any places that may contain ruby code like a haml file.

The idea would be that this would be run with cruisecontrol.rb and against a code base where there are holes in test coverage.

Answer 1

Don't over-think it! Just write a simple script to search for it over your app's directory.

Using command-line grep :

grep -r --include='*.rb' debugger .

Using ack :

ack --type=ruby debugger

Using Ruby's grep :

Dir['**/*.rb'].each do |path|
  File.open(path, 'r') do |file|
    file.grep /debugger/ do
      puts path
    end
  end
end

(Ruby code lovingly adapted from _why's Wearing Ruby Slippers to Work )

You might also want to consider searching over Javascript files for "debugger" as well, and possibly "console.log" , etc.

You may also want to make this be more strict to reduce false positives by using something like /^\\s*debugger\\s*$/ to only match it when it's the only thing on the line. Adapting this to work for HAML probably requires a bit more: /^\\s*[-=]\\s*debugger\\s*$/ .

Answer 2

Great answer by @Andrew Mashall. For our rails project we use a slightly modified version:

#!/usr/bin/env ruby                                                                                                                                                                                                                          

expressions = [/^\s*binding\.pry/, /^\s*debugger/, /^\s*console\.log/, /^\s*save_and_open_page/]                                                                                                                                             
debuggers = []                                                                                                                                                                                                                               
dirs = `git ls-files |grep '\\(rb\\|haml\\|rake\\|js\\|coffee\\)$'`.split                                                                                                                                                                    
dirs.each do |path|                                                                                                                                                                                                                          
  File.open(path, 'r') do |file|
    contents = file.read
    expressions.each do |expr|                                                                                                                                                                                                               
      contents.match expr do                                                                                                                                                                                                                      
        debuggers << path                                                                                                                                                                                                                    
      end                                                                                                                                                                                                                                    
    end                                                                                                                                                                                                                                      
  end                                                                                                                                                                                                                                        
end                                                                                                                                                                                                                                          
raise "debugger statements found in #{debuggers.to_s}" unless debuggers.empty?

We also added it into our .git/hooks/pre-commit script and to our continuous-integration build to double-check we don't leave debug statements around...