rcov 0.5.0.1-mswin32 → 0.6.0.1-mswin32

data/BLURB

@@ -2,7 +2,7 @@
 Source code, additional information, screenshots... available at 
     http://eigenclass.org/hiki.rb?rcov
 Release information:
-    http://eigenclass.org/hiki.rb?rcov+0.5.0
+    http://eigenclass.org/hiki.rb?rcov+0.6.0
 
 If you're on win32, you can also find a pre-built rcovrt.so (which makes
 code coverage analysis >100 times faster) in the above-mentioned pages.
@@ -14,6 +14,8 @@ 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
@@ -83,6 +85,38 @@ The (undecorated) textual output with execution count information looks like thi
  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/CHANGES

@@ -1,6 +1,34 @@
 
 User-visible changes.
 
+Since 0.5.0 (2006-05-30)
+========================
+Features
+--------
+* differential coverage report: --text-coverage-diff (-D) and --save
+  Tells you when you've added new code that was not covered by the tests and
+  when code that used to be covered isn't anymore. Integration with vim
+  (contributions for other editors/IDEs welcome).
+* fully cross-referenced reports, indicating where methods are called from
+  and which methods were called for each line (--xrefs)
+* cross-referenced report generation is now over 4 times faster for
+  applications with deep call stacks (such as Rails apps)
+
+Bugfixes
+--------
+* comments at EOF are marked now
+* better handling of multiline hashes/arrays
+* better handling of end/}: support chained method calls and more expressions
+  on the same line
+* better handling of heredocs with interpolation
+
+Minor enhancements
+------------------
+* more readable --text-coverage
+* set whether comments are "run" by default instead of attaching them to
+  the following block of code (--[no-]comments)
+* --report-cov-bug can be used to report bugs in the coverage analysis 
+
 Since 0.4.0 (2006-05-22)
 ========================
 Features

data/README.en

@@ -9,6 +9,8 @@ rcov README
   * 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

data/README.vim

@@ -0,0 +1,47 @@
+
+<tt>rcov.vim</tt> allows you to run unit tests from vim and enter quickfix mode in
+order to jump to uncovered code introduced since the last run.
+
+== Installation
+Copy <tt>rcov.vim</tt> to the appropriate "compiler" directory (typically
+<tt>$HOME/.vim/compiler</tt>).
+
+== Usage
+
+=== Setting the reference point
+
++rcov+'s <tt>--text-coverage-diff</tt> mode compares the current coverage status against
+the saved one. It therefore needs that information to be recorded
+before you write new code (typically right after you perform a commit) in
+order to have something to compare against.
+
+You can save the current status with the <tt>--save</tt> option.
+If you're running +rcov+ from Rake, you can do something like
+  rake rcov_units RCOVOPTS="-T --save --rails"
+in order to take the current status as the reference point.
+
+=== Finding new uncovered code
+
+Type the following in command mode while editing your program:
+   :compiler rcov
+
+rcov.vim assumes +rcov+ can be invoked with a rake task (see 
+README.rake[link:files/README_rake.html] for
+information on how to create it). 
+
+You can then execute +rcov+ and enter quickfix mode by typing
+
+   :make <taskname>
+
+where taskname is the +rcov+ task you want to use; if you didn't override the
+default name in the Rakefile, just
+  
+   :make rcov
+
+will do.
+
+vim will then enter quickfix mode, allowing you to jump to the areas that were
+not covered since the last time you saved the coverage data.
+
+--------
+# vim: ft=text :

data/Rakefile

@@ -18,26 +18,26 @@ ENV["RCOVPATH"] = "bin/rcov"
 # (really!)
 desc "Create a cross-referenced code coverage report."
 Rcov::RcovTask.new do |t|
-  t.libs << "ext/rcovrt"
   t.test_files = FileList['test/test*.rb']
