rcov 0.9.3-java

data/lib/rcov/formatters/html_erb_template.rb

@@ -0,0 +1,62 @@
+module Rcov
+  module Formatters
+    class HtmlErbTemplate
+      attr_accessor :local_variables
+
+      def initialize(template_file, locals={})
+        require "erb"
+
+        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|
+          h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
+        }
+      end
+
+      def render
+        @template.result(get_binding)
+      end
+
+      def coverage_threshold_classes(percentage)
+        return 110 if percentage == 100
+        return (1..10).find_all{|i| i * 10 > percentage}.map{|i| i.to_i * 10} * " " 
+      end
+      
+      def code_coverage_html(code_coverage_percentage, is_total=false)
+        %{<div class="percent_graph_legend"><tt class='#{ is_total ? 'coverage_total' : ''}'>#{ "%3.2f" % code_coverage_percentage }%</tt></div>
+          <div class="percent_graph">
+            <div class="covered" style="width:#{ code_coverage_percentage.round }px"></div>
+            <div class="uncovered" style="width:#{ 100 - code_coverage_percentage.round }px"></div>
+          </div>}
+      end
+
+      def file_filter_classes(file_path)
+        file_path.split('/')[0..-2] * " "
+      end
+      
+      def relative_filename(path)
+        @path_relativizer[path]
+      end
+    
+      def line_css(line_number)
+        case fileinfo.coverage[line_number]
+        when true
+          "marked"
+        when :inferred
+          "inferred"
+        else
+          "uncovered"
+        end
+      end
+
+      def method_missing(key, *args)
+        local_variables.has_key?(key) ? local_variables[key] : super
+      end
+
+      def get_binding
+        binding 
+      end
+    end
+  end
+end

data/lib/rcov/formatters/text_coverage_diff.rb

