rcov 0.9.11 → 1.0.0

data/bin/rcov

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # -*- coding: iso-8859-1 -*-
+
 # rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
 #
 # rcov originally based on 
@@ -10,6 +11,11 @@
 #
 # See LEGAL and LICENSE for additional licensing information.
 #
+if RUBY_VERSION =~ /1.9/
+  puts "** Ruby 1.9 is not supported. Please switch to simplecov **"
+  exit 1
+end
+
 require 'cgi'
 require 'rbconfig'
 require 'optparse'
@@ -27,6 +33,7 @@ options.profiling = false
 options.destdir = nil
 options.loadpaths = []
 options.textmode = false
+options.custom_formatters = []
 options.skip = Rcov::BaseFormatter::DEFAULT_OPTS[:ignore]
 options.include = []
 options.html = true
@@ -178,6 +185,21 @@ EOF
   opts.on("--text-coverage", "Dump coverage info to stdout, using", "ANSI color sequences unless -n.") do
     options.textmode = :coverage
   end
+
+  opts.on("--require LIB", "Require an additional lib before running") do |file|
+	require file
+  end
+
+  opts.on("--custom-formatter EXPR", "Generate additional output using a",
+          "custom formatter class. The expression",
+		  "is evaluated as Ruby code and should",
+          "return a Class object") do |class_expr|
+    formatter = instance_eval class_expr
+    unless formatter.is_a? Class
+      raise "--custom-formatter expression must return a Class object. Got a #{formatter.class.name}"
+    end
+    options.custom_formatters << formatter
+  end
   
   opts.on("--gcc", "Dump uncovered line in GCC error format.") do
     options.gcc_output = true
@@ -395,6 +417,10 @@ if options.html
   end
 end
 
+options.custom_formatters.each do |formatter|
+  formatters << make_formatter[formatter]
+end
+
 textual_formatters = { :counts => Rcov::FullTextReport, :coverage => Rcov::FullTextReport,
                       :gcc => Rcov::FullTextReport, :annotate => Rcov::RubyAnnotation,
                       :summary => Rcov::TextSummary, :report => Rcov::TextReport,
@@ -503,9 +529,6 @@ $rcov_code_coverage_analyzer.install_hook
 
 #{{{ Load scripts
 begin
-  if RUBY_VERSION =~ /1.9/
-    puts "** WARNING: Ruby 1.9 Support is experimental at best. Don't expect correct results! **"
-  end
   pending_scripts = ARGV.clone
   ARGV.replace extra_args
   until pending_scripts.empty?

data/ext/rcovrt/1.8/callsite.c

@@ -4,17 +4,15 @@
 #include <st.h>
 #include <stdlib.h>
 
-static char callsite_hook_set_p;
-
 typedef struct {
   char *sourcefile;
   unsigned int sourceline;
   VALUE curr_meth;
-} type_def_site;       
+} type_def_site;
 
+static char callsite_hook_set_p;
 static VALUE caller_info = 0;
 static VALUE method_def_site_info = 0;
