rcov 0.5.0.1-mswin32 → 0.6.0.1-mswin32

data/ext/rcovrt/extconf.rb

@@ -1,3 +1,11 @@
 require 'mkmf'
 
-create_makefile("rcovrt")
+dir_config("gcov")
+if ENV["USE_GCOV"] and Config::CONFIG['CC'] =~ /gcc/ and 
+  have_library("gcov", "__gcov_open")
+
+  $CFLAGS << " -fprofile-arcs -ftest-coverage"
+  create_makefile("rcovrt")
+else
+  create_makefile("rcovrt")
+end

data/ext/rcovrt/rcov.c

@@ -1,10 +1,11 @@
 
 #include <ruby.h>
+#include <env.h>
 #include <node.h>
 #include <st.h>
 #include <stdlib.h>
 
-#define RCOVRT_VERSION_MAJOR 1
+#define RCOVRT_VERSION_MAJOR 2
 #define RCOVRT_VERSION_MINOR 0
 #define RCOVRT_VERSION_REV   0
 
@@ -12,7 +13,6 @@ static VALUE mRcov;
 static VALUE mRCOV__;
 static VALUE oSCRIPT_LINES__;
 static ID id_cover;
-static VALUE id_caller = 0;
 static st_table* coverinfo = 0;
 static char coverage_hook_set_p;
 static char callsite_hook_set_p;
@@ -94,22 +94,61 @@ record_method_def_site(VALUE args)
   return Qnil;
 }
 