@@ -0,0 +1,193 @@
+module Rcov
+  class TextCoverageDiff < BaseFormatter # :nodoc:
+    FORMAT_VERSION = [0, 1, 0]
+    DEFAULT_OPTS = { :textmode => :coverage_diff, :coverage_diff_mode => :record,
+                     :coverage_diff_file => "coverage.info", :diff_cmd => "diff", 
+                     :comments_run_by_default => true }
+    HUNK_HEADER = /@@ -\d+,\d+ \+(\d+),(\d+) @@/
+  
+    def SERIALIZER
+      # mfp> this was going to be YAML but I caught it failing at basic
+      # round-tripping, turning "\n" into "" and corrupting the data, so
+      # it must be Marshal for now
+      Marshal
+    end
+
+    def initialize(opts = {})
+      options = DEFAULT_OPTS.clone.update(opts)
+      @textmode = options[:textmode]
+      @color = options[:color]
+      @mode = options[:coverage_diff_mode]
+      @state_file = options[:coverage_diff_file]
+      @diff_cmd = options[:diff_cmd]
+      @gcc_output = options[:gcc_output]
+      super(options)
+    end
+
+    def execute
+      case @mode
+      when :record
+        record_state
+      when :compare
+        compare_state
+      else
+        raise "Unknown TextCoverageDiff mode: #{mode.inspect}."
+      end
+    end
+
+    def record_state
+      state = {}
+      each_file_pair_sorted do |filename, fileinfo|
+        state[filename] = {:lines    => SCRIPT_LINES__[filename], :coverage => fileinfo.coverage.to_a,:counts   => fileinfo.counts}
+      end
+      File.open(@state_file, "w") do |f|
+        self.SERIALIZER.dump([FORMAT_VERSION, state], f)
+      end
+    rescue
+      $stderr.puts <<-EOF
+      Couldn't save coverage data to #{@state_file}.
+      EOF
+    end # '
+
+    require 'tempfile'
+    def compare_state
+      return unless verify_diff_available
+      begin
+        format, prev_state = File.open(@state_file){|f| self.SERIALIZER.load(f) }
+      rescue
+        $stderr.puts <<-EOF
+        Couldn't load coverage data from #{@state_file}.
+        EOF
+        return # '
+      end
+      if !(Array === format) or
+        FORMAT_VERSION[0] != format[0] || FORMAT_VERSION[1] < format[1]
+        $stderr.puts <<-EOF
+        Couldn't load coverage data from #{@state_file}.
+        The file is saved in the format  #{format.inspect[0..20]}.
+        This rcov executable understands #{FORMAT_VERSION.inspect}.
+        EOF
+        return # '
+      end
+      each_file_pair_sorted do |filename, fileinfo|
+        old_data = Tempfile.new("#{mangle_filename(filename)}-old")
+        new_data = Tempfile.new("#{mangle_filename(filename)}-new")
+        if prev_state.has_key? filename
+          old_code, old_cov = prev_state[filename].values_at(:lines, :coverage)
+          old_code.each_with_index do |line, i|
+            prefix = old_cov[i] ? "   " : "!! "
+            old_data.write "#{prefix}#{line}"
+          end
+        else
+          old_data.write ""
+        end
+        old_data.close
+        SCRIPT_LINES__[filename].each_with_index do |line, i|
+          prefix = fileinfo.coverage[i] ? "   " : "!! "
+          new_data.write "#{prefix}#{line}"
+        end
+        new_data.close
+
+        diff = `#{@diff_cmd} -u "#{old_data.path}" "#{new_data.path}"`
+        new_uncovered_hunks = process_unified_diff(filename, diff)
+        old_data.close!
+        new_data.close!
+        display_hunks(filename, new_uncovered_hunks)
+      end
+    end
+
+    def display_hunks(filename, hunks)
+      return if hunks.empty?
+      puts
+      puts "=" * 80
+      puts "!!!!! Uncovered code introduced in #{filename}"
+
+      hunks.each do |offset, lines|
+        if @gcc_output
+          lines.each_with_index do |line,i|
+            lineno = offset + i
+            flag = (/^!! / !~ line) ? "-" : ":"
+            prefix = "#{filename}#{flag}#{lineno}#{flag}"
+            puts "#{prefix}#{line[3..-1]}"
+          end
+        elsif @color
+          puts "### #{filename}:#{offset}"
+          lines.each do |line|
+            prefix = (/^!! / !~ line) ? "\e[32;40m" : "\e[31;40m"
+            puts "#{prefix}#{line[3..-1].chomp}\e[37;40m"
+          end
+        else
+          puts "### #{filename}:#{offset}"
+          puts lines
+        end
+      end
+    end
+
+    def verify_diff_available
+      old_stderr = STDERR.dup
+      old_stdout = STDOUT.dup
+      new_stderr = Tempfile.new("rcov_check_diff")
+      STDERR.reopen new_stderr.path
+      STDOUT.reopen new_stderr.path
+
+      retval = system "#{@diff_cmd} --version"
+      unless retval
+        old_stderr.puts <<EOF
+  The '#{@diff_cmd}' executable seems not to be available.
+  You can specify which diff executable should be used with --diff-cmd.
+  If your system doesn't have one, you might want to use Diff::LCS's:
+  gem install diff-lcs
+  and use --diff-cmd=ldiff.
+EOF
+        return false
+      end
+      true
+    ensure
+      STDOUT.reopen old_stdout
+      STDERR.reopen old_stderr
+      new_stderr.close!
+    end
+
+    def process_unified_diff(filename, diff)
+      current_hunk = []
+      current_hunk_start = 0
+      keep_current_hunk = false
+      state = :init
+      interesting_hunks = []
+      diff.each_with_index do |line, i|
+        #puts "#{state} %5d #{line}" % i
+        case state
+        when :init
+          if md = HUNK_HEADER.match(line)
+            current_hunk = []
+            current_hunk_start = md[1].to_i
+            state = :body
+          end
+        when :body
+          case line
+          when HUNK_HEADER
+            new_start = $1.to_i
+            if keep_current_hunk
+              interesting_hunks << [current_hunk_start, current_hunk]
+            end
+            current_hunk_start = new_start
+            current_hunk = []
+            keep_current_hunk = false
+          when /^-/
+            # ignore
+          when /^\+!! /
+            keep_current_hunk = true
+            current_hunk << line[1..-1]
+          else
+            current_hunk << line[1..-1]
+          end
+        end
+      end
+      if keep_current_hunk
+        interesting_hunks << [current_hunk_start, current_hunk]
+      end
+
+      interesting_hunks
+    end
+  end
+end

data/lib/rcov/formatters/text_report.rb

@@ -0,0 +1,32 @@
+module Rcov
+  class TextReport < TextSummary # :nodoc:
+    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
+end

data/lib/rcov/formatters/text_summary.rb

@@ -0,0 +1,11 @@
+module Rcov
+  class TextSummary < BaseFormatter # :nodoc:
+    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
+end

data/lib/rcov/lowlevel.rb

