relevance-rcov 0.8.2.1 → 0.8.3.0

data/Rakefile

@@ -44,19 +44,11 @@ Rcov::RcovTask.new(:rcov_ccanalyzer) do |t|
 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.test_files = FileList['test/*_test.rb']
-    t.verbose = true
-  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
+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
 
 file "ext/rcovrt/rcovrt.so" => FileList["ext/rcovrt/*.c"] do

data/bin/rcov

@@ -17,7 +17,6 @@ require 'ostruct'
 SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 require 'rcov/version'
 require 'rcov/formatters'
-require 'rcov/report'
 
 #{{{ "main" code
 options = OpenStruct.new
@@ -419,10 +418,9 @@ 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}
+
+You can post bugs to
+  http://github.com/relevance/rcov/issues
 
 Thank you!
         

data/ext/rcovrt/extconf.rb

@@ -1,23 +1,21 @@
-unless RUBY_PLATFORM == 'java' then
-  require 'mkmf'
-  
-  dir_config("gcov")
-  if ENV["USE_GCOV"] and Config::CONFIG['CC'] =~ /gcc/ and 
-    have_library("gcov", "__gcov_open")
-  
-    $CFLAGS << " -fprofile-arcs -ftest-coverage"
-    if RUBY_VERSION =~ /1.9/
-      $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
-      create_makefile("rcovrt", "1.9/")
-    else
-      create_makefile("rcovrt", "1.8/")
-    end
+require 'mkmf'
+
+dir_config("gcov")
+if ENV["USE_GCOV"] and Config::CONFIG['CC'] =~ /gcc/ and 
+  have_library("gcov", "__gcov_open")
+
+  $CFLAGS << " -fprofile-arcs -ftest-coverage"
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+    create_makefile("rcovrt", "1.9/")
   else
-    if RUBY_VERSION =~ /1.9/
-      $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
-      create_makefile("rcovrt", "1.9/")
-    else
-      create_makefile("rcovrt", "1.8/")
-    end
+    create_makefile("rcovrt", "1.8/")
   end
-end
+else
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+    create_makefile("rcovrt", "1.9/")
+  else
+    create_makefile("rcovrt", "1.8/")
+  end
+end

data/lib/rcov/formatters/base_formatter.rb