+static VALUE
+callsite_custom_backtrace(int lev)
+{
+  struct FRAME *frame = ruby_frame;
+  VALUE ary;
+  NODE *n;
+  VALUE level;
+  VALUE klass;
+
+  ary = rb_ary_new();
+  if (frame->last_func == ID_ALLOCATOR) {
+          frame = frame->prev;
+  }
+  for (; frame && (n = frame->node); frame = frame->prev) {
+          if (frame->prev && frame->prev->last_func) {
+                  if (frame->prev->node == n) continue;
+                  level = rb_ary_new();
+                  klass = frame->prev->last_class ? frame->prev->last_class : Qnil;
+                  if(TYPE(klass) == T_ICLASS) {
+                          klass = CLASS_OF(klass);
+                  }
+                  rb_ary_push(level, klass);
+                  rb_ary_push(level, ID2SYM(frame->prev->last_func));
+                  rb_ary_push(level, rb_str_new2(n->nd_file));
+                  rb_ary_push(level, INT2NUM(nd_line(n)));
+          }
+          else {
+                  level = rb_ary_new();
+                  rb_ary_push(level, Qnil);
+                  rb_ary_push(level, Qnil);
+                  rb_ary_push(level, rb_str_new2(n->nd_file));
+                  rb_ary_push(level, INT2NUM(nd_line(n)));
+          }
+          rb_ary_push(ary, level);
+          if(--lev == 0)
+                  break;
+  }
+
+  return ary;
+}
   
 static void
 coverage_event_callsite_hook(rb_event_t event, NODE *node, VALUE self, 
                 ID mid, VALUE klass)
 {
  VALUE caller_ary;
- VALUE aref_args[2];
  VALUE curr_meth;
  VALUE args[2];
  int status;
 
- caller_ary = rb_funcall(rb_mKernel, id_caller, 0);
- aref_args[0] = INT2FIX(0);
- aref_args[1] = INT2NUM(caller_stack_len);
- caller_ary = rb_ary_aref(2, aref_args, caller_ary);
+ caller_ary = callsite_custom_backtrace(caller_stack_len);
 
+ if(TYPE(klass) == T_ICLASS) {
+         klass = CLASS_OF(klass);
+ }
  curr_meth = rb_ary_new();
  rb_ary_push(curr_meth, klass);
  rb_ary_push(curr_meth, ID2SYM(mid));
@@ -123,7 +162,7 @@ coverage_event_callsite_hook(rb_event_t event, NODE *node, VALUE self,
          args.sourcefile = node->nd_file;
          args.sourceline = nd_line(node) - 1;
          args.curr_meth = curr_meth;
-         rb_protect(record_method_def_site, (VALUE)&args, 0);
+         rb_protect(record_method_def_site, (VALUE)&args, NULL);
  }
  if(status)
          rb_gv_set("$!", Qnil);
@@ -191,6 +230,70 @@ cov_reset_callsite(VALUE self)
  *
  * */
 
+static struct cov_array *
+coverage_increase_counter_uncached(char *sourcefile, int sourceline,
+                                   char mark_only)
+{
+  struct cov_array *carray;
+  
+  if(!st_lookup(coverinfo, (st_data_t)sourcefile, (st_data_t*)&carray)) {
+          VALUE arr;
+
+          arr = rb_hash_aref(oSCRIPT_LINES__, rb_str_new2(sourcefile));
+          if(NIL_P(arr)) 
+                  return 0;
+          rb_check_type(arr, T_ARRAY);
+          carray = calloc(1, sizeof(struct cov_array));
+          carray->ptr = calloc(RARRAY(arr)->len, sizeof(unsigned int));
+          carray->len = RARRAY(arr)->len;
+          st_insert(coverinfo, (st_data_t)strdup(sourcefile), 
+                          (st_data_t) carray);
+  }
+  if(mark_only) {
+          if(!carray->ptr[sourceline])
+                  carray->ptr[sourceline] = 1;
+  } else {
+          carray->ptr[sourceline]++;
+  }
+
+  return carray;
+}
+
+
+static void
+coverage_mark_caller()
+{
+  struct FRAME *frame = ruby_frame;
+  NODE *n;
+
+  if (frame->last_func == ID_ALLOCATOR) {
+          frame = frame->prev;
+  }
+  for (; frame && (n = frame->node); frame = frame->prev) {
+          if (frame->prev && frame->prev->last_func) {
+                  if (frame->prev->node == n) continue;
+                  coverage_increase_counter_uncached(n->nd_file, nd_line(n), 1);
+          }
+          else {
+                  coverage_increase_counter_uncached(n->nd_file, nd_line(n), 1);
+          }
+          break;
+  }
+}
+
+
+static void
+coverage_increase_counter_cached(char *sourcefile, int sourceline)
+{
+ if(cached_file == sourcefile && cached_array) {
+         cached_array->ptr[sourceline]++;
+         return;
+ }
+ cached_file = sourcefile;
+ cached_array = coverage_increase_counter_uncached(sourcefile, sourceline, 0);
+}
+
+
 static void
 coverage_event_coverage_hook(rb_event_t event, NODE *node, VALUE self, 
                 ID mid, VALUE klass)
@@ -201,34 +304,15 @@ coverage_event_coverage_hook(rb_event_t event, NODE *node, VALUE self,
  if(event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS))
          return;
  
- if(!node)
+ if(node == NULL)
          return;
 
  sourcefile = node->nd_file;
  sourceline = nd_line(node) - 1;
 
-
- if(cached_file == sourcefile && cached_array) {
-         cached_array->ptr[sourceline]++;
-         return;
- }
- 
-
- if(!st_lookup(coverinfo, (st_data_t)sourcefile, (st_data_t*)&cached_array)) {
-         VALUE arr;
-
-         arr = rb_hash_aref(oSCRIPT_LINES__, rb_str_new2(sourcefile));
-         if(NIL_P(arr)) 
-                 return;
-         rb_check_type(arr, T_ARRAY);
-         cached_array = calloc(1, sizeof(struct cov_array));
-         cached_array->ptr = calloc(RARRAY(arr)->len, sizeof(unsigned int));
-         cached_array->len = RARRAY(arr)->len;
-         st_insert(coverinfo, (st_data_t)strdup(sourcefile), 
-                   (st_data_t) cached_array);
- }
- cached_file = sourcefile;
- cached_array->ptr[sourceline]++;
+ coverage_increase_counter_cached(sourcefile, sourceline);
+ if(event == RUBY_EVENT_CALL)
+         coverage_mark_caller();
 }
 
 
@@ -359,7 +443,6 @@ Init_rcovrt()
  ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
  
  id_cover = rb_intern("COVER");
- id_caller = rb_intern("caller");
 
  if(rb_const_defined(rb_cObject, id_rcov)) 
          mRcov = rb_const_get(rb_cObject, id_rcov);

data/lib/rcov.rb