@@ -0,0 +1,146 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# See LEGAL and LICENSE for licensing information.
+
+require 'rcov/version'
+
+module Rcov
+
+# RCOV__ performs the low-level tracing of the execution, gathering code
+# coverage information in the process. The C core made available through the
+# rcovrt extension will be used if possible. Otherwise the functionality
+# will be emulated using set_trace_func, but this is very expensive and
+# will fail if other libraries (e.g. breakpoint) change the trace_func.
+#
+# Do not use this module; it is very low-level and subject to frequent
+# changes. Rcov::CodeCoverageAnalyzer offers a much more convenient and
+# stable interface.
+
+module RCOV__
+  COVER = {}
+  CALLSITES = {}
+  DEFSITES = {}
+  pure_ruby_impl_needed = true
+  unless defined? $rcov_do_not_use_rcovrt 
+    begin
+      require 'rcovrt'
+      abi = [0,0,0]
+      begin
+        abi = RCOV__.ABI
+        raise if abi[0] != RCOVRT_ABI[0] || abi[1] < RCOVRT_ABI[1]
+        pure_ruby_impl_needed = false
+      rescue
+        $stderr.puts <<-EOF
+The rcovrt extension I found was built for a different version of rcov.
+The required ABI is:              #{RCOVRT_ABI.join(".")}
+Your current rcovrt extension is: #{abi.join(".")}
+
+Please delete rcovrt.{so,bundle,dll,...} and install the required one.
+        EOF
+        raise LoadError
+      end
+    rescue LoadError
+      $stderr.puts <<-EOF
+
+Since the rcovrt extension couldn't be loaded, rcov will run in pure-Ruby
+mode, which is about two orders of magnitude slower.
+
+If you're on win32, you can find a pre-built extension (usable with recent
+One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
+
+      EOF
+    end
+  end
+
+  if pure_ruby_impl_needed
+    methods = %w[install_coverage_hook remove_coverage_hook reset_coverage 
+                 install_callsite_hook remove_callsite_hook reset_callsite 
+                 generate_coverage_info generate_callsite_info]
+    sklass = class << self; self end
+    (methods & sklass.instance_methods).each do |meth|
+      sklass.class_eval{ remove_method meth }
+    end
+
+    @coverage_hook_activated = @callsite_hook_activated = false
+
+    def self.install_coverage_hook # :nodoc:
+      install_common_hook
+      @coverage_hook_activated = true
+    end
+
+    def self.install_callsite_hook # :nodoc:
+      install_common_hook
+      @callsite_hook_activated = true
+    end
+
+    def self.install_common_hook # :nodoc:
+      set_trace_func lambda {|event, file, line, id, binding, klass|
+        next unless SCRIPT_LINES__.has_key? file
+        case event
+        when 'call'
+          if @callsite_hook_activated
+            receiver = eval("self", binding)
+            klass = class << klass; self end unless klass === receiver
+            begin
+              DEFSITES[[klass.to_s, id.to_s]] = [file, line]
+            rescue Exception
+            end
+            caller_arr = self.format_backtrace_array(caller[1,1])
+            begin
+              hash = CALLSITES[[klass.to_s, id.to_s]] ||= {}
+              hash[caller_arr] ||= 0
+              hash[caller_arr] += 1
+              #puts "#{event} #{file} #{line} #{klass.inspect} " +
+              #     "#{klass.object_id} #{id} #{eval('self', binding)}"
+            rescue Exception
+            end
+          end
+        when 'c-call', 'c-return', 'class'
+          return
+        end
+        if @coverage_hook_activated
+          COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
+          COVER[file][line - 1] ||= 0
+          COVER[file][line - 1] += 1
+        end
+      }
+    end
+
+    def self.remove_coverage_hook # :nodoc:
+      @coverage_hook_activated = false
+      set_trace_func(nil) if !@callsite_hook_activated
+    end
+
+    def self.remove_callsite_hook # :nodoc:
+      @callsite_hook_activated = false
+      set_trace_func(nil) if !@coverage_hook_activated
+    end
+
+    def self.reset_coverage # :nodoc:
+      COVER.replace({})
+    end
+
+    def self.reset_callsite # :nodoc:
+      CALLSITES.replace({})
+      DEFSITES.replace({})
+    end
+
+    def self.generate_coverage_info # :nodoc:
+      Marshal.load(Marshal.dump(COVER))
+    end
+
+    def self.generate_callsite_info # :nodoc:
+      [CALLSITES, DEFSITES]
+    end
+
+    def self.format_backtrace_array(backtrace)
+      backtrace.map do |line|
+        md = /^([^:]*)(?::(\d+)(?::in `(.*)'))?/.match(line)
+        raise "Bad backtrace format" unless md
+        [nil, md[3] ? md[3].to_sym : nil, md[1], (md[2] || '').to_i]
+      end
+    end
+  end
+end 
+
+end