rak 0.8.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.8.0 / 2007-10-30
+
+* Initial release.
+
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/rak
+lib/rak.rb
+spec/rak_spec.rb
+spec/help_spec.rb

data/README.txt

@@ -0,0 +1,66 @@
+rak
+    by Daniel Lucraft
+    http://rubyforge.org/projects/rak
+
+== DESCRIPTION:
+  
+Replacement for grep. Recursively scans directories to match a given
+Ruby regular expression. Prints highlighted results.
+
+Based on the Perl tool 'ack' by Andy Lester.
+
+Examples with similar grep:
+ 
+  $ rak pattern
+  $ grep pattern $(find . | grep -v .svn)
+
+  $ rak --ruby pattern
+  $ grep pattern $(find . -name '*.rb' | grep -v .svn)
+
+== FEATURES/PROBLEMS:
+  
+* Ruby regular expression syntax (uses oniguruma gem if installed).
+* Highlighted output.
+* Automatically recurses down the current directory or any given
+  directories.
+* Skips version control directories, backups like '~' and '#' and your
+* ruby project's pkg directory.
+* Allows inclusion and exclusion of files based on types.
+* Many options similar to grep.
+
+== SYNOPSIS:
+
+See 'rak --help' for usage information.
+
+== REQUIREMENTS:
+
+* Ruby
+
+== INSTALL:
+
+* gem install rak
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Daniel Lucraft
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,14 @@
+
+require 'rubygems'
+require 'hoe'
+require 'lib/rak'
+
+Hoe.new('rak', Rak::VERSION) do |p|
+  p.rubyforge_name = 'rak'
+  p.author = 'Daniel Lucraft'
+  p.email = 'dan@fluentradical.com'
+  p.summary = 'A grep replacement in Ruby, type "$rak pattern".'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end

data/bin/rak

