katsuya-rcov 0.9.7.1

data/BLURB

@@ -0,0 +1,111 @@
+Overview
+========
+rcov is a code coverage tool for Ruby. It is commonly used for viewing overall
+test coverage of target code. It features:
+* fast execution: 20-300 times faster than previous tools
+* multiple analysis modes: standard, bogo-profile, "intentional testing",
+  dependency analysis...
+* detection of uncovered code introduced since the last run ("differential
+  code coverage")
+* fairly accurate coverage information through code linkage inference using 
+  simple heuristics
+* cross-referenced XHTML and several kinds of text reports
+* support for easy automation with Rake
+* colorblind-friendliness
+
+How do I use it?
+================
+
+In the common scenario, your tests are under test/ and the target code
+(whose coverage you want) is in lib/. In that case, all you have to do is
+use rcov to run the tests (instead of testrb), and a number of XHTML files
+with the code coverage information will be generated, e.g.
+
+    rcov -Ilib test/*.rb
+
+will execute all the .rb files under test/ and generate the code coverage
+report for the target code (i.e. for the files in lib/) under coverage/. The
+target code needs not be under lib/; rcov will detect is as long as it is
+require()d by the tests. rcov is smart enough to ignore "uninteresting"
+files: the tests themselves, files installed in Ruby's standard locations,
+etc.  See  rcov --help  for the list of regexps rcov matches filenames
+against.
+
+rcov can also be used from Rake; see readme_for_rake or the RDoc documentation
+for more information.
+
+rcov can output information in several formats, and perform different kinds
+of analyses in addition to plain code coverage.  See  rcov --help  for a
+description of the available options.
+
+Sample output
+=============
+
+The text report (also used by default in RcovTasks) resembles
+
+
++-----------------------------------------------------+-------+-------+--------+
+|                  File                               | Lines |  LOC  |  COV   |
++-----------------------------------------------------+-------+-------+--------+
+|lib/rcov.rb                                          |   572 |   358 |  91.3% |
++-----------------------------------------------------+-------+-------+--------+
+|Total                                                |   572 |   358 |  91.3% |
++-----------------------------------------------------+-------+-------+--------+
+91.3%   1 file(s)   572 Lines   358 LOC
+
+
+
+The (undecorated) textual output with execution count information looks like this:
+
+ $ rcov --no-html --text-counts b.rb 
+ ================================================================================
+ ./b.rb
+ ================================================================================
+                                                                       |      2
+ a, b, c = (1..3).to_a                                                 |      2
+ 10.times do                                                           |      1
+   a += 1                                                              |     10
+   20.times do |i|                                                     |     10
+     b += i                                                            |    200
+     b.times do                                                        |    200
+       c += (j = (b-a).abs) > 0 ? j : 0                                | 738800
+     end                                                               |      0
+   end                                                                 |      0
+ end                                                                   |      0
+
+
+rcov can detect when you've added code that was not covered by your unit
+tests:
+
+    $ rcov --text-coverage-diff --no-color test/*.rb
+    Started
+    .......................................
+    Finished in 1.163085 seconds.
+    
+    39 tests, 415 assertions, 0 failures, 0 errors
+    
+    ================================================================================
+    !!!!! Uncovered code introduced in lib/rcov.rb
+    
+    ### lib/rcov.rb:207
+       
+	 def precompute_coverage(comments_run_by_default = true)
+	   changed = false
+	   lastidx = lines.size - 1
+	   if (!is_code?(lastidx) || /^__END__$/ =~ @lines[-1]) && !@coverage[lastidx]
+    !!       # mark the last block of comments
+    !!       @coverage[lastidx] ||= :inferred
+    !!       (lastidx-1).downto(0) do |i|
+    !!         break if is_code?(i)
+    !!         @coverage[i] ||= :inferred
+    !!       end
+    !!     end
+	   (0...lines.size).each do |i|
+	     next if @coverage[i]
+	     line = @lines[i]
+
+
+
+License
+-------
+rcov is released under the terms of Ruby's license.

data/LICENSE

@@ -0,0 +1,53 @@
+rcov is copyrighted free software by Mauricio Fernandez <mfp@acm.org>.
+You can redistribute it and/or modify it under either the terms of the GPL,
+or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/Rakefile

@@ -0,0 +1,103 @@
+$:.unshift "lib" if File.directory? "lib"
+require 'rcov/rcovtask'
+require 'rcov/version'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+# Use the specified rcov executable instead of the one in $PATH
+# (this way we get a sort of informal functional test).
+# This could also be specified from the command like, e.g.
+#   rake rcov RCOVPATH=/path/to/myrcov
+ENV["RCOVPATH"] = "bin/rcov"
+
+# The following task is largely equivalent to:
+# Rcov::RcovTask.new
+desc "Create a cross-referenced code coverage report."
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.rcov_opts << "--xrefs"  # comment to disable cross-references
+  t.verbose = true
+end
+
+desc "Analyze code coverage for the FileStatistics class."
+Rcov::RcovTask.new(:rcov_sourcefile) do |t|
+  t.test_files = FileList['test/file_statistics_test.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.output_dir = "coverage.sourcefile"
+end
+
+Rcov::RcovTask.new(:rcov_ccanalyzer) do |t|
+  t.test_files = FileList['test/code_coverage_analyzer_test.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.ruby_opts << "-Ilib:ext/rcovrt" # in order to use this rcov
+  t.output_dir = "coverage.ccanalyzer"
+end
+
+desc "Run the unit tests with rcovrt."
+if RUBY_PLATFORM == 'java'
+  Rake::TestTask.new(:test_rcovrt => ["lib/rcovrt.jar"]) do |t|
+    t.libs << "lib"
+    t.ruby_opts << "--debug"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+
+  file "lib/rcovrt.jar" => FileList["ext/java/**/*.java"] do |t|
+    rm_f "lib/rcovrt.jar"
+    mkdir_p "pkg/classes"
+    sh "javac -classpath #{Java::JavaLang::System.getProperty('java.class.path')} -d pkg/classes #{t.prerequisites.join(' ')}"
+    sh "jar cf #{t.name} -C pkg/classes ."
+  end
+else
+    Rake::TestTask.new(:test_rcovrt => ["ext/rcovrt/rcovrt.so"]) do |t|
+    system("cd ext/rcovrt && make clean && rm Makefile")
+    t.libs << "ext/rcovrt"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+end
+
+file "ext/rcovrt/rcovrt.so" => FileList["ext/rcovrt/*.c"] do
+  ruby "setup.rb config"
+  ruby "setup.rb setup"
+end
+
+desc "Run the unit tests in pure-Ruby mode ."
+Rake::TestTask.new(:test_pure_ruby) do |t|
+  t.libs << "ext/rcovrt"
+  t.test_files = FileList['test/turn_off_rcovrt.rb', 'test/*_test.rb']
+  t.verbose = true
+end
+
+desc "Run the unit tests"
+task :test => [:test_rcovrt]
+
+desc "install by setup.rb"
+task :install do
+  sh "sudo ruby setup.rb install"
+end
+
+task :default => :test
+
+begin
+  %w{sdoc sdoc-helpers rdiscount}.each { |name| gem name }
+  require 'sdoc_helpers'
+rescue LoadError => ex
+  puts "sdoc support not enabled:"
+  puts ex.inspect
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ''
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rcov #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/THANKS

@@ -0,0 +1,110 @@
+Jay McGaffigan:
+* JRuby support integrated from original rcov4j
+
+Aaron Bedra:
+* major refactoring
+* added threshold testing
+* Took on the task of keeping RCov going
+
+Corey Ehmke (Bantik):
+* redesigned index and detail XHTML
+* added sortable columns in coverage table
+* added file and coverage threshold filters to index XHTML
+* added print-specific style sheet
+* added support for custom CSS for XHTML output
+
+Tom Dolbilin:
+ * identified and fixed backslash problem on win32 for generated filenames
+
+Andrew Kreiling:
+* made the index XHTML compliant
+* consolidate multiple references to the same underlying .rb file
+
+Robert Feldt:
+* pointed me to dynamic uses of the tracing hooks, provided the inspiration
+  for RCOV__.run_hooked
+* helped to refine the color scheme
+
+Andre Nathan:
+* identified a bug in the heuristics: missing propagation for lines
+  with only }, ), ]
+
+David Roberts: 
+* reported confusing behavior when all files are ignored because they match
+  a regexp in the reject list
+* tested the RubyGems package for win32
+
+John-Mason Shackelford:
+* reported an important bug in the pure-Ruby tracer module, which broke it
+  altogether in 0.4.0
+* suggested a change in the CSS to make XHTML reports more readable under IE
+
+Dave Burt:
+* reported an issue with text reports under cmd.exe (should use < 80 cols)
+
+Alex Wayne:
+* reported problem with heredocs: they were not being marked as a whole if
+  the "header" wasn't reported by Ruby.
+* reported problem with the last line of literal data structs not being
+  covered if there was stuff after the end delimiter
+
+Coda Hale:
+* reported problem with blocks were the first line is not being marked
+  and ditto for the last line when end/} is followed by more stuff
+
+Tim Shadel:
+* reported that the last comment block was not being marked even when
+  it was the last thing in the file
+
+Thomas Leitner:
+* reported that the SCRIPT_LINES__ workaround did not always work
+* fixed the bug which broke differential reports for filenames with
+  special characters
+
+Assaph Mehr:
+* beta-tested 0.7.0 and found a bug in --aggregate (missing files)
+
+Ryan Kinderman:
+* suggested that -Ipath be passed to ruby instead of rcov in RcovTasks
+
+Jan Svitok:
+* reported typo in rcovtask.rb's RDoc
+
+rubikitch:
+* implemented --annotate mode
+* implemented --gcc option
+* superior emacs support
+* testing, refactoring...
+* many other things, see darcs changes
+
+Zed A. Shaw:
+* reported and fixed segfault triggered by rspec
+
+Lee Marlow:
+* patch allowing to run rcov against a data file with no input code
+
+Kurt Stephens:
+* patch to rethrow any exceptions generated by the traced scripts after
+  report generation; notably SystemExit, allowing to use the exit code from
+  test runners under rake.
+
+Brian Candler:
+* found compatibility issues with the REXML lib included in ruby-1.8.6-p110
+  and provided a workaround
+
+Mat Schaffer:
+* reported missing line colorization on Safari and probably other browsers,
+  owing to self-closing <a> not being handled properly despite being valid
+  XHTML 1.0.
+
+Sam Granieri:
+* tested workaround for REXML bug
+
+Kosmas Schütz, Daniel Berger, François Beausoleil, Bil Kleb:
+* provided information about the ruby-1.8.6-p11[01] REXML problems
+
+Chad Humphries:
+* indicated that Spec::DSL::Example has changed in RSpec trunk
+
+Jeremy Hinegardner:
+* more info about REXML's bugs in 1.8.6-p11[01]