-  t.rcov_opts << "--callsites"  # comment to disable cross-references
+  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.libs << "ext/rcovrt"
   t.test_files = FileList['test/test_FileStatistics.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.libs << "ext/rcovrt"
   t.test_files = FileList['test/test_CodeCoverageAnalyzer.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
 
@@ -73,6 +73,7 @@ Rake::RDocTask.new("rdoc") { |rdoc|
   rdoc.rdoc_files.include('README.API')
   rdoc.rdoc_files.include('README.rake')
   rdoc.rdoc_files.include('README.rant')
+  rdoc.rdoc_files.include('README.vim')
   rdoc.rdoc_files.include('lib/**/*.rb')
 }
 
@@ -114,7 +115,7 @@ EOF
   s.bindir = "bin"                               # Use these for applications.
   s.executables = ["rcov"]
   s.has_rdoc = true
-  s.extra_rdoc_files = %w[README.API README.rake]
+  s.extra_rdoc_files = %w[README.API README.rake README.rant README.vim]
   s.rdoc_options << "--main" << "README.API" << "--title" << 'rcov code coverage tool'
   s.test_files = Dir["test/test_*.rb"]
 end

data/Rantfile

@@ -64,7 +64,8 @@ desc "Generate documentation."
 gen RubyDoc, :rdoc do |g|
     g.verbose = true
     g.dir = "doc"
-    g.files = sys["README.API", "README.rake", "README.rant", "lib/**/*.rb"]
+    g.files = sys["README.API", "README.rake", "README.rant", "README.vim", 
+                  "lib/**/*.rb"]
     g.opts = %w(--line-numbers --inline-source --title rcov --main README.API)
 end
 

data/THANKS

@@ -27,3 +27,17 @@ John-Mason Shackelford:
 
 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

data/bin/rcov

@@ -30,737 +30,7 @@ end
 
 SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 require 'rcov/version'
-
-module Rcov
-
-class Formatter
-    ignore_files = [/\A#{Regexp.escape(Config::CONFIG["libdir"])}/, /\btc_[^.]*.rb/,
-        /_test\.rb\z/, /\btest\//, /\bvendor\//, /\A#{Regexp.escape(__FILE__)}\z/]
-    DEFAULT_OPTS = {:ignore => ignore_files, :sort => :name, :sort_reverse => false,
-                    :output_threshold => 101, :dont_ignore => [], 
-                    :callsite_analyzer => nil}
-    def initialize(opts = {})
-        options = DEFAULT_OPTS.clone.update(opts)
-        @files = {}
-        @ignore_files = options[:ignore]
-        @dont_ignore_files = options[:dont_ignore]
-        @sort_criterium = case options[:sort]
-            when :loc : lambda{|fname, finfo| finfo.num_code_lines}
-            when :coverage : lambda{|fname, finfo| finfo.code_coverage}
-            else lambda{|fname, finfo| fname}
-        end
-        @sort_reverse = options[:sort_reverse]
-        @output_threshold = options[:output_threshold]
-        @callsite_analyzer = options[:callsite_analyzer]
-        @callsite_index = nil
-    end
-
-    def add_file(filename, lines, coverage, counts)
-        old_filename = filename
-        filename = normalize_filename(filename)
-        SCRIPT_LINES__[filename] = SCRIPT_LINES__[old_filename]
-        if @ignore_files.any?{|x| x === filename} && 
-           !@dont_ignore_files.any?{|x| x === filename}
-            return nil
-        end
-        if @files[filename]
-            @files[filename].merge(lines, coverage, counts)
-        else
-            @files[filename] = FileStatistics.new filename, lines, counts
-        end
-    end
-
-    def normalize_filename(filename)
-        File.expand_path(filename).gsub(/^#{Regexp.escape(Dir.getwd)}\//, '')
-    end
-
-    def each_file_pair_sorted(&b)
-        return sorted_file_pairs unless block_given?
-        sorted_file_pairs.each(&b)
-    end
-
-    def sorted_file_pairs
-        pairs = @files.sort_by do |fname, finfo|
-            @sort_criterium.call(fname, finfo)
-        end.select{|_, finfo| 100 * finfo.code_coverage < @output_threshold}
-        @sort_reverse ? pairs.reverse : pairs
-    end
-
-    def total_coverage
-        lines = 0
-        total = 0.0
-        @files.each do |k,f| 
-            total += f.num_lines * f.total_coverage 
-            lines += f.num_lines 
-        end
-        return 0 if lines == 0
-        total / lines
-    end
-
-    def code_coverage
-        lines = 0
-        total = 0.0
-        @files.each do |k,f| 
-            total += f.num_code_lines * f.code_coverage 
-            lines += f.num_code_lines 
-        end
-        return 0 if lines == 0
-        total / lines
-    end
-
-    def num_code_lines
-        lines = 0
-        @files.each{|k, f| lines += f.num_code_lines }
-        lines
-    end
-
-    def num_lines
-        lines = 0
-        @files.each{|k, f| lines += f.num_lines }
-        lines
-    end
-
-    private
-    def cross_references_for(filename, lineno)
-        return nil unless @callsite_analyzer
-        @callsite_index ||= build_callsite_index
-        @callsite_index[normalize_filename(filename)][lineno]
-    end
-
-    def build_callsite_index
-        index = Hash.new{|h,k| h[k] = {}}
-        @callsite_analyzer.analyzed_classes.each do |classname|
-            @callsite_analyzer.analyzed_methods(classname).each do |methname|
-                defsite = @callsite_analyzer.defsite(classname, methname)
-                index[normalize_filename(defsite.file)][defsite.line] = 
-                    @callsite_analyzer.callsites(classname, methname)
-            end
-        end
-        index
-    end
-end
-
-class TextSummary < Formatter
-    def execute
-        puts summary
-    end
-
-    def summary
-        "%.1f%%   %d file(s)   %d Lines   %d LOC" % [code_coverage * 100,
-            @files.size, num_lines, num_code_lines]
-    end
-end
-
-class TextReport < TextSummary
-    def execute
-        print_lines
-        print_header
-        print_lines
-        each_file_pair_sorted do |fname, finfo|
-            name = fname.size < 52 ? fname : "..." + fname[-48..-1]
-            print_info(name, finfo.num_lines, finfo.num_code_lines, 
-                       finfo.code_coverage)
-        end
-        print_lines
-        print_info("Total", num_lines, num_code_lines, code_coverage)
-        print_lines
-        puts summary
-    end
-
-    def print_info(name, lines, loc, coverage)
-        puts "|%-51s | %5d | %5d | %5.1f%% |" % [name, lines, loc, 100 * coverage]
-    end
-
-    def print_lines
-        puts "+----------------------------------------------------+-------+-------+--------+"
-    end
-
-    def print_header
-        puts "|                  File                              | Lines |  LOC  |  COV   |"
-    end
-end
-
-class TextCoverage < Formatter
-    DEFAULT_OPTS = {:textmode => :coverage}
-    def initialize(opts = {})
-        options = DEFAULT_OPTS.clone.update(opts)
-        @textmode = options[:textmode]
-        @color = options[:color]
-        super(options)
-    end
-
-    def execute
-        each_file_pair_sorted do |filename, fileinfo|
-            puts "=" * 80
-            puts filename
-            puts "=" * 80
-            SCRIPT_LINES__[filename].each_with_index do |line, i|
-                case @textmode
-                when :counts
-                    puts "%-70s| %6d" % [line.chomp[0,70], fileinfo.counts[i]]
-                when :coverage
-                    if @color
-                        prefix = fileinfo.coverage[i] ? "\e[32;40m" : "\e[31;40m"
-                        puts "#{prefix}%s\e[37;40m" % line.chomp
-                    else
-                        prefix = fileinfo.coverage[i] ? "   " : "## "
-                        puts "#{prefix}#{line}"
-                    end
-                end
-            end
-        end
-    end
-end
-
-
-class HTMLCoverage < Formatter
-    include XX::XHTML
-    include XX::XMLish
-    require 'fileutils'
-    JAVASCRIPT_PROLOG = <<-EOS
-
-// <![CDATA[
-  function toggleCode( id ) {
-    if ( document.getElementById )
-      elem = document.getElementById( id );
-    else if ( document.all )
-      elem = eval( "document.all." + id );
-    else
-      return false;
-
-    elemStyle = elem.style;
-    
-    if ( elemStyle.display != "block" ) {
-      elemStyle.display = "block"
-    } else {
-      elemStyle.display = "none"
-    }
-
-    return true;
-  }
-  
-  // Make cross-references hidden by default
-  document.writeln( "<style type=\\"text/css\\">span.cross-ref { display: none }</style>" )
-  
-  // ]]>
-    EOS
-
-    CSS_PROLOG = <<-EOS
-span.marked0 {
-  background-color: rgb(185, 210, 200);
-  display: block;
-}
-span.marked1 {
-  background-color: rgb(190, 215, 205);
-  display: block;
-}
-span.inferred0 {
-  background-color: rgb(175, 200, 200);
-  display: block;
-}
-span.inferred1 {
-  background-color: rgb(180, 205, 205);
-  display: block;
-}
-span.uncovered0 {
-  background-color: rgb(225, 110, 110);
-  display: block;
-}
-span.uncovered1 {
-  background-color: rgb(235, 120, 120);
-  display: block;
-}
-span.overview {
-  border-bottom: 8px solid black;
-}
-div.overview {
-  border-bottom: 8px solid black;
-}
-body {
-    font-family: verdana, arial, helvetica;
-}
-
-div.footer {
-    font-size: 68%;
-    margin-top: 1.5em;
-}
-
-h1, h2, h3, h4, h5, h6 {
-    margin-bottom: 0.5em;
-}
-
-h5 {
-    margin-top: 0.5em;
-}
-
-.hidden {
-    display: none;
-}
-
-div.separator {
-    height: 10px;
-}
-/* Commented out for better readability, esp. on IE */
-/*
-table tr td, table tr th {
-    font-size: 68%;
-}
-
-td.value table tr td {
-    font-size: 11px;
-}
-*/
-
-table.percent_graph {
-    height: 12px;
-    border: #808080 1px solid;
-    empty-cells: show;
-}
-
-table.percent_graph td.covered {
-    height: 10px;
-    background: #00f000;
-}
-
-table.percent_graph td.uncovered {
-    height: 10px;
-    background: #e00000;
-}
-
-table.percent_graph td.NA {
-    height: 10px;
-    background: #eaeaea;
-}
-
-table.report {
-    border-collapse: collapse;
-    width: 100%;
-}
-
-table.report td.heading {
-    background: #dcecff;
-    border: #d0d0d0 1px solid;
-    font-weight: bold;
-    text-align: center;
-}
-
-table.report td.heading:hover {
-    background: #c0ffc0;
-}
-
-table.report td.text {
-    border: #d0d0d0 1px solid;
-}
-
-table.report td.value {
-    text-align: right;
-    border: #d0d0d0 1px solid;
-}
-table.report tr.light {
-    background-color: rgb(240, 240, 245);
-}
-table.report tr.dark {
-    background-color: rgb(230, 230, 235);
-}
-EOS
-
-    DEFAULT_OPTS = {:color => false, :fsr => 30, :destdir => "coverage"}
-    def initialize(opts = {})
-        options = DEFAULT_OPTS.clone.update(opts)
-        super(options)
-        @dest = options[:destdir]
-        @color = options[:color]
-        @fsr = options[:fsr]
-        @span_class_index = 0
-    end
-
-    def execute
-        return if @files.empty?
-        FileUtils.mkdir_p @dest
-        create_index(File.join(@dest, "index.html"))
-        each_file_pair_sorted do |filename, fileinfo|
-            create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
-        end
-    end
-
-    def mangle_filename(base)
-        base.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
-    end
-
-    private
-
-    def blurb
-        xmlish_ {
-                p_ { 
-                    t_{ "Generated using the " }
-                    a_(:href => "http://eigenclass.org/hiki.rb?rcov") {
-                        t_{ "rcov code coverage analysis tool for Ruby" }
-                    }
-                    t_{ " version #{Rcov::VERSION}." }
-                }
-        }.pretty
-    end
-
-    def output_color_table?
-        true
-    end
-
-    def default_color
-        "rgb(240, 240, 245)"
-    end
-
-    def default_title
-        "C0 code coverage information"
-    end
-
-    def format_overview(*file_infos)
-        table_text = xmlish_ {
-            table_(:class => "report") {
-                thead_ {
-                    tr_ { 
-                        ["Name", "Total lines", "Lines of code", "Total coverage",
-                         "Code coverage"].each do |heading|
-                            td_(:class => "heading") { heading }
-                         end
-                    }
-                }
-                tbody_ { 
-                    color_class_index = 1
-                    color_classes = %w[light dark]
-                    file_infos.each do |f|
-                        color_class_index += 1
-                        color_class_index %= color_classes.size
-                        tr_(:class => color_classes[color_class_index]) {
-                            td_ { 
-                                case f.name
-                                when "TOTAL": 
-                                    t_ { "TOTAL" }
-                                else
-                                    a_(:href => mangle_filename(f.name)){ t_ { f.name } } 
-                                end
-                            }
-                            [f.num_lines, f.num_code_lines].each do |value| 
-                                td_(:class => "value") { tt_{ value } }
-                            end
-                            [f.total_coverage, f.code_coverage].each do |value|
-                                value *= 100
-                                td_ { 
-                                    table_(:cellpadding => 0, :cellspacing => 0, :align => "right") { 
-                                        tr_ { 
-                                            td_ {
-                                                 tt_ { "%3.1f%%" % value } 
-                                                 x_ "&nbsp;"
-                                            }
-                                            ivalue = value.round
-                                            td_ {
-                                                table_(:class => "percent_graph", :cellpadding => 0,
-                                                   :cellspacing => 0, :width => 100) {
-                                                    tr_ {
-                                                        td_(:class => "covered", :width => ivalue)
-                                                        td_(:class => "uncovered", :width => (100-ivalue))
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            end
-                        }
-                    end
-                }
-            }
-        }
-        table_text.pretty
-    end
-
-    class SummaryFileInfo 
-        def initialize(obj); @o = obj end
-        %w[num_lines num_code_lines code_coverage total_coverage].each do |m|
-            define_method(m){ @o.send(m) }
-        end
-        def name; "TOTAL" end
-    end
-
-    def create_index(destname)
-        files = [SummaryFileInfo.new(self)] + each_file_pair_sorted.map{|k,v| v}
-        title = default_title
-        output = xhtml_ { html_ {
-            head_ {
-                title_{ title }
-                style_(:type => "text/css") { t_{ "body { background-color: #{default_color}; }" }  }
-                style_(:type => "text/css") { CSS_PROLOG }
-                script_(:type => "text/javascript") { h_{ JAVASCRIPT_PROLOG } }
-            }
-            body_ {
-                h3_{
-                    t_{ title }
-                }
-                p_ {
-                    t_{ "Generated on #{Time.new.to_s} with " }
-                    a_(:href => Rcov::UPSTREAM_URL){ "rcov #{Rcov::VERSION}" }
-                }
-                p_ { "Threshold: #{@output_threshold}%" } if @output_threshold != 101
-                hr_
-                x_{ format_overview(*files) }
-                hr_
-                x_{ blurb }
-                p_ {
-                    a_(:href => "http://validator.w3.org/check/referer") {
-                    img_(:src => "http://www.w3.org/Icons/valid-xhtml11",
-                         :alt => "Valid XHTML 1.1!", :height => 31, :width => 88)
-                    }
-                    a_(:href => "http://jigsaw.w3.org/css-validator/check/referer") {
-                        img_(:style => "border:0;width:88px;height:31px",
-                             :src => "http://jigsaw.w3.org/css-validator/images/vcss",
-                             :alt => "Valid CSS!")
-                    }
-                }
-            }
-        } }
-        lines = output.pretty.to_a
-        lines.unshift lines.pop if /DOCTYPE/ =~ lines[-1]
-        File.open(destname, "w") do |f|
-            f.puts lines
-        end
-    end
-
-    def format_lines(file)
-        result = ""
-        last = nil
-        end_of_span = ""
-        format_line = "%#{file.num_lines.to_s.size}d"
-        file.num_lines.times do |i|
-            line = file.lines[i]
-            marked = file.coverage[i]
-            count = file.counts[i]
-            spanclass = span_class(file, marked, count)
-            if spanclass != last
-                result += end_of_span
-                case spanclass
-                when nil
-                    end_of_span = ""
-                else
-                    result += %[<span class="#{spanclass}">]
-                    end_of_span = "</span>"
-                end
-            end
-            result += %[<a name="line#{i+1}" />] + (format_line % (i+1)) + 
-                " " + create_cross_refs(file.name, i+1, CGI.escapeHTML(line)) + "\n"
-            last = spanclass
-        end
-        result += end_of_span
-        "<pre>#{result}</pre>"
-    end
-
-    def create_cross_refs(filename, lineno, linetext)
-        return linetext unless @callsite_analyzer
-        @cross_ref_idx ||= 0
-        ret = ""
-        refs = cross_references_for(filename, lineno)
-        return linetext unless refs
-        refs = refs.sort_by{|k,count| count}
-        ret << %[<a class="crossref-toggle" href="#" onclick="toggleCode('XREF-#{@cross_ref_idx+=1}'); return false;">#{linetext}</a>]
-        ret << %[<span class="cross-ref" id="XREF-#{@cross_ref_idx}">]
-        ret << %[\nThis method was called by:\n\n]
-        known_files = sorted_file_pairs.map{|fname, finfo| normalize_filename(fname)}
-        refs.reverse_each do |dst, count|
-            dstfile = normalize_filename(dst.file)
-            dstline = dst.line
-            calling_method = dst.calling_method
-            label = "%7d   %s" % 
-                [count, CGI.escapeHTML("#{dstfile}:#{dstline} in '#{calling_method}'")]
-            if known_files.include? dstfile
-                ret << %[<a href="#{mangle_filename(dstfile)}#line#{dstline}">#{label}</a>]
-            else
-                ret << label
-            end
-            ret << "\n"
-        end
-        ret << "</span>"
-    end
-
-    def span_class(sourceinfo, marked, count)
-        @span_class_index ^= 1
-        case marked
-        when true
-            "marked#{@span_class_index}"
-        when :inferred
-            "inferred#{@span_class_index}"
-        else 
-            "uncovered#{@span_class_index}"
-        end
-    end
-
-    def create_file(destfile, fileinfo)
-        #$stderr.puts "Generating #{destfile.inspect}"
-        body = format_overview(fileinfo) + format_lines(fileinfo)
-        title = fileinfo.name + " - #{default_title}"
-        do_ctable = output_color_table?
-        output = xhtml_ { html_ {
-            head_ { 
-                title_{ title } 
-                style_(:type => "text/css") { t_{ "body { background-color: #{default_color}; }" }  }
-                style_(:type => "text/css") { CSS_PROLOG }
-                script_(:type => "text/javascript") { h_ { JAVASCRIPT_PROLOG } }
-                style_(:type => "text/css") { h_ { colorscale } }
-            }
-            body_ {
-                h3_{ t_{ default_title } }
-                p_ {
-                    t_{ "Generated on #{Time.new.to_s} with " }
-                    a_(:href => Rcov::UPSTREAM_URL){ "rcov #{Rcov::VERSION}" }
-                }
-                hr_
-                if do_ctable
-                    # this kludge needed to ensure .pretty doesn't mangle it
-                    x_ { <<EOS
-<pre><span class='marked0'>Code reported as executed by Ruby looks like this...
-</span><span class='marked1'>and this: this line is also marked as covered.
-</span><span class='inferred0'>Lines considered as run by rcov, but not reported by Ruby, look like this,
-</span><span class='inferred1'>and this: these lines were inferred by rcov (using simple heuristics).
-</span><span class='uncovered0'>Finally, here&apos;s a line marked as not executed.
-</span></pre>                       
-EOS
-                    }
-                end
-                x_{ body }
-                hr_
-                x_ { blurb }
-                p_ {
-                    a_(:href => "http://validator.w3.org/check/referer") {
-                    img_(:src => "http://www.w3.org/Icons/valid-xhtml10",
-                         :alt => "Valid XHTML 1.0!", :height => 31, :width => 88)
-                    }
-                    a_(:href => "http://jigsaw.w3.org/css-validator/check/referer") {
-                        img_(:style => "border:0;width:88px;height:31px",
-                             :src => "http://jigsaw.w3.org/css-validator/images/vcss",
-                             :alt => "Valid CSS!")
-                    }
-                }
-            }
-        } }
-        # .pretty needed to make sure DOCTYPE is in a separate line
-        lines = output.pretty.to_a
-        lines.unshift lines.pop if /DOCTYPE/ =~ lines[-1]
-        File.open(destfile, "w") do |f|
-            f.puts lines
-        end
-    end
-
-    def colorscale
-        colorscalebase =<<EOF
-span.run%d {
-  background-color: rgb(%d, %d, %d);
-  display: block;
-}
-EOF
-        cscale = ""
-        101.times do |i|
-            if @color
-                r, g, b = hsv2rgb(220-(2.2*i).to_i, 0.3, 1)
-                r = (r * 255).to_i
-                g = (g * 255).to_i
-                b = (b * 255).to_i
-            else
-                r = g = b = 255 - i 
-            end
-            cscale << colorscalebase % [i, r, g, b]
-        end
-        cscale
-    end
-
-    # thanks to kig @ #ruby-lang for this one
-    def hsv2rgb(h,s,v)
-        return [v,v,v] if s == 0
-        h = h/60.0
-        i = h.floor
-        f = h-i
-        p = v * (1-s)
-        q = v * (1-s*f)
-        t = v * (1-s*(1-f))
-        case i
-        when 0
-            r = v
-            g = t
-            b = p
-        when 1
-            r = q
-            g = v
-            b = p
-        when 2
-            r = p
-            g = v
-            b = t
-        when 3
-            r = p
-            g = q
-            b = v
-        when 4
-            r = t
-            g = p
-            b = v
-        when 5
-            r = v
-            g = p
-            b = q
-        end
-        [r,g,b]
-    end
-end
-
-class HTMLProfiling < HTMLCoverage
-
-    DEFAULT_OPTS = {:destdir => "profiling"}
-    def initialize(opts = {})
-        options = DEFAULT_OPTS.clone.update(opts)
-        super(options)
-        @max_cache = {}
-        @median_cache = {}
-    end
-    
-    def default_title
-        "Bogo-profile information"
-    end
-    
-    def default_color
-        if @color
-            "rgb(179,205,255)"
-        else
-            "rgb(255, 255, 255)"
-        end
-    end
-
-    def output_color_table?
-        false
-    end
-
-    def span_class(sourceinfo, marked, count)
-        full_scale_range = @fsr # dB
-        nz_count = sourceinfo.counts.select{|x| x && x != 0}
-        nz_count << 1 # avoid div by 0
-        max = @max_cache[sourceinfo] ||= nz_count.max
-        #avg = @median_cache[sourceinfo] ||= 1.0 * 
-        #    nz_count.inject{|a,b| a+b} / nz_count.size
-        median = @median_cache[sourceinfo] ||= 1.0 * nz_count.sort[nz_count.size/2]
-        max ||= 2
-        max = 2 if max == 1
-        if marked == true
-            count = 1 if !count || count == 0
-            idx = 50 + 1.0 * (500/full_scale_range) * Math.log(count/median) /
-                Math.log(10)
-            idx = idx.to_i
-            idx = 0 if idx < 0
-            idx = 100 if idx > 100
-            "run#{idx}"
-        else 
-            nil
-        end
-    end
-end
-
-end # Rcov
-
-#{{{ only run if executed directly
+require 'rcov/report'
 
 #{{{ "main" code
 options = OpenStruct.new
@@ -772,13 +42,20 @@ options.loadpaths = []
 options.textmode = false
 options.skip = Rcov::Formatter::DEFAULT_OPTS[:ignore]
 options.include = []
-options.nohtml = false
+options.html = true
+options.comments_run_by_default = false
 options.test_unit_only = false
 options.sort = :name
 options.sort_reverse = false
 options.output_threshold = 101
 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
 
 EXTRA_HELP = <<-EOF
 
@@ -813,6 +90,11 @@ EOF
             "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 in TestCases.") do
         options.test_unit_only = true
@@ -853,9 +135,14 @@ EOF
         options.skip.concat [%r{\bvendor/},%r{\bconfig/},%r{\benvironment/}]
     end
     opts.on("--[no-]callsites", "Show callsites in generated XHTML report.",
-            "(much slower; disabled by default)") do |val|
+            "(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"
@@ -878,9 +165,30 @@ EOF
             "ANSI color sequences unless -n.") do
         options.textmode = :coverage
     end
-    opts.on("--no-html", "Don't generate HTML output.",
-            "(no output unless text output specified)") do
-        options.nohtml = true
+    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.",
+            "(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("--sort CRITERION", [:name, :loc, :coverage],
             "Sort files in the output by the specified",
@@ -913,8 +221,12 @@ EOF
             "(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 help message") do
+    opts.on_tail("-h", "--help", "Show extended help message") do
         require 'pp'
         puts opts
         puts <<EOF
@@ -925,12 +237,26 @@ 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 /([^.]+)(#|\.)(.*)/: 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])
@@ -961,6 +287,8 @@ options.loadpaths.reverse_each{|x| $:.unshift x}
 
 require 'rcov'
 
+options.callsites = true if options.report_cov_bug_for
+
 if options.callsites 
     $rcov_callsite_analyzer = Rcov::CallSiteAnalyzer.new
     $rcov_callsite_analyzer.install_hook
@@ -974,26 +302,37 @@ 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 => options.sort,
               :sort_reverse => options.sort_reverse, 
               :output_threshold => options.output_threshold,
-              :callsite_analyzer => $rcov_callsite_analyzer)
+              :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
+             )
 end
 
-unless options.nohtml
+if options.html
     if options.profiling
         formatters << make_formatter[Rcov::HTMLProfiling]
     else
         formatters << make_formatter[Rcov::HTMLCoverage]
     end
 end
-textual_formatters = {:counts => Rcov::TextCoverage, :coverage => Rcov::TextCoverage,
-                      :summary => Rcov::TextSummary, :report => Rcov::TextReport}
+textual_formatters = {:counts => Rcov::FullTextReport, 
+                      :coverage => Rcov::FullTextReport,
+                      :summary => Rcov::TextSummary, :report => Rcov::TextReport,
+                      :coverage_diff => Rcov::TextCoverageDiff}
 
 if textual_formatters[options.textmode]
     formatters << make_formatter[textual_formatters[options.textmode]]
 end
 
+formatters << make_formatter[Rcov::TextCoverageDiff] if options.coverage_diff_save
+
 $rcov_code_coverage_analyzer = Rcov::CodeCoverageAnalyzer.new
 
 # must be registered before test/unit puts its own
@@ -1001,6 +340,49 @@ END {
     $rcov_code_coverage_analyzer.remove_hook
     $rcov_callsite_analyzer.remove_hook if $rcov_callsite_analyzer
     $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 report the bug via the Ruby-Talk ML, send it directly to 
+<mfp at acm dot org> (include "rcov" in the subject to get past the spam filters),
+or post it to 
+  http://eigenclass.org/hiki.rb?rcov+#{VERSION}
+
+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.all?{|formatter| formatter.sorted_file_pairs.empty? }
         require 'pp'
         $stderr.puts <<-EOF
@@ -1022,7 +404,6 @@ You can solve this by doing one or more of the following:
   to test/test_*.rb, or running rcov via a Rakefile (read the RDoc
   documentation or README.rake in the source distribution).
 EOF
-        exit(-1)
     end
 }