@@ -79,7 +79,7 @@ end
 # counts would normally be obtained from a Rcov::CodeCoverageAnalyzer.
 class FileStatistics
   attr_reader :name, :lines, :coverage, :counts
-  def initialize(name, lines, counts)
+  def initialize(name, lines, counts, comments_run_by_default = false)
     @name = name
     @lines = lines
     initial_coverage = counts.map{|x| (x || 0) > 0 ? true : false }
@@ -92,7 +92,7 @@ class FileStatistics
     @multiline_string_start = Array.new(lines.size, false)
     extend_heredocs
     find_multiline_strings
-    precompute_coverage false
+    precompute_coverage comments_run_by_default
   end
 
   # Merge code coverage and execution count information.
@@ -108,8 +108,10 @@ class FileStatistics
   def merge(lines, coverage, counts)
     coverage.each_with_index do |v, idx|
       case @coverage[idx]
-      when :inferred : @coverage[idx] = v || @coverage[idx]
-      when false : @coverage[idx] ||= v
+      when :inferred 
+        @coverage[idx] = v || @coverage[idx]
+      when false 
+        @coverage[idx] ||= v
       end
     end
     counts.each_with_index{|v, idx| @counts[idx] += v }
@@ -207,12 +209,23 @@ class FileStatistics
 
   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]
       if /^\s*(begin|ensure|else|case)\s*(?:#.*)?$/ =~ line && next_expr_marked?(i) or
         /^\s*(?:end|\})\s*(?:#.*)?$/ =~ line && prev_expr_marked?(i) or
+        /^\s*(?:end\b|\})/ =~ line && prev_expr_marked?(i) && next_expr_marked?(i) or
         /^\s*rescue\b/ =~ line && next_expr_marked?(i) or