data/bin/rcov

@@ -0,0 +1,514 @@
+#!/usr/bin/env ruby
+# -*- coding: iso-8859-1 -*-
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# rcov originally based on 
+# module COVERAGE__ originally (c) NAKAMURA Hiroshi
+# module PrettyCoverage originally (c) Simon Strandgaard
+#
+# rewritten & extended by Mauricio Fern�ndez <mfp@acm.org>
+#
+# See LEGAL and LICENSE for additional licensing information.
+#
+require 'cgi'
+require 'rbconfig'
+require 'optparse'
+require 'ostruct'
+
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+require 'rcov/version'
+require 'rcov/formatters'
+
+#{{{ "main" code
+options = OpenStruct.new
+options.color = true
+options.range = 30.0
+options.profiling = false
+options.destdir = nil
+options.loadpaths = []
+options.textmode = false
+options.skip = Rcov::BaseFormatter::DEFAULT_OPTS[:ignore]
+options.include = []
+options.html = true
+options.css = nil
+options.comments_run_by_default = false
+options.test_unit_only = false
+options.spec_only = false
+options.sort = :name
+options.sort_reverse = false
+options.output_threshold = 101
+options.failure_threshold = nil
+options.replace_prog_name = false
+options.callsites = false
+options.crossrefs = false
+options.coverage_diff_file = "coverage.info"
+options.coverage_diff_mode = :compare
+options.coverage_diff_save = false
+options.diff_cmd = "diff"
+options.report_cov_bug_for = nil
+options.aggregate_file = nil
+options.gcc_output = false
+options.charset = nil
+
+EXTRA_HELP = <<-EOF
+
+You can run several programs at once:
+  rcov something.rb somethingelse.rb
+
+The parameters to be passed to the program under inspection can be specified
+after --:
+
+  rcov -Ilib -t something.rb -- --theseopts --are --given --to --something.rb
+
+ARGV will be set to the specified parameters after --.
+Keep in mind that all the programs are run under the same process
+(i.e. they just get Kernel#load()'ed in sequence).
+
+$PROGRAM_NAME (aka. $0) will be set before each file is load()ed if
+--replace-progname is used.
+EOF
+
+def deprecated(opt)
+  puts "#{opt} is now depricated.  Please remove it from you Rakefile or scripts.  It will be removed in the next release."
+end
+
+#{{{ OptionParser
+opts = OptionParser.new do |opts|
+    opts.banner = <<-EOF
+rcov #{Rcov::VERSION} #{Rcov::RELEASE_DATE}
+Usage: rcov [options] <script1.rb> [script2.rb] [-- --extra-options]
+EOF
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-o", "--output PATH", "Destination directory.") do |dir|
+    options.destdir = dir
+  end
+  
+  opts.on("-I", "--include PATHS", "Prepend PATHS to $: (colon separated list)") do |paths|
+    options.loadpaths = paths.split(/:/)
+  end
+  
+  opts.on("--[no-]comments", "Mark all comments by default.", "(default: --no-comments)") do |comments_run_p|
+    options.comments_run_by_default = comments_run_p
+  end
+  
+  opts.on("--test-unit-only", "Only trace code executed inside TestCases.") do
+    deprecated("--test-unit-only")
+  end
+  
+  opts.on("--spec-only", "Only trace code executed inside RSpec specs.") do
+    deprecated("--spec-only")
+  end
+  
+  opts.on("-n", "--no-color", "Create colorblind-safe output.") do
+    options.color = false
+  end
+  
+  opts.on("-i", "--include-file PATTERNS", 
+          "Generate info for files matching a",
+          "pattern (comma-separated regexp list)") do |list|
+    begin
+      regexps = list.split(/,/).map{|x| Regexp.new(x) }
+      options.include += regexps
+    rescue RegexpError => e
+      raise OptionParser::InvalidArgument, e.message
+    end
+  end
+  
+  opts.on("-x", "--exclude PATTERNS", "Don't generate info for files matching a","pattern (comma-separated regexp list)") do |list|
+    begin
+      regexps = list.split(/,/).map{|x| Regexp.new x}
+        options.skip += regexps
+    rescue RegexpError => e
+        raise OptionParser::InvalidArgument, e.message
+    end
+  end
+  
+  opts.on("--exclude-only PATTERNS", "Skip info only for files matching the", "given patterns.") do |list|
+    begin
+      options.skip = list.split(/,/).map{|x| Regexp.new(x) }
+    rescue RegexpError => e
+      raise OptionParser::InvalidArgument, e.message
+    end
+  end
+  
+  opts.on("--rails", "Skip config/, environment/ and vendor/.") do 
+    options.skip.concat [%r{\bvendor/},%r{\bconfig/},%r{\benvironment/}]
+  end
+  
+  opts.on("--[no-]callsites", "Show callsites in generated XHTML report.", "(somewhat slower; disabled by default)") do |val|
+    options.callsites = val
+  end
+  
+  opts.on("--[no-]xrefs", "Generate fully cross-referenced report.", "(includes --callsites)") do |val|
+    options.crossrefs = val
+    options.callsites ||= val
+  end
+  
+  opts.on("-p", "--profile", "Generate bogo-profiling info.") do
+    options.profiling = true
+    options.destdir ||= "profiling"
+  end
+  
+  opts.on("-r", "--range RANGE", Float, "Color scale range for profiling info (dB).") do |val|
+      options.range = val
+  end
+  
+  opts.on("-a", "--annotate", "Generate annotated source code.") do
+    options.html = false
+    options.textmode = :annotate
+    options.crossrefs = true
+    options.callsites = true
+    options.skip = [ %r!/test/unit/! ]
+  end
+  
+  opts.on("-T", "--text-report", "Dump detailed plain-text report to stdout.", "(filename, LoC, total lines, coverage)") do
+    options.textmode = :report
+  end
+  
+  opts.on("-t", "--text-summary", "Dump plain-text summary to stdout.") do
+    options.textmode = :summary
+  end
+  
+  opts.on("--text-counts", "Dump execution counts in plaintext.") do
+    options.textmode = :counts
+  end
+  
+  opts.on("--text-coverage", "Dump coverage info to stdout, using", "ANSI color sequences unless -n.") do
+    options.textmode = :coverage
+  end
+  
+  opts.on("--gcc", "Dump uncovered line in GCC error format.") do
+    options.gcc_output = true
+  end
+  
+  opts.on("--aggregate FILE", "Aggregate data from previous runs",
+          "in FILE. Overwrites FILE with the",
+          "merged data. FILE is created if",
+          "necessary.") do |file|
+    options.aggregate_file = file
+  end
+  
+  opts.on("-D [FILE]", "--text-coverage-diff [FILE]",
+          "Compare code coverage with saved state",
+          "in FILE, defaults to coverage.info.",
+          "Implies --comments.") do |file|
+    options.textmode = :coverage_diff
+    options.comments_run_by_default = true
+    if options.coverage_diff_save
+      raise "You shouldn't use --save and --text-coverage-diff at a time."
+    end
+    options.coverage_diff_mode = :compare
+    options.coverage_diff_file = file if file && !file.empty?
+  end
+  
+  opts.on("--save [FILE]", "Save coverage data to FILE,", "for later use with rcov -D.", "(default: coverage.info)") do |file|
+    options.coverage_diff_save = true
+    options.coverage_diff_mode = :record
+    if options.textmode == :coverage_diff
+      raise "You shouldn't use --save and --text-coverage-diff at a time."
+    end
+    options.coverage_diff_file = file if file && !file.empty?
+  end
+  
+  opts.on("--[no-]html", "Generate HTML output.", "(default: --html)") do |val|
+    options.html = val
+  end
+  
+  opts.on("--css relative/path/to/custom.css", "Use a custom CSS file for HTML output.", "Specified as a relative path.") do |val|
+    options.css = val
+  end
+  
+  opts.on("--sort CRITERION", [:name, :loc, :coverage], "Sort files in the output by the specified", "field (name, loc, coverage)") do |criterion|
+    options.sort = criterion
+  end
+  
+  opts.on("--sort-reverse", "Reverse files in the output.") do
+    options.sort_reverse = true
+  end
+  
+  opts.on("--threshold INT", "Only list files with coverage < INT %.", "(default: 101)") do |threshold|
+    begin
+      threshold = Integer(threshold)
+      raise if threshold <= 0 || threshold > 101
+    rescue Exception
+      raise OptionParser::InvalidArgument, threshold
+    end
+    options.output_threshold = threshold
+  end
+  
+  opts.on("--failure-threshold [INT]", "Fail if the coverage is below the threshold", "(default: 100)") do |threshold|
+    options.failure_threshold = (threshold || 100).to_i
+    options.textmode = :failure_report
+  end
+
+  opts.on("--charset CHARSET", "Charset used in Content-Type declaration of HTML reports.") do |c|
+    options.charset = c
+  end
+  
+  opts.on("--only-uncovered", "Same as --threshold 100") do
+    options.output_threshold = 100
+  end
+  
+  opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
+    options.replace_prog_name = true
+  end
+  
+  opts.on("-w", "Turn warnings on (like ruby).") do
+    $VERBOSE = true
+  end
+  
+  opts.on("--no-rcovrt", "Do not use the optimized C runtime.", "(will run 30-300 times slower)") do 
+    $rcov_do_not_use_rcovrt = true
+  end
+  
+  opts.on("--diff-cmd PROGNAME", "Use PROGNAME for --text-coverage-diff.",
+          "(default: diff)") do |cmd|
+    options.diff_cmd = cmd
+  end
+  
+  opts.separator ""
+  
+  opts.on_tail("-h", "--help", "Show extended help message") do
+    require 'pp'
+    puts opts
+    puts <<EOF
+
+Files matching any of the following regexps will be omitted in the report(s):
+#{PP.pp(options.skip, "").chomp}
+EOF
+    puts EXTRA_HELP
+    exit
+  end
+  
+  opts.on_tail("--report-cov-bug SELECTOR", "Report coverage analysis bug for the",
+               "method specified by SELECTOR", "(format: Foo::Bar#method, A::B.method)") do |selector|
+    case selector
+    when /([^.]+)(#|\.)(.*)/ then options.report_cov_bug_for = selector
+    else
+      raise OptionParser::InvalidArgument, selector
+    end
+    options.textmode = nil
+    options.html = false
+    options.callsites = true
+  end
+  opts.on_tail("--version", "Show version") do
+    puts "rcov " + Rcov::VERSION + " " + Rcov::RELEASE_DATE
+    exit
+  end
+end
+
+$ORIGINAL_ARGV = ARGV.clone
+if (idx = ARGV.index("--"))
+  extra_args = ARGV[idx+1..-1]
+  ARGV.replace(ARGV[0,idx])
+else
+  extra_args = []
+end
+
+begin
+  opts.parse! ARGV
+rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, OptionParser::MissingArgument => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+end
+
+options.destdir ||= "coverage"
+unless ARGV[0] or options.aggregate_file && File.file?(options.aggregate_file)
+  puts opts
+  exit
+end
+
+# {{{ set loadpath
+options.loadpaths.reverse_each{|x| $:.unshift x}
+
+#{{{ require 'rcov': do it only now in order to be able to run rcov on itself
+# since we need to set $: before.
+
+require 'rcov'
+
+options.callsites = true if options.report_cov_bug_for
+options.textmode = :gcc if !options.textmode and options.gcc_output
+
+def rcov_load_aggregate_data(file)
+  require 'zlib'
+  begin
+    old_data = nil
+    Zlib::GzipReader.open(file){|gz| old_data = Marshal.load(gz) }
+  rescue
+    old_data = {}
+  end
+  old_data || {}
+end
+
+def rcov_save_aggregate_data(file)
+  require 'zlib'
+  Zlib::GzipWriter.open(file) do |f|
+    Marshal.dump({:callsites => $rcov_callsite_analyzer, :coverage => $rcov_code_coverage_analyzer}, f)
+  end
+end
+
+if options.callsites 
+  if options.aggregate_file
+    saved_aggregate_data = rcov_load_aggregate_data(options.aggregate_file)
+    if saved_aggregate_data[:callsites]
+      $rcov_callsite_analyzer = saved_aggregate_data[:callsites]
+    end
+  end
+  $rcov_callsite_analyzer ||= Rcov::CallSiteAnalyzer.new
+  $rcov_callsite_analyzer.install_hook
+else
+  $rcov_callsite_analyzer = nil
+end
+
+# {{{ create formatters
+formatters = []
+make_formatter = lambda do |klass| 
+    klass.new(:destdir => options.destdir, :color => options.color, 
+              :fsr => options.range, :textmode => options.textmode,
+              :ignore => options.skip, :dont_ignore => options.include, 
+              :sort => options.sort,
+              :sort_reverse => options.sort_reverse, 
+              :output_threshold => options.output_threshold,
+              :callsite_analyzer => $rcov_callsite_analyzer,
+              :coverage_diff_mode => options.coverage_diff_mode,
+              :coverage_diff_file => options.coverage_diff_file,
+              :callsites => options.callsites, 
+              :cross_references => options.crossrefs,
+              :diff_cmd => options.diff_cmd,
+              :comments_run_by_default => options.comments_run_by_default,
+              :gcc_output => options.gcc_output,
+              :charset => options.charset,
+              :css => options.css,
+              :failure_threshold => options.failure_threshold
+             )
+end
+
+if options.html
+  if options.profiling
+    formatters << make_formatter[Rcov::HTMLProfiling]
+  else
+    formatters << make_formatter[Rcov::HTMLCoverage]
+  end
+end
+
+textual_formatters = { :counts => Rcov::FullTextReport, :coverage => Rcov::FullTextReport,
+                      :gcc => Rcov::FullTextReport, :annotate => Rcov::RubyAnnotation,
+                      :summary => Rcov::TextSummary, :report => Rcov::TextReport,
+                      :coverage_diff => Rcov::TextCoverageDiff, :failure_report => Rcov::FailureReport }
+
+if textual_formatters[options.textmode]
+  formatters << make_formatter[textual_formatters[options.textmode]]
+end
+
+formatters << make_formatter[Rcov::TextCoverageDiff] if options.coverage_diff_save
+
+if options.aggregate_file
+  saved_aggregate_data ||= rcov_load_aggregate_data(options.aggregate_file)
+  if saved_aggregate_data[:coverage]
+    $rcov_code_coverage_analyzer = saved_aggregate_data[:coverage]
+  end
+end
+
+$rcov_code_coverage_analyzer ||= Rcov::CodeCoverageAnalyzer.new
+
+# must be registered before test/unit puts its own
+
+
+# The exception to rethrow after reporting has been handled.
+$__rcov_exit_exception = nil
+
+END {
+    $rcov_code_coverage_analyzer.remove_hook
+    $rcov_callsite_analyzer.remove_hook if $rcov_callsite_analyzer
+    rcov_save_aggregate_data(options.aggregate_file) if options.aggregate_file
+    $rcov_code_coverage_analyzer.dump_coverage_info(formatters)
+    if options.report_cov_bug_for
+        defsite = $rcov_callsite_analyzer.defsite(options.report_cov_bug_for)
+        if !defsite
+            $stderr.puts <<-EOF
+Couldn't find definition site of #{options.report_cov_bug_for}.
+Was it executed at all?
+EOF
+            exit(-1)
+        end
+        lines, mark_info, count_info = $rcov_code_coverage_analyzer.data(defsite.file)
+        puts <<EOF
+
+Please fill in the blanks in the following report.
+
+
+You can post bugs to
+  http://github.com/relevance/rcov/issues
+
+Thank you!
+        
+=============================================================================
+Bug report generated on #{Time.new}
+
+Ruby version:              #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})
+Platform:                  #{RUBY_PLATFORM}
+rcov version:              #{Rcov::VERSION}
+rcovrt loaded?             #{$".any?{|x| /\brcovrt\b/ =~ x} }
+using RubyGems?            #{$".any?{|x| /\brubygems\b/ =~ x} }
+Command-line arguments:    #{$ORIGINAL_ARGV.inspect}
+Coverage analysis bug in:  #{options.report_cov_bug_for}
+
+Line(s) ____________ should be ______ (red/green).
+        
+Raw coverage information (feel free to remove useless data, but please leave
+some context around the faulty lines):
+
+EOF
+        defsite.line.upto(SCRIPT_LINES__[defsite.file].size) do |i|
+            puts "%7d:%5d:%s" % [count_info[i-1], i, lines[i-1]]
+        end
+        exit
+    end
+  if !formatters.empty? and formatters.all?{|formatter| formatter.sorted_file_pairs.empty? }  
+        require 'pp'
+        $stderr.puts <<-EOF
+
+No file to analyze was found. All the files loaded by rcov matched one of the
+following expressions, and were thus ignored:
+#{PP.pp(options.skip, "").chomp}
+
+You can solve this by doing one or more of the following:
+* rename the files not to be ignored so they don't match the above regexps
+* use --include-file to give a list of patterns for files not to be ignored
+* use --exclude-only to give the new list of regexps to match against
+* structure your code as follows:
+      test/test_*.rb  for the test cases
+      lib/**/*.rb     for the target source code whose coverage you want
+  making sure that the test/test_*.rb files are loading from lib/, e.g. by 
+  using the -Ilib command-line argument, adding  
+    $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+  to test/test_*.rb, or running rcov via a Rakefile (read the RDoc
+  documentation or README.rake in the source distribution).
+EOF
+    end
+
+    raise $__rcov_exit_exception if $__rcov_exit_exception
+}
+
+$rcov_code_coverage_analyzer.install_hook
+
+#{{{ Load scripts
+begin
+  pending_scripts = ARGV.clone
+  ARGV.replace extra_args
+  until pending_scripts.empty?
+    prog = pending_scripts.shift
+    if options.replace_prog_name
+      $0 = File.basename(File.expand_path(prog))
+    end
+    load prog
+  end
+rescue Object => err
+  $__rcov_exit_exception = err
+end
+
+__END__