-
 static caller_stack_len = 1;
 
 static VALUE record_callsite_info(VALUE args) {
@@ -28,23 +26,20 @@ static VALUE record_callsite_info(VALUE args) {
   curr_meth = pargs[1];
   count_hash = rb_hash_aref(caller_info, curr_meth);
 
-  if(TYPE(count_hash) != T_HASH) { 
-    /* Qnil, anything else should be impossible unless somebody's been
-     * messing with ObjectSpace */
+  if (TYPE(count_hash) != T_HASH) {
     count_hash = rb_hash_new();
     rb_hash_aset(caller_info, curr_meth, count_hash);
   }
 
   count = rb_hash_aref(count_hash, caller_ary);
 
-  if(count == Qnil) 
-          count = INT2FIX(0);
+  if (count == Qnil) count = INT2FIX(0);
 
   count = INT2FIX(FIX2UINT(count) + 1);
   rb_hash_aset(count_hash, caller_ary, count);
   /*
-  printf("CALLSITE: %s -> %s   %d\n", RSTRING(rb_inspect(curr_meth))->ptr,
-                  RSTRING(rb_inspect(caller_ary))->ptr, FIX2INT(count));
+    printf("CALLSITE: %s -> %s   %d\n", RSTRING(rb_inspect(curr_meth))->ptr,
+    RSTRING(rb_inspect(caller_ary))->ptr, FIX2INT(count));
   */
 
   return Qnil;
@@ -55,17 +50,16 @@ static VALUE record_method_def_site(VALUE args) {
   VALUE def_site_info;
   VALUE hash;
 
-  if(RTEST(rb_hash_aref(method_def_site_info, pargs->curr_meth)))
-    return Qnil;
+  if (RTEST(rb_hash_aref(method_def_site_info, pargs->curr_meth))) return Qnil;
   def_site_info = rb_ary_new();
   rb_ary_push(def_site_info, rb_str_new2(pargs->sourcefile));
   rb_ary_push(def_site_info, INT2NUM(pargs->sourceline+1));
   rb_hash_aset(method_def_site_info, pargs->curr_meth, def_site_info);
   /*
-  printf("DEFSITE: %s:%d  for %s\n", pargs->sourcefile, pargs->sourceline+1,
-                  RSTRING(rb_inspect(pargs->curr_meth))->ptr);
+    printf("DEFSITE: %s:%d  for %s\n", pargs->sourcefile, pargs->sourceline+1,
+    RSTRING(rb_inspect(pargs->curr_meth))->ptr);
   */
-  
+
   return Qnil;
 }
 
@@ -78,18 +72,17 @@ static VALUE callsite_custom_backtrace(int lev) {
 
   ary = rb_ary_new();
 
-  if (frame->last_func == ID_ALLOCATOR) {
-    frame = frame->prev;
-  }
+  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);
-      }
+
+      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));
@@ -102,14 +95,14 @@ static VALUE callsite_custom_backtrace(int lev) {
       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;
+    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 curr_meth;
@@ -117,49 +110,40 @@ static void coverage_event_callsite_hook(rb_event_t event, NODE *node, VALUE sel
   int status;
 
   caller_ary = callsite_custom_backtrace(caller_stack_len);
-  
-  if(TYPE(klass) == T_ICLASS) {
-    klass = CLASS_OF(klass);
-  }
+
+  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));
-
   args[0] = caller_ary;
   args[1] = curr_meth;
   rb_protect(record_callsite_info, (VALUE)args, &status);
 