@@ -0,0 +1,292 @@
+require "erb"
+
+class Document
+
+  attr_accessor :local_variables 
+
+  def initialize(template_file, locals={})
+    template_path = File.expand_path("#{File.dirname(__FILE__)}/../templates/#{template_file}")
+    @template = ERB.new(File.read(template_path))
+    @local_variables = locals
+    @path_relativizer = Hash.new{|h,base|
+      # TODO: Waaaahhhhh?
+      h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
+    }
+  end
+  
+  def render
+    @template.result(get_binding)
+  end
+
+  def relative_filename(path)
+    @path_relativizer[path]
+  end
+
+  #def create_cross_refs(filename, lineno, linetext)
+    #form = formatter
+    #return linetext unless @callsite_analyzer && @do_callsites
+
+    #ref_blocks = []
+    #form.send(:_get_defsites, ref_blocks, filename, lineno, "Calls", linetext) do |ref|
+      #if ref.file
+          #where = "at #{formatter.normalize_filename(ref.file)}:#{ref.line}"
+      #else
+          #where = "(C extension/core)"
+      #end
+      #CGI.escapeHTML("%7d   %s" % [ref.count, "#{ref.klass}##{ref.mid} " + where])
+    #end
+
+    #form.send(:_get_callsites, ref_blocks, filename, lineno, "Called by", linetext) do |ref|
+      #r = "%7d   %s" % [ref.count, "#{formatter.normalize_filename(ref.file||'C code')}:#{ref.line} " + "in '#{ref.klass}##{ref.mid}'"]
+      #CGI.escapeHTML(r)
+    #end
+
+    #create_cross_reference_block(linetext, ref_blocks)
+  #end
+
+  #def create_cross_reference_block(linetext, ref_blocks)
+      #return linetext if ref_blocks.empty?
+      #ret = ""
+      #@cross_ref_idx ||= 0
+      #@known_files ||= formatter.sorted_file_pairs.map{|fname, finfo| formatter.normalize_filename(fname)}
+      #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 << "\n"
+      #ref_blocks.each do |refs, toplabel, label_proc|
+          #unless !toplabel || toplabel.empty?
+              #ret << %!<span class="cross-ref-title">#{toplabel}</span>\n!
+          #end
+          #refs.each do |dst|
+              #dstfile = formatter.normalize_filename(dst.file) if dst.file
+              #dstline = dst.line
+              #label = label_proc.call(dst)
+              #if dst.file && @known_files.include?(dstfile)
+                  #ret << %[<a href="#{formatter.mangle_filename(dstfile)}#line#{dstline}">#{label}</a>]
+              #else
+                  #ret << label
+              #end
+              #ret << "\n"
+          #end
+      #end
+      #ret << "</span>"
+  #end
+
+  def line_css(line_number)
+    case file.coverage[line_number]
+    when true
+      "marked"
+    when :inferred
+      "inferred"
+    else
+      "uncovered"
+    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].chomp
+          #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}"></a>] + (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 method_missing(key, *args)
+    local_variables.has_key?(key) ? local_variables[key] : super
+  end
+
+  def get_binding
+    binding 
+  end
+
+end
+
+module Rcov
+  
+  class BaseFormatter # :nodoc:
+    require 'pathname'
+    require 'mkmf'
+    ignore_files = [/\A#{Regexp.escape(Pathname.new(::Config::CONFIG['libdir']).cleanpath.to_s)}/, /\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, :comments_run_by_default => false}
+
+    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 then lambda{|fname, finfo| finfo.num_code_lines}
+      when :coverage then 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]
+      @comments_run_by_default = options[:comments_run_by_default]
+      @callsite_index = nil
+
+      @mangle_filename = Hash.new{|h,base|
+        h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
+      }
+    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,
+        @comments_run_by_default)
+      end
+    end
+
+    def normalize_filename(filename)
+      File.expand_path(filename).gsub(/^#{Regexp.escape(Dir.getwd)}\//, '')
+    end
+
+    def mangle_filename(base)
+      @mangle_filename[base]
+    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 reverse_cross_references_for(filename, lineno)
+      return nil unless @callsite_analyzer
+      @callsite_reverse_index ||= build_reverse_callsite_index
+      @callsite_reverse_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
+
+    def build_reverse_callsite_index
+      index = Hash.new{|h,k| h[k] = {}}
+      @callsite_analyzer.analyzed_classes.each do |classname|
+        @callsite_analyzer.analyzed_methods(classname).each do |methname|
+          callsites = @callsite_analyzer.callsites(classname, methname)
+          defsite = @callsite_analyzer.defsite(classname, methname)
+          callsites.each_pair do |callsite, count|
+            next unless callsite.file
+            fname = normalize_filename(callsite.file)
+            (index[fname][callsite.line] ||= []) << [classname, methname, defsite, count]
+          end
+        end
+      end
+      index
+    end
+
+    class XRefHelper < Struct.new(:file, :line, :klass, :mid, :count) # :nodoc:
+    end
+
+    def _get_defsites(ref_blocks, filename, lineno, linetext, label, &format_call_ref)
+      if @do_cross_references and
+        (rev_xref = reverse_cross_references_for(filename, lineno))
+        refs = rev_xref.map do |classname, methodname, defsite, count|
+          XRefHelper.new(defsite.file, defsite.line, classname, methodname, count)
+        end.sort_by{|r| r.count}.reverse
+        ref_blocks << [refs, label, format_call_ref]
+      end
+    end
+
+    def _get_callsites(ref_blocks, filename, lineno, linetext, label, &format_called_ref)
+      if @do_callsites and
+        (refs = cross_references_for(filename, lineno))
+        refs = refs.sort_by{|k,count| count}.map do |ref, count|
+          XRefHelper.new(ref.file, ref.line, ref.calling_class, ref.calling_method, count)
+        end.reverse
+        ref_blocks << [refs, label, format_called_ref]
+      end
+    end
+
+  end
+
+end

data/lib/rcov/formatters/full_text_report.rb

@@ -0,0 +1,55 @@
+module Rcov
+
+  class FullTextReport < BaseFormatter # :nodoc:
+    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
+        lines = SCRIPT_LINES__[filename]
+      
+        unless lines
+          # try to get the source code from the global code coverage
+          # analyzer
+          re = /#{Regexp.escape(filename)}\z/
+          if $rcov_code_coverage_analyzer and
+            (data = $rcov_code_coverage_analyzer.data_matching(re))
+            lines = data[0]
+          end
+        end
+      
+        (lines || []).each_with_index do |line, i|
+        
+          case @textmode
+          when :counts
+            puts "%-70s| %6d" % [line.chomp[0,70], fileinfo.counts[i]]
+          when :gcc
+            puts "%s:%d:%s" % [filename, i+1, line.chomp] unless fileinfo.coverage[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
+  
+end

data/lib/rcov/formatters/html_coverage.rb

@@ -0,0 +1,258 @@
+module Rcov
+
+  class HTMLCoverage < BaseFormatter # :nodoc:
+      require 'fileutils'
+
+      DEFAULT_OPTS = {:color => false, :fsr => 30, :destdir => "coverage",
+                      :callsites => false, :cross_references => false,
+                      :validator_links => true, :charset => nil
+                     }
+                     
+      def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        super(options)
+        @dest = options[:destdir]
+        @color = options[:color]
+        @fsr = options[:fsr]
+        @do_callsites = options[:callsites]
+        @do_cross_references = options[:cross_references]
+        @span_class_index = 0
+        @show_validator_links = options[:validator_links]
+        @charset = options[:charset]
+      end
+
+      def execute
+        return if @files.empty?
+        FileUtils.mkdir_p @dest
+        css_file = File.expand_path("#{File.dirname(__FILE__)}/../templates/screen.css")
+        FileUtils.cp(css_file, File.join(@dest, "screen.css"))
+
+        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
+
+      private
+
+      class SummaryFileInfo  # :nodoc:
+        
+        def initialize(obj)
+          @o = obj 
+        end
+      
+        def num_lines
+          @o.num_lines
+        end
+      
+        def num_code_lines
+          @o.num_code_lines
+        end
+      
+        def code_coverage
+          @o.code_coverage
+        end
+
+        def code_coverage_for_report
+          code_coverage * 100
+        end
+
+        def total_coverage
+          @o.total_coverage
+        end
+
+        def total_coverage_for_report
+          total_coverage * 100
+        end
+      
+        def name
+          "TOTAL" 
+        end
+
+      end
+
+      def create_index(destname)
+          files = [SummaryFileInfo.new(self)] + each_file_pair_sorted.map{|k,v| v}
+
+          doc = Document.new('index.html.erb', :title => 'C0 Coverage Information - RCov', 
+                                               :generated_on => Time.now,
+                                               :rcov => Rcov,
+                                               :formatter => self,
+                                               :output_threshold => @output_threshold,
+                                               :files => files)
+
+          File.open(destname, "w")  { |f| f.puts doc.render }
+      end
+
+     
+      def create_file(destfile, fileinfo)
+          doc = Document.new('detail.html.erb', :title => fileinfo.name, 
+                                                :generated_on => Time.now,
+                                                :rcov => Rcov,
+                                                :formatter => self,
+                                                :output_threshold => @output_threshold,
+                                                :file => fileinfo)
+          File.open(destfile, "w")  { |f| f.puts doc.render }
+      end
+
+  end
+
+  class HTMLProfiling < HTMLCoverage # :nodoc:
+
+      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
+
+  class RubyAnnotation < BaseFormatter # :nodoc:
+      DEFAULT_OPTS = { :destdir => "coverage" }
+      def initialize(opts = {})
+          options = DEFAULT_OPTS.clone.update(opts)
+          super(options)
+          @dest = options[:destdir]
+          @do_callsites = true
+          @do_cross_references = true
+
+          @mangle_filename = Hash.new{|h,base|
+              h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".rb"
+          }
+      end
+
+      def execute
+          return if @files.empty?
+          FileUtils.mkdir_p @dest
+          each_file_pair_sorted do |filename, fileinfo|
+              create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
+          end
+      end
+
+      private
+
+      def format_lines(file)
+          result = ""
+          format_line = "%#{file.num_lines.to_s.size}d"
+          file.num_lines.times do |i|
+              line = file.lines[i].chomp
+              marked = file.coverage[i]
+              count = file.counts[i]
+              result << create_cross_refs(file.name, i+1, line, marked) + "\n"
+          end
+          result
+      end
+
+  def create_cross_refs(filename, lineno, linetext, marked)
+      return linetext unless @callsite_analyzer && @do_callsites
+      ref_blocks = []
+      _get_defsites(ref_blocks, filename, lineno, linetext, ">>") do |ref|
+          if ref.file
+              ref.file.sub!(%r!^./!, '')
+              where = "at #{mangle_filename(ref.file)}:#{ref.line}"
+          else
+              where = "(C extension/core)"
+          end
+          "#{ref.klass}##{ref.mid} " + where + ""
+      end
+      _get_callsites(ref_blocks, filename, lineno, linetext, "<<") do |ref| # "
+          ref.file.sub!(%r!^./!, '')
+          "#{mangle_filename(ref.file||'C code')}:#{ref.line} " +
+              "in #{ref.klass}##{ref.mid}"
+      end
+
+      create_cross_reference_block(linetext, ref_blocks, marked)
+  end
+
+  def create_cross_reference_block(linetext, ref_blocks, marked)
+    codelen = 75
+    if ref_blocks.empty?
+        if marked
+            return "%-#{codelen}s #o" % linetext
+        else
+            return linetext
+        end
+    end
+    ret = ""
+    @cross_ref_idx ||= 0
+    @known_files ||= sorted_file_pairs.map{|fname, finfo| normalize_filename(fname)}
+    ret << "%-#{codelen}s # " % linetext
+    ref_blocks.each do |refs, toplabel, label_proc|
+        unless !toplabel || toplabel.empty?
+            ret << toplabel << " "
+        end
+        refs.each do |dst|
+            dstfile = normalize_filename(dst.file) if dst.file
+            dstline = dst.line
+            label = label_proc.call(dst)
+            if dst.file && @known_files.include?(dstfile)
+                ret << "[[" << label << "]], "
+            else
+                ret << label << ", "
+            end
+        end
+    end
+
+    ret
+  end
+
+      def create_file(destfile, fileinfo)
+        #body = format_lines(fileinfo)
+        #File.open(destfile, "w") do |f|
+          #f.puts body
+          #f.puts footer(fileinfo)
+        #end
+      end
+
+      def footer(fileinfo)
+        s  = "# Total lines    : %d\n" % fileinfo.num_lines
+        s << "# Lines of code  : %d\n" % fileinfo.num_code_lines
+        s << "# Total coverage : %3.1f%%\n" % [ fileinfo.total_coverage*100 ]
+        s << "# Code coverage  : %3.1f%%\n\n" % [ fileinfo.code_coverage*100 ]
+        # prevents false positives on Emacs
+        s << "# Local " "Variables:\n" "# mode: " "rcov-xref\n" "# End:\n"
+      end
+    end
+
+end