+        /(do|\{)\s*(\|[^|]*\|\s*)?(?:#.*)?$/ =~ line && next_expr_marked?(i) or
         prev_expr_continued?(i) && prev_expr_marked?(i) or
         comments_run_by_default && !is_code?(i) or 
         /^\s*((\)|\]|\})\s*)+(?:#.*)?$/ =~ line && prev_expr_marked?(i) or
@@ -253,6 +266,8 @@ class FileStatistics
       loop do
         scanned_text = scanner.search_full(/<<(-?)(?:(['"`])((?:(?!\2).)+)\2|([A-Z_a-z]\w*))/, 
                                            true, true)
+        # k is the first line after the end delimiter for the last heredoc
+        # scanned so far
         unless scanner.matched?
           i = k
           break
@@ -265,23 +280,25 @@ class FileStatistics
           i = k
           break
         end
-        if @coverage[i]
-          must_mark = []
-          end_of_heredoc = (scanner[1] == "-") ? /^\s*#{Regexp.escape(term)}$/ :
-            /^#{Regexp.escape(term)}$/
-            loop do
-            break if j == @lines.size
-            must_mark << j
-            if end_of_heredoc =~ @lines[j]
-              must_mark.each do |n|
-                @heredoc_start[n] = i
-                @coverage[n] ||= :inferred
-              end
-              k = (j += 1)
-              break
+        must_mark = []
+        end_of_heredoc = (scanner[1] == "-") ? 
+               /^\s*#{Regexp.escape(term)}$/ : /^#{Regexp.escape(term)}$/
+        loop do
+          break if j == @lines.size
+          must_mark << j
+          if end_of_heredoc =~ @lines[j]
+            must_mark.each do |n|
+              @heredoc_start[n] = i
             end
-            j += 1
+            if (must_mark + [i]).any?{|lineidx| @coverage[lineidx]}
+              @coverage[i] ||= :inferred
+              must_mark.each{|lineidx| @coverage[lineidx] ||= :inferred}
             end
+            # move the "first line after heredocs" index
+            k = (j += 1)
+            break
+          end
+          j += 1
         end
       end
 
@@ -644,19 +661,15 @@ class CodeCoverageAnalyzer < DifferentialAnalyzer
 
 
   def refine_coverage_info(lines, covers)
-    line_info = []
     marked_info = []
     count_info = []
-    0.upto(lines.size - 1) do |c|
-      line = lines[c].chomp
-      marked = false
-      marked = true if covers[c] && covers[c] > 0
-      line_info << line
-      marked_info << marked
-      count_info << (covers[c] || 0)
+    lines.size.times do |i|
+      c = covers[i]
+      marked_info << ((c && c > 0) ? true : false)
+      count_info << (c || 0)
     end
 
-    script_lines_workaround(line_info, marked_info, count_info)
+    script_lines_workaround(lines, marked_info, count_info)
   end
 
   # Try to detect repeated data, based on observed repetitions in line_info:
@@ -744,30 +757,40 @@ class CallSiteAnalyzer < DifferentialAnalyzer
   # Object representing a method call site.
   # It corresponds to a part of the callstack starting from the context that
   # called the method.   
-  class CallSite < Struct.new(:description)
+  class CallSite < Struct.new(:backtrace)
     # The depth of a CallSite is the number of stack frames
     # whose information is included in the CallSite object.
     def depth
-      description.size
+      backtrace.size
     end
     
     # File where the method call originated.
+    # Might return +nil+ or "" if it is not meaningful (C extensions, etc).
     def file(level = 0)
-      desc = description[level]
-      desc ? desc[/[^:]*/] : nil
+      stack_frame = backtrace[level]
+      stack_frame ? stack_frame[2] : nil
     end
 
     # Line where the method call originated.
+    # Might return +nil+ or 0 if it is not meaningful (C extensions, etc).
     def line(level = 0)
-      desc = description[level]
-      desc ? desc[/:(\d+)/, 1].to_i : nil
+      stack_frame = backtrace[level]
+      stack_frame ? stack_frame[3] : nil
     end
 
     # Name of the method where the call originated.
     # Returns +nil+ if the call originated in +toplevel+.
+    # Might return +nil+ if it could not be determined.
     def calling_method(level = 0)
-      desc = description[level]
-      desc ? desc[/:in `(.*)'/, 1] : nil
+      stack_frame = backtrace[level]
+      stack_frame ? stack_frame[1] : nil
+    end
+
+    # Name of the class holding the method where the call originated.
+    # Might return +nil+ if it could not be determined.
+    def calling_class(level = 0)
+      stack_frame = backtrace[level]
+      stack_frame ? stack_frame[0] : nil
     end
   end
 
@@ -814,7 +837,9 @@ class CallSiteAnalyzer < DifferentialAnalyzer
     return nil unless rawsites
     ret = {}
     # could be a job for inject but it's slow and I don't mind the extra loc
-    rawsites.each_pair{|csite_info, count| ret[CallSite.new(csite_info)] = count }
+    rawsites.each_pair do |backtrace, count|
+      ret[CallSite.new(backtrace)] = count
+    end
     ret
   end
 
@@ -826,9 +851,9 @@ class CallSiteAnalyzer < DifferentialAnalyzer
   #   analyzer.defsite("Foo", "f1")
   #   analyzer.defsite("#<class:Foo>", "g1")
   def defsite(classname_or_fullname, methodname = nil)
-    raw = raw_data_relative[1][expand_name(classname_or_fullname, methodname)]
-    return nil unless raw
-    DefSite.new(*raw)
+    file, line = raw_data_relative[1][expand_name(classname_or_fullname, methodname)]
+    return nil unless file && line
+    DefSite.new(file, line)
   end
 
   private
@@ -857,9 +882,9 @@ class CallSiteAnalyzer < DifferentialAnalyzer
     raw.each_pair do |(klass, method), hash|
       begin  
         key = [klass.to_s, method.to_s]
-        ret1[key] = hash.clone # no deep cloning needed
+        ret1[key] = hash.clone #Marshal.load(Marshal.dump(hash))
         ret2[key] = method_def_site[[klass, method]]
-      rescue Exception
+      #rescue Exception
       end
     end
     

data/lib/rcov/lowlevel.rb

@@ -84,7 +84,7 @@ One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
               DEFSITES[[klass.to_s, id.to_s]] = [file, line]
             rescue Exception
             end
-            caller_arr = caller[1,1]
+            caller_arr = self.format_backtrace_array(caller[1,1])
             begin
               hash = CALLSITES[[klass.to_s, id.to_s]] ||= {}
               hash[caller_arr] ||= 0
@@ -131,6 +131,14 @@ One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
     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 # RCOV__