-  if(!status && node) {
-    type_def_site args;        
-    
+  if (!status && node) {
+    type_def_site args;
     args.sourcefile = node->nd_file;
     args.sourceline = nd_line(node) - 1;
     args.curr_meth = curr_meth;
     rb_protect(record_method_def_site, (VALUE)&args, NULL);
   }
 
-  if(status)
-    rb_gv_set("$!", Qnil);
+  if (status) rb_gv_set("$!", Qnil);
 }
 
 static VALUE cov_install_callsite_hook(VALUE self) {
-  if(!callsite_hook_set_p) {
-    if(TYPE(caller_info) != T_HASH)
-      caller_info = rb_hash_new();
+  if (!callsite_hook_set_p) {
+    if (TYPE(caller_info) != T_HASH) caller_info = rb_hash_new();
     callsite_hook_set_p = 1;
     rb_add_event_hook(coverage_event_callsite_hook, RUBY_EVENT_CALL);
-    
     return Qtrue;
-  } 
-  else
-    return Qfalse;
+  } else return Qfalse;
 }
 
 static VALUE cov_remove_callsite_hook(VALUE self) {
-  if(!callsite_hook_set_p) 
+  if (!callsite_hook_set_p) {
     return Qfalse;
-  else {
+  } else {
     rb_remove_event_hook(coverage_event_callsite_hook);
     callsite_hook_set_p = 0;
     return Qtrue;
@@ -168,7 +152,6 @@ static VALUE cov_remove_callsite_hook(VALUE self) {
 
 static VALUE cov_generate_callsite_info(VALUE self) {
   VALUE ret;
-
   ret = rb_ary_new();
   rb_ary_push(ret, caller_info);
   rb_ary_push(ret, method_def_site_info);
@@ -176,7 +159,7 @@ static VALUE cov_generate_callsite_info(VALUE self) {
 }
 
 static VALUE cov_reset_callsite(VALUE self) {
-  if(callsite_hook_set_p) {
+  if (callsite_hook_set_p) {
     rb_raise(rb_eRuntimeError, "Cannot reset the callsite info in the middle of a traced run.");
     return Qnil;
   }
@@ -193,22 +176,24 @@ void Init_rcov_callsite() {
   ID id_coverage__ = rb_intern("RCOV__");
   ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
 
-  if(rb_const_defined(rb_cObject, id_rcov)) 
+  if (rb_const_defined(rb_cObject, id_rcov)) {
     mRcov = rb_const_get(rb_cObject, id_rcov);
-  else
+  } else {
     mRcov = rb_define_module("Rcov");
-  
-  if(rb_const_defined(mRcov, id_coverage__))
+  }
+
+  if(rb_const_defined(mRcov, id_coverage__)) {
     mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
-  else
+  } else {
     mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
+  }
 
   callsite_hook_set_p = 0;
   caller_info = rb_hash_new();
   method_def_site_info = rb_hash_new();
   rb_gc_register_address(&caller_info);
   rb_gc_register_address(&method_def_site_info);
- 
+
   rb_define_singleton_method(mRCOV__, "install_callsite_hook", cov_install_callsite_hook, 0);
   rb_define_singleton_method(mRCOV__, "remove_callsite_hook", cov_remove_callsite_hook, 0);
   rb_define_singleton_method(mRCOV__, "generate_callsite_info", cov_generate_callsite_info, 0);

data/ext/rcovrt/1.8/rcovrt.c

@@ -6,7 +6,6 @@
 #include <assert.h>
 
 #define COVERAGE_DEBUG_EVENTS 0
-
 #define RCOVRT_VERSION_MAJOR 2
 #define RCOVRT_VERSION_MINOR 0
 #define RCOVRT_VERSION_REV   0
@@ -24,41 +23,36 @@ struct cov_array {
 };
 
 static struct cov_array *cached_array = 0;
-static char *cached_file = 0; 
+static char *cached_file = 0;
 
 static struct cov_array * coverage_increase_counter_uncached(char *sourcefile, unsigned int sourceline, char mark_only) {
   struct cov_array *carray = NULL;
- 
-  if(sourcefile == NULL) {
-    /* "can't happen", just ignore and avoid segfault */
+
+  if (sourcefile == NULL) {
     return NULL;
-  } 
-  else if(!st_lookup(coverinfo, (st_data_t)sourcefile, (st_data_t*)&carray)) {
+  } else 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;
+
+    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);
-  } 
-  else {
-    /* recovered carray, sanity check */
+  } else {
     assert(carray && "failed to create valid carray");
   }
 
-  if(mark_only) {
+  if (mark_only) {
     if (carray && carray->len > sourceline) {
-      if(!carray->ptr[sourceline])
+      if (!carray->ptr[sourceline])
         carray->ptr[sourceline] = 1;
     } else {
-      #if COVERAGE_DEBUG_EVENTS
-        printf("DEBUG: %s carray->len:%d sourceline:%d\n",
-               sourcefile, carray->len, sourceline);
-      #endif
+#if COVERAGE_DEBUG_EVENTS
+      printf("DEBUG: %s carray->len:%d sourceline:%d\n", sourcefile, carray->len, sourceline);
+#endif
     }
   } else {
     if (carray && carray->len > sourceline) {
@@ -73,17 +67,15 @@ static void coverage_mark_caller() {
   struct FRAME *frame = ruby_frame;
   NODE *n;
 
-  if (frame->last_func == ID_ALLOCATOR) {
-    frame = frame->prev;
-  }
+  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) {
         if (frame->prev->last_func == frame->last_func) continue;
       }
       coverage_increase_counter_uncached(n->nd_file, nd_line(n) - 1, 1);
-    }
-    else {
+    } else {
       coverage_increase_counter_uncached(n->nd_file, nd_line(n) - 1, 1);
     }
     break;
@@ -91,10 +83,11 @@ static void coverage_mark_caller() {
 }
 
 static void coverage_increase_counter_cached(char *sourcefile, int sourceline) {
-  if(cached_file == sourcefile && cached_array && cached_array->len > sourceline) {
+  if (cached_file == sourcefile && cached_array && cached_array->len > sourceline) {
     cached_array->ptr[sourceline]++;
     return;
   }
+
   cached_file = sourcefile;
   cached_array = coverage_increase_counter_uncached(sourcefile, sourceline, 0);
 }
@@ -103,74 +96,65 @@ static void coverage_event_coverage_hook(rb_event_t event, NODE *node, VALUE sel
   char *sourcefile;
   unsigned int sourceline;
   static unsigned int in_hook = 0;
- 
-  if(in_hook) {
-    return;
-  }
+
+  if (in_hook) return;
 
   in_hook++;
 
-  #if COVERAGE_DEBUG_EVENTS
-    do {
-      int status;
-      VALUE old_exception;
-      old_exception = rb_gv_get("$!");
-      rb_protect(rb_inspect, klass, &status);
-      if(!status) {
-        printf("EVENT: %d %s %s %s %d\n", event,
-               klass ? RSTRING(rb_inspect(klass))->ptr : "", 
-               mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
-               : "unknown",
-               node ? node->nd_file : "", node ? nd_line(node) : 0);
-      } 
-      else {
-        printf("EVENT: %d %s %s %d\n", event,
-               mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid)) 
-               : "unknown",
-               node ? node->nd_file : "", node ? nd_line(node) : 0);
-      }
-      
-      rb_gv_set("$!", old_exception);
-    } while (0); 
-  #endif
+#if COVERAGE_DEBUG_EVENTS
+  do {
+    int status;
+    VALUE old_exception;
+    old_exception = rb_gv_get("$!");
+    rb_protect(rb_inspect, klass, &status);
+
+    if (!status) {
+      printf("EVENT: %d %s %s %s %d\n", event,
+             klass ? RSTRING(rb_inspect(klass))->ptr : "",
+             mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
+             : "unknown",
+             node ? node->nd_file : "", node ? nd_line(node) : 0);
+    } else {
+      printf("EVENT: %d %s %s %d\n", event,
+             mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
+             : "unknown",
+             node ? node->nd_file : "", node ? nd_line(node) : 0);
+    }
 
-  if(event & RUBY_EVENT_C_CALL) {
-    coverage_mark_caller();
-  }
-  
-  if(event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS)) {
+    rb_gv_set("$!", old_exception);
+  } while (0);
+#endif
+
+  if (event & RUBY_EVENT_C_CALL) coverage_mark_caller();
+
+  if (event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS)) {
     in_hook--;
     return;
   }
-  
-  if(node == NULL) {
+
+  if (node == NULL) {
     in_hook--;
-      return;
+    return;
   }
-  
+
   sourcefile = node->nd_file;
   sourceline = nd_line(node) - 1;
-  
   coverage_increase_counter_cached(sourcefile, sourceline);
-  
-  if(event & RUBY_EVENT_CALL)
-    coverage_mark_caller();
+
+  if (event & RUBY_EVENT_CALL) coverage_mark_caller();
   in_hook--;
 }
 
 static VALUE cov_install_coverage_hook(VALUE self) {
-  if(!coverage_hook_set_p) {
-    if(!coverinfo)
-      coverinfo = st_init_strtable();
+  if (!coverage_hook_set_p) {
+    if (!coverinfo) coverinfo = st_init_strtable();
     coverage_hook_set_p = 1;
     /* TODO: allow C_CALL too, since it's supported already
      * the overhead is around ~30%, tested on typo */
     rb_add_event_hook(coverage_event_coverage_hook, RUBY_EVENT_ALL & ~RUBY_EVENT_C_CALL & ~RUBY_EVENT_C_RETURN & ~RUBY_EVENT_CLASS);
-    
+
     return Qtrue;
-  }
-  else
-    return Qfalse;
+  } else return Qfalse;
 }
 
 static int populate_cover(st_data_t key, st_data_t value, st_data_t cover) {
@@ -179,24 +163,25 @@ static int populate_cover(st_data_t key, st_data_t value, st_data_t cover) {
   VALUE rval;
   struct cov_array *carray;
   unsigned int i;
- 
+
   rcover = (VALUE)cover;
   carray = (struct cov_array *) value;
   rkey = rb_str_new2((char*) key);
   rval = rb_ary_new2(carray->len);
 
-  for(i = 0; i < carray->len; i++)
+  for (i = 0; i < carray->len; i++) {
     RARRAY(rval)->ptr[i] = UINT2NUM(carray->ptr[i]);
+  }
 
   RARRAY(rval)->len = carray->len;
   rb_hash_aset(rcover, rkey, rval);
-  
+
   return ST_CONTINUE;
 }
 
 static int free_table(st_data_t key, st_data_t value, st_data_t ignored) {
   struct cov_array *carray;
- 
+
   carray = (struct cov_array *) value;
   free((char *)key);
   free(carray->ptr);
@@ -206,9 +191,9 @@ static int free_table(st_data_t key, st_data_t value, st_data_t ignored) {
 }
 
 static VALUE cov_remove_coverage_hook(VALUE self) {
-  if(!coverage_hook_set_p) 
+  if (!coverage_hook_set_p) {
     return Qfalse;
-  else {
+  } else {
     rb_remove_event_hook(coverage_event_coverage_hook);
     coverage_hook_set_p = 0;
     return Qtrue;
@@ -218,14 +203,11 @@ static VALUE cov_remove_coverage_hook(VALUE self) {
 static VALUE cov_generate_coverage_info(VALUE self) {
   VALUE cover;
 
-  if(rb_const_defined_at(mRCOV__, id_cover)) {
-    rb_mod_remove_const(mRCOV__, ID2SYM(id_cover));
-  }
+  if (rb_const_defined_at(mRCOV__, id_cover)) rb_mod_remove_const(mRCOV__, ID2SYM(id_cover));
 
   cover = rb_hash_new();
 
-  if(coverinfo)
-    st_foreach(coverinfo, populate_cover, cover);
+  if (coverinfo) st_foreach(coverinfo, populate_cover, cover);
 
   rb_define_const(mRCOV__, "COVER", cover);
 
@@ -233,14 +215,14 @@ static VALUE cov_generate_coverage_info(VALUE self) {
 }
 
 static VALUE cov_reset_coverage(VALUE self) {
-  if(coverage_hook_set_p) {
+  if (coverage_hook_set_p) {
     rb_raise(rb_eRuntimeError, "Cannot reset the coverage info in the middle of a traced run.");
     return Qnil;
   }
 
   cached_array = 0;
   cached_file = 0;
-  st_foreach(coverinfo, free_table, Qnil); 
+  st_foreach(coverinfo, free_table, Qnil);
   st_free_table(coverinfo);
   coverinfo = 0;
 
@@ -249,12 +231,12 @@ static VALUE cov_reset_coverage(VALUE self) {
 
 static VALUE cov_ABI(VALUE self) {
   VALUE ret;
-  
+
   ret = rb_ary_new();
   rb_ary_push(ret, INT2FIX(RCOVRT_VERSION_MAJOR));
   rb_ary_push(ret, INT2FIX(RCOVRT_VERSION_MINOR));
   rb_ary_push(ret, INT2FIX(RCOVRT_VERSION_REV));
-  
+
   return ret;
 }
 
@@ -262,33 +244,35 @@ void Init_rcovrt() {
   ID id_rcov = rb_intern("Rcov");
   ID id_coverage__ = rb_intern("RCOV__");
   ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
- 
+
   id_cover = rb_intern("COVER");
-  
-  if(rb_const_defined(rb_cObject, id_rcov)) 
+
+  if (rb_const_defined(rb_cObject, id_rcov)) {
     mRcov = rb_const_get(rb_cObject, id_rcov);
-  else
+  } else {
     mRcov = rb_define_module("Rcov");
-  
-  if(rb_const_defined(mRcov, id_coverage__))
+  }
+
+  if (rb_const_defined(mRcov, id_coverage__)) {
     mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
-  else
+  } else {
     mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
-  
-  if(rb_const_defined(rb_cObject, id_script_lines__))
+  }
+
+  if (rb_const_defined(rb_cObject, id_script_lines__)) {
     oSCRIPT_LINES__ = rb_const_get(rb_cObject, rb_intern("SCRIPT_LINES__"));
-  else {
+  } else {
     oSCRIPT_LINES__ = rb_hash_new();
     rb_const_set(rb_cObject, id_script_lines__, oSCRIPT_LINES__);
   }
-  
+
   coverage_hook_set_p = 0;
-  
+
   rb_define_singleton_method(mRCOV__, "install_coverage_hook", cov_install_coverage_hook, 0);
   rb_define_singleton_method(mRCOV__, "remove_coverage_hook",  cov_remove_coverage_hook, 0);
   rb_define_singleton_method(mRCOV__, "generate_coverage_info", cov_generate_coverage_info, 0);
   rb_define_singleton_method(mRCOV__, "reset_coverage", cov_reset_coverage, 0);
   rb_define_singleton_method(mRCOV__, "ABI", cov_ABI, 0);
-  
+
   Init_rcov_callsite();
 }