Normally we use meta-programming in Ruby for our own convenience as developers, and we swallow the speed hit it gives us as a reasonable trade-off. The way Rak is implemented turns this on its head.

Rak compiles its line matching code on the fly, to speed up searching. Its not as horrendous as it sounds. Here’s a very simplified version of the line matching code without the optimization:

def line_match(filename, regex, line)
  if options[:invert_match]
    unless line =~ regex
      if options[:print_filename]
        puts filename
      end
      puts line
    end
  else
    if line =~ regex
      if options[:print_filename]
        puts filename
      end
      puts line
    end
  end
end

We notice that the options hash never changes once the searching has begun. But we are doing an awful lot of work checking the values in the hash for every single line we are matching against. So we replace it with this:

def compile_line_match(filename, regex, line)
  code = []
  code << %{def line_match(filename, regex, line) }
              if options[:invert_match]
  code << %{    unless line =~ regex              }
                  if options[:print_filename]
  code << %{        puts filename                 }
                  end     
  code << %{      puts line                       }
  code << %{    end                               }
              else 
  code << %{    if line =~ regex                  }
                  if options[:print_filename]      
  code << %{        puts filename                 }
                  end        
  code << %{      puts line                       }
  code << %{    end                               }
              end     
  code << %{end                                   }
  module_eval code.join("\\n")
end  

I’ve preserved the indenting so you can see the logic of the method. Here all the option tests have been factored out and will only be done once, at startup. Assuming we are not inverting the match and are printing filenames, the final compiled method looks like this:

def line_match(filename, regex, line)
  if line =~ regex
    puts filename
    puts line
  end
end

Much smaller. This method is 140 lines long in the full version, so its a much more impressive win there. All told this sped up Rak by about two times when I tested it searching on my Phd repository (3500 files).

There’s more work to do optimizing Rak. It’s still not as fast as Ack, so you might want to use that unless you are a Ruby fanboy like me :). But I have some more ideas….

Update 20/04/08: thankyou to redditer tomel for pointing out a WTF in the above code :).