@@ -0,0 +1,797 @@
+#!/usr/bin/env ruby
+
+require 'getoptlong'
+
+begin
+  require 'rubygems'
+  require 'oniguruma'
+  require 'inline'
+  $use_onig = true
+rescue LoadError
+  $use_onig = false
+end
+
+$use_onig = false
+
+class Rak
+  VERSION = "0.0.1"
+  
+  FILE_COLOUR = "\033[1;31m"
+  MATCH_COLOUR = "\033[1;37m\033[41m"
+  CLEAR_COLOURS = "\033[0m"
+  
+  VERSION_INFO=<<END
+rak #{VERSION}
+
+Copyright 2007 Daniel Lucraft, all rights reserved. 
+Based on the perl tool 'ack' by Andy Lester.
+
+This program is free software; you can redistribute it and/or modify it
+under the same terms as Ruby.
+END
+  
+  FILE_TYPES = {
+    :asm         => %w( .s .S ),
+    #     :binary      => q{Binary files, as defined by Perl's -B op (default: off)},
+    :cc          => %w( .c .h .xs ),
+    :cpp         => %w( .cpp .m .h .C .H ),
+    :csharp      => %w( .cs ),
+    :css         => %w( .css ),
+    :elisp       => %w( .el ),
+    :haskell     => %w( .hs .lhs ),
+    :hh          => %w( .h ),
+    :html        => %w( .htm .html .shtml ),
+    #   :skipped     => q{Files, but not directories, normally skipped by ack (default: off)},
+    :lisp        => %w( .lisp ),
+    :java        => %w( .java properties ),
+    :js          => %w( .js ),
+    :jsp         => %w( .jsp .jspx .jhtm .jhtml ),
+    :make        => %w( Makefile ),
+    :mason       => %w( .mas .mhtml .mpl .mtxt ),
+    :ocaml       => %w( .ml .mli ),
+    :parrot      => %w( .pir .pasm .pmc .ops .pod .pg .tg ),
+    :perl        => %w( .pl .pm .pod .t ),
+    :php         => %w( .php .phpt .php3 .php4 .php5 ),
+    :prolog      => %w( .pl .ecl ),
+    :python      => %w( .py ),
+    :ruby        => %w( .rb .rhtml .rjs .rxml Rakefile ),
+    :scheme      => %w( .scm ),
+    :shell       => %w( .sh .bash .csh .ksh .zsh ),
+    :sql         => %w( .sql .ctl ),
+    :tcl         => %w( .tcl ),
+    :tex         => %w( .tex .cls .sty ),
+    :text        => %w( .txt .text ),
+    :tt          => %w( .tt .tt2 .ttml ),
+    :vb          => %w( .bas .cls .frm .ctl .vb .resx ),
+    :vim         => %w( .vim ),
+    :yaml        => %w( .yaml .yml ),
+    :xml         => %w( .xml .dtd .xslt )
+  }
+  
+  VC_DIRS = %w(blib CVS _darcs .git .pc RCS SCCS .svn pkg)
+  
+  class << self
+    attr_reader :opt
+  end
+  
+  def self.search
+    @opt = {}
+
+    # file types
+    opt[:includes] = []
+    opt[:excludes] = []
+    
+    FILE_TYPES.each do |type, exts|
+      if ARGV.delete('--'+type.to_s)
+        exts.each do |ext|
+          opt[:includes] << ext
+        end
+      end
+      if ARGV.delete('--no'+type.to_s)
+        exts.each do |ext|
+          opt[:excludes] << ext
+        end
+      end
+    end
+    
+      opts = GetoptLong.new(
+                            [ '--help', GetoptLong::OPTIONAL_ARGUMENT ],
+                            [ '--max-count', '-m', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '--files', '-f', GetoptLong::NO_ARGUMENT ],
+                            [ '--output', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '--version', GetoptLong::NO_ARGUMENT ],
+                            [ '-c', '--count', GetoptLong::NO_ARGUMENT ],
+                            [ '-h', '--no-filename', GetoptLong::NO_ARGUMENT ],
+                            [ '-i', '--ignore-case', GetoptLong::NO_ARGUMENT ],
+                            [ '-v', '--invert-match', GetoptLong::NO_ARGUMENT ],
+                            [ '-n', GetoptLong::NO_ARGUMENT ],
+                            [ '-Q', '--literal', GetoptLong::NO_ARGUMENT ],
+                            [ '-o', GetoptLong::NO_ARGUMENT ],
+                            [ '-w', '--word-regexp', GetoptLong::NO_ARGUMENT ],
+                            [ '--group', GetoptLong::NO_ARGUMENT ],
+                            [ '--nogroup', GetoptLong::NO_ARGUMENT ],
+                            [ '-l', '--files-with-matches', GetoptLong::NO_ARGUMENT ],
+                            [ '-L', '--files-without-matches', GetoptLong::NO_ARGUMENT ],
+                            [ '--passthru', GetoptLong::NO_ARGUMENT ],
+                            [ '-H', '--with-filename', GetoptLong::NO_ARGUMENT ],
+                            [ '--colour', GetoptLong::NO_ARGUMENT ],
+                            [ '--nocolour', GetoptLong::NO_ARGUMENT ],
+                            [ '--color', GetoptLong::NO_ARGUMENT ],
+                            [ '--nocolor', GetoptLong::NO_ARGUMENT ],
+                            [ '-a', '--all', GetoptLong::NO_ARGUMENT ],
+                            [ '--type', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '--sort-files', GetoptLong::NO_ARGUMENT ],
+                            [ '--follow', GetoptLong::NO_ARGUMENT ],
+                            [ '--nofollow', GetoptLong::NO_ARGUMENT ],
+                            [ '--after-context', '-A', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '--before-context', '-B', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '--context', '-C', GetoptLong::OPTIONAL_ARGUMENT ],
+                            [ '-g', GetoptLong::REQUIRED_ARGUMENT ],
+                            [ '-x', '--line-regexp', GetoptLong::NO_ARGUMENT ]
+                            )
+
+    dir = nil
+    
+    opt[:max_count] = nil
+    opt[:do_search] = true
+    opt[:print_filename] = true
+    opt[:print_line_number] = true
+    opt[:print_filelist] = false
+    opt[:print_output] = nil
+    opt[:print_highlighted] = true
+    opt[:print_num_matches] = false
+    opt[:ignore_case] = false
+    opt[:invert_match] = false
+    opt[:descend] = true
+    opt[:literal] = false
+    opt[:print_match] = false
+    opt[:match_whole_words] = false
+    opt[:match_whole_lines] = false
+    opt[:print_file_each_line] = false
+    opt[:print_file_if_match] = false
+    opt[:print_file_if_no_match] = false
+    opt[:print_entire_line_if_no_match] = false
+    opt[:colour] = true
+    opt[:all_files] = false
+    opt[:sort_files] = false
+    opt[:follow_symlinks] = false
+    opt[:after_context] = 0
+    opt[:before_context] = 0
+    opt[:collect_context] = false
+    opt[:filename_regex] = nil
+    
+    # if redirected (RAK_TEST allows us to redirect in testing and still 
+    # get the non-redirected defaults).
+    if STDOUT.isatty == false and ENV['RAK_TEST'] != "true"
+      opt[:colour] = false
+      opt[:print_file_each_line] = true
+      opt[:print_filename] = false
+      opt[:print_line_number] = false
+    end
+    
+    begin
+      opts.each do |option, arg|
+        case option
+        when '--help'
+          if arg == ""
+            puts USAGE_HELP
+          elsif arg == "types"
+            puts TYPES_HELP
+          end
+          exit
+        when '--max-count'
+          opt[:max_count] = arg.to_i
+        when '--files'
+          opt[:do_search] = false
+          opt[:print_filelist] = true
+        when '--output'
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_output] = arg
+          opt[:print_highlighted] = false
+        when '--version'
+          puts VERSION_INFO
+          exit
+        when '-c'
+          opt[:print_num_matches] = true
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_highlighted] = false
+        when '-h'
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_file_each_line] = false
+        when '-i'
+          opt[:ignore_case] = true
+        when '-v'
+          opt[:invert_match] = true
+        when '-n'
+          opt[:descend] = false
+        when '-Q'
+          opt[:literal] = true
+        when '-o'
+          opt[:print_match] = true
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_highlighted] = false
+        when '-w'
+          opt[:match_whole_words] = true
+        when '--group'
+          opt[:print_filename] = true
+          opt[:print_file_each_line] = false
+        when '--nogroup'
+          opt[:print_file_each_line] = true
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+        when '-l'
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_highlighted] = false
+          opt[:print_file_if_match] = true
+        when '-L'
+          opt[:print_filename] = false
+          opt[:print_line_number] = false
+          opt[:print_highlighted] = false
+          opt[:print_file_if_no_match] = true
+        when '--passthru'
+          opt[:print_entire_line_if_no_match] = true
+        when '-H'
+          opt[:print_filename] = true
+          opt[:print_line_number] = true
+        when '--nocolour', '--nocolor'
+          opt[:colour] = false
+        when '--colour', '--color'
+          opt[:colour] = true
+        when '-a'
+          opt[:all_files] = true
+        when '--type'
+          if arg[0..1] == "no"
+            type = arg[2..-1]
+            arr = opt[:excludes]
+          else
+            type = arg
+            arr = opt[:includes]
+          end
+          exts = FILE_TYPES[type.intern]
+          unknown_type(type) unless exts
+          exts.each do |ext|
+            arr << ext
+          end
+        when '--sort-files'
+          opt[:sort_files] = true
+        when '--follow'
+          opt[:follow_symlinks] = true
+        when '--nofollow'
+          opt[:follow_symlinks] = false
+        when '--after-context'
+          opt[:use_context] = true
+          opt[:after_context] = arg.to_i
+        when '--before-context'
+          opt[:use_context] = true
+          opt[:before_context] = arg.to_i
+        when '--context'
+          opt[:use_context] = true
+          if arg == ""
+            val = 2
+          else
+            val = arg.to_i
+          end
+          opt[:before_context] = val
+          opt[:after_context] = val
+        when '-g'
+          opt[:filename_regex] = arg
+        when '-x'
+          opt[:match_whole_lines] = true
+        end
+      end
+    rescue GetoptLong::InvalidOption => ex
+      puts "rak: see rak --help for usage."
+      exit
+    rescue SystemExit
+      exit
+    end
+
+    if ARGV.empty? and opt[:print_filelist] == false
+      puts USAGE_HELP
+      exit
+    end
+    
+    files = get_files
+    
+    compile_match_file
+
+    unless opt[:colour]
+      FILE_COLOUR.replace ""
+      CLEAR_COLOURS.replace ""
+      MATCH_COLOUR.replace ""
+    end
+
+    print_files(files)      if opt[:print_filelist]
+    search2(ARGV[0], files) if opt[:do_search]
+  end
+  
+  def self.print_files(files)
+    files.each do |fn|
+      puts fn
+    end
+  end
+  
+  def self.get_all_files(files=[], dir="./")
+    Dir[dir+"*"].each do |fn|
+      if File.directory? fn
+        if opt[:descend] 
+          if File.symlink? fn
+            if opt[:follow_symlinks]
+              get_all_files(files, fn+"/")
+            end
+          else
+            get_all_files(files, fn+"/")
+          end
+        end
+      else
+        if File.symlink? fn
+          if opt[:follow_symlinks]
+            files << fn
+          end
+        else
+          files << fn
+        end
+      end
+    end
+    files
+  end
+  
+  def self.get_files(dir="./")
+    types_files = FILE_TYPES.invert
+    types = types_files.keys.flatten
+    files_and_dirs = ARGV[1..-1]
+    io_files = []
+    if !files_and_dirs or files_and_dirs.empty?
+      if STDIN.isatty == false
+        io_files << STDIN
+        opt[:print_filename] = false
+        files = []
+      else
+        files = get_all_files
+      end
+    else
+      files = []
+      files_and_dirs.each do |thing|
+        if File.file? thing
+          files << thing
+        end
+        if File.directory? thing
+          get_all_files(files, thing)
+        end
+      end
+      if files_and_dirs.length == 1 and 
+          File.file? files_and_dirs[0]
+        opt[:print_filename] = false
+      end
+    end
+    
+    # strip out based on extension
+    shebang_files = []
+    unless opt[:all_files]
+      files = files.select do |fn|
+        fn[-1..-1] != "~" and
+          fn[-1..-1] != "#"
+      end
+      new_files = []
+      files.each do |fn|
+        if types.any? {|ext| File.extname(fn) == ext or fn.split("/").last == ext}
+          new_files << fn
+        elsif ext = shebang_matches(fn)
+          shebang_files << [fn, ext]
+        end
+      end
+      files = new_files
+    end
+    
+    # select based on file type
+    if not opt[:includes].empty?
+      files = files.select do |fn|
+        opt[:includes].any? {|ext| fn.include? ext}
+      end
+      shebang_files2 = []
+      shebang_files.each do |fn, ext|
+        if opt[:includes].include? ext
+          shebang_files2 << [fn, ext]
+        end
+      end
+    else
+      shebang_files2 = shebang_files
+    end
+    
+    if not opt[:excludes].empty?
+      files = files.select do |fn|
+        not opt[:excludes].any? {|ext| fn.include? ext}
+      end
+      shebang_files3 = []
+      shebang_files2.each do |fn, ext|
+        unless opt[:excludes].any? {|ext| fn.include? ext}
+          shebang_files3 << [fn, ext]
+        end
+      end
+    else
+      shebang_files3 = shebang_files2
+    end
+    
+    files += shebang_files3.map {|fn, ext| fn}
+    
+    # reject version control dirs
+    files.reject! do |fn|
+      VC_DIRS.any? {|vc| fn.include? vc}
+    end
+    
+    # filter based on -g=REGEX
+    if opt[:filename_regex]
+      if $use_onig
+        fn_re = Oniguruma::ORegexp.new(opt[:filename_regex])
+      else
+        fn_re = Regexp.new(opt[:filename_regex])
+      end
+      files = files.select {|fn| fn =~ fn_re }
+    end
+    
+    # remove the "./"
+    files.map! {|fn| fn[0..1] == "./" ? fn[2..-1] : fn}
+    
+    if opt[:sort_files]
+      files = files.sort_by {|fn| fn.downcase}
+    end
+    
+    files + io_files
+  end
+  
+  def self.shebang_matches(fn)
+    File.open(fn) do |f|
+      begin
+        line = f.readline
+      rescue
+        line = ""
+      end
+      if line =~ /^#!/
+          if line =~ /\b(ruby|perl|php|python)\b/
+            return "."+FILE_TYPES[$1.intern].first
+          elsif line =~ /\b(bash|csh|ksh|zsh)\b/
+            return ".sh"
+          end
+      else
+        if line =~ /\Q<?xml /
+          return ".xml"
+        end
+      end
+      return false
+    end
+  end
+    
+  def self.search2(str, files)
+    if opt[:literal]
+      str = Regexp.quote(str)
+    end
+    if opt[:match_whole_words]
+      str = "\\b" + str + "\\b"
+    end
+    if opt[:match_whole_lines]
+      str = "^" + str + "$"
+    end
+    if $use_onig
+      if opt[:ignore_case]
+        re = Oniguruma::ORegexp.new(str, :options => Oniguruma::OPTION_IGNORECASE)
+      else
+        re = Oniguruma::ORegexp.new(str)
+      end
+    else
+      if opt[:ignore_case]
+        re = Regexp.new(str, Regexp::IGNORECASE)
+      else
+        re = Regexp.new(str)
+      end
+    end
+    files.each do |fn| 
+      match_file(re, fn)
+    end
+  end
+  
+  # this is tricky thing. Ignore the "code <<" to see the
+  # logic. Because the options never change we conditionally compile
+  # the match method based on them. This is gives a 2x speedup over
+  # the alternative.
+  def self.compile_match_file
+    code = ""
+    def code.<<(str)
+      self.concat(str + "\n")
+    end
+    code << %{def self.match_file(re, fn)        }
+    code << %{  displayed_filename = false       }
+    code << %{  count = 0                        }
+    code << %{  i = 0                            }
+    code << %{  matches = []                     }
+    code << %{  print_num = 0                    }
+
+                if opt[:before_context] > 0
+    code << %{    before_context = []                           }
+    code << %{    before_context_size = opt[:before_context]    }
+                end
+    code << %{  if fn.is_a? String              }
+    code << %{    f = File.open(fn, "r")        }
+    code << %{  elsif fn.is_a? IO               }
+    code << %{    f = fn                        }
+    code << %{  end                             }
+    
+    code << %{  f.each_line do |line|                                          }
+    code << %{    i += 1                                                         }
+    code << %{    rest = line                                                      }
+    code << %{    while md = re.match(rest)                                   }
+    code << %{      rest = md.post_match                                          }
+                    if opt[:print_output]
+    code << %{        matches << eval(opt[:print_output])                            }
+                    else
+    code << %{        matches << md                                               }
+                    end
+                    if opt[:print_match]
+    code << %{        puts md.to_s                                               }
+                    end
+    code << %{      count += 1                                                      }
+    code << %{    end                                                             }
+                  if opt[:invert_match]
+                    if opt[:print_filename] 
+    code << %{        unless displayed_filename                                   }
+    code << %{          puts FILE_COLOUR + fn + CLEAR_COLOURS                            }
+    code << %{          displayed_filename = true                                   }
+    code << %{        end                                                               }
+                    end
+    code << %{      if matches.empty?                                                 }
+                      if opt[:print_highlighted]
+                        if opt[:print_line_number]
+    code << %{            print "\#{i.to_s.rjust(4)}|"                            }
+                        end
+    code << %{          puts "\#{line}"                                          }
+                      end
+    code << %{      end                                                               }
+    code << %{      matches.clear                                                   }
+                  else
+    code << %{      if matches.empty?                                                 }
+                      if opt[:print_entire_line_if_no_match]
+    code << %{          puts line                                                 }
+                      end
+                      if opt[:use_context]
+                        if opt[:before_context] > 0 
+    code << %{            if print_num == 0                                                 }
+    code << %{              before_context << [i, line]                                   }
+    code << %{              if before_context.length == before_context_size+1                            }
+    code << %{                before_context = before_context[1..-1]                            }
+    code << %{              end                                                               }
+    code << %{            end                                                               }
+                        end
+    code << %{          if print_num > 0                                                 }
+    code << %{            print_num -= 1                                                 }
+                          if opt[:print_highlighted]
+                            if opt[:print_line_number]
+    code << %{                print "\#{i.to_s.rjust(4)}|"                            }
+                            end
+    code << %{              puts "\#{line}"                                          }
+    code << %{            end                                                        }
+                        end
+                      end
+    code << %{      else                                                                      }
+    code << %{        print_num = opt[:after_context]                                          }
+                      if opt[:print_filename]
+    code << %{          unless displayed_filename                                          }
+    code << %{            puts FILE_COLOUR + fn + CLEAR_COLOURS                            }
+    code << %{            displayed_filename = true                                          }
+    code << %{          end                                                               }
+                      end
+                      if opt[:before_context] > 0
+    code << %{          before_context.each do |before_i, before_line|                            }
+                          if opt[:print_line_number]
+    code << %{              print "\#{before_i.to_s.rjust(4)}|"                            }
+                          end
+    code << %{            puts before_line                                                 }
+    code << %{          end                                                               }
+    code << %{          before_context = []                                                 }
+                      end       
+                      if opt[:print_output]
+    code << %{          matches.each {|m| puts m}                                          }
+                      end
+                      if opt[:print_highlighted]
+                        if opt[:print_line_number]
+    code << %{            prefix = "\#{i.to_s.rjust(4)}|"                                   }
+                        else
+                          if opt[:print_file_each_line]
+    code << %{              fn_str = (fn.is_a?(String) ? FILE_COLOUR + fn + CLEAR_COLOURS + " " : "")                            }
+    code << %{              prefix = fn_str + "\#{i.to_s.rjust(4)}|"                            }
+                          else
+    code << %{              prefix = ""                                                        }
+                          end
+                        end
+    code << %{          print_highlighted(prefix, line, matches)                            }
+                      end
+    code << %{      end                                                                      }
+                    if opt[:max_count] 
+    code << %{        if count >= opt[:max_count]                                          }
+    code << %{          break                                                               }
+    code << %{        end                                                               }
+                    end
+    code << %{      matches.clear                                                        }
+                  end
+    code << %{  end                                                                      }
+                if opt[:print_highlighted] and opt[:print_filename]
+    code << %{    if count > 0                                                               }
+    code << %{      puts                                                                      }
+    code << %{    end                                                                      }
+                end
+    code << %{  f.close if f === File                                                        }
+                if opt[:print_num_matches]
+                  if opt[:invert_match]
+    code << %{      puts "\#{fn}:\#{i-count}"                                                 }
+                  else       
+    code << %{      puts "\#{fn}:\#{count}"                                                 }
+                  end
+                end
+                if opt[:print_file_if_match]
+    code << %{    if count > 0                                                               }
+    code << %{      puts fn                                                               }
+    code << %{    end                                                                      }
+                end
+    
+                if opt[:print_file_if_no_match]
+    code << %{    if count == 0                                                               }
+    code << %{      puts fn                                                                      }
+    code << %{    end                                                                      }
+                end 
+    code << %{end }
+#    if ENV['RACK_TEST'] == "true"
+#      File.open("compiled_method.rb", "w") {|f| f.puts code}
+#    end
+    module_eval code
+  end
+  
+  def self.print_highlighted(prefix, line, matches)
+    from1 = matches[0].begin(0)
+    pre = ""
+    pre = line[0..(from1-1)] if from1 > 0
+    print prefix
+    print pre
+    ptr = 0
+    0.upto(matches.length-1) do |n|
+      from = matches[n].begin(0)
+      to   = matches[n].end(0)
+      print MATCH_COLOUR +
+        line[(from+ptr)..(to+ptr-1)] +
+        CLEAR_COLOURS
+      ptr += to
+      if n == matches.length - 1
+        puts matches.last.post_match
+      else
+        print line[ptr..(matches[n+1].begin(0)-1+ptr)]
+      end
+    end
+  end
+  
+  def self.unknown_type(type)
+    puts "rak: Unknown --type \"#{type}\""
+    puts "rak: See rak --help types"
+    exit
+  end
+end
+
+USAGE_HELP=<<END
+Usage: rak [OPTION]... PATTERN [FILES]
+
+Search for PATTERN in each source file in the tree from cwd on down.
+If [FILES] is specified, then only those files/directories are checked.
+rak will search STDIN only if no FILES are specified.
+
+Example: rak -i select
+
+Searching:
+  -i, --ignore-case     Ignore case distinctions
+  -v, --invert-match    Invert match: select non-matching lines
+  -w, --word-regexp     Force PATTERN to match only whole words
+  -x, --line-regexp     Force PATTERN to match only whole lines
+  -Q, --literal         Quote all metacharacters; expr is literal
+
+Search output:
+  -l, --files-with-matches
+                        Only print filenames containing matches
+  -L, --files-without-match
+                        Only print filenames with no match
+  -o                    Show only the part of a line matching PATTERN
+                        (turns off text highlighting)
+  --passthru            Print all lines, whether matching or not
+  --output=expr         Output the evaluation of expr for each line
+                        (turns off text highlighting)
+  -m, --max-count=NUM   Stop searching in a file after NUM matches
+  -H, --with-filename   Print the filename for each match
+  -h, --no-filename     Suppress the prefixing filename on output
+  -c, --count           Show number of lines matching per file
+
+  --group               Group matches by file name.
+                        (default: on when used interactively)
+  --nogroup             One result per line, including filename, like grep
+                        (default: on when the output is redirected)
+
+  --[no]colour          Highlight the matching text (default: on unless
+                        output is redirected, or on Windows)
+                                             
+  -A NUM, --after-context=NUM
+                        Print NUM lines of trailing context after matching
+                        lines.
+  -B NUM, --before-context=NUM
+                        Print NUM lines of leading context before matching
+                        lines.
+  -C [NUM], --context[=NUM]
+                        Print NUM lines (default 2) of output context.
+
+File finding:
+  -f                    Only print the files found, without searching.
+                        The PATTERN must not be specified.
+  --sort-files          Sort the found files lexically.
+
+File inclusion/exclusion:
+  -n                    No descending into subdirectories
+  -g REGEX              Only search in file matching REGEX.
+  -a, --all             All files, regardless of extension (but still skips
+                        blib, pkg, CVS, _darcs, .git, .pc, RCS, SCCS and .svn dirs)
+  --ruby                Include only Ruby files.
+  --type=ruby           Include only Ruby files.
+  --noruby              Exclude Ruby files.
+  --type=noruby         Exclude Ruby files.
+                        See "rak --help type" for supported filetypes.
+  --[no]follow          Follow symlinks.  Default is off.
+
+Miscellaneous:
+  --help                This help
+  --version             Display version & copyright
+END
+
+TYPES_HELP=<<END
+Usage: rak [OPTION]... PATTERN [FILES]
+
+The following is the list of filetypes supported by rak.  You can
+specify a file type with the --type=TYPE format, or the --TYPE
+format.  For example, both --type=ruby and --ruby work.
+
+Note that some extensions may appear in multiple types.  For example,
+.pod files are both Perl and Parrot.
+
+    --[no]asm       .s
+    --[no]cc        .c .h .xs
+    --[no]cpp       .cpp .m .h
+    --[no]csharp    .cs
+    --[no]css       .css
+    --[no]elisp     .el
+    --[no]erlang    .erl
+    --[no]fortran   .f .f77 .f90 .f95 .f03 .for .ftn .fpp
+    --[no]haskell   .hs .lhs
+    --[no]hh        .h
+    --[no]html      .htm .html .shtml
+    --[no]java      .java .properties
+    --[no]js        .js
+    --[no]jsp       .jsp .jspx .jhtm .jhtml
+    --[no]lisp      .lisp
+    --[no]make      Makefile
+    --[no]mason     .mas .mhtml .mpl .mtxt
+    --[no]ocaml     .ml .mli
+    --[no]parrot    .pir .pasm .pmc .ops .pod .pg .tg
+    --[no]perl      .pl .pm .pod .t
+    --[no]php       .php .phpt .php3 .php4 .php5
+    --[no]prolog    .pl .ecl
+    --[no]python    .py
+    --[no]ruby      .rb .rhtml .rjs .rxml Rakefile
+    --[no]scheme    .scm
+    --[no]shell     .sh .bash .csh .ksh .zsh
+    --[no]sql       .sql .ctl
+    --[no]tcl       .tcl
+    --[no]tex       .tex .cls .sty
+    --[no]text      .txt .text
+    --[no]tt        .tt .tt2 .ttml
+    --[no]vb        .bas .cls .frm .ctl .vb .resx
+    --[no]vim       .vim
+    --[no]xml       .xml .dtd .xslt
+    --[no]yaml      .yaml .yml
+END
+
+Rak.search