rcov 0.8.1.2.0 → 0.9.3

data/doc/readme_for_api.markdown

@@ -0,0 +1,22 @@
+# RCov
+
+RCov is a:
+
+1. tool for code coverage analysis for Ruby
+2. library for collecting code coverage and execution count information introspectively
+
+If you want to use the command line tool, the output from `rcov -h` is self explanatory.  If you want to automate the execution of RCov via Rake take a look at [readme for rake]("http://github.com/relevance/rcov/blob/master/doc/readme_for_rake.markdown").  If you want to use the associated library, read on.
+
+## Usage of the RCov runtime/library
+
+RCov is primarily a tool for code coverage analysis, but since 0.4.0 it exposes some of its code so that you can build on top of its heuristics for code analysis and its capabilities for coverage information and execution count gathering.  The main classes of interest are `Rcov::FileStatistics`, `Rcov::CodeCoverageAnalyzer` and `Rcov::CallSiteAnalyzer`. 
+
+* `Rcov::FileStatistics` can use some heuristics to determine which parts of the file are executable and which are mere comments.
+
+* `Rcov::CodeCoverageAnalyzer` is used to gather code coverage and execution count information inside a running Ruby program.
+
+* `Rcov::CallSiteAnalyzer` is used to obtain information about where methods are defined and who calls them.
+
+The parts of RCov's runtime meant to be reused (i.e. the external API) are documented with RDoc. Those not meant to be used are clearly marked as so or were deliberately removed from the present documentation.
+
+

data/doc/readme_for_emacs.markdown

@@ -0,0 +1,52 @@
+# rcov.el
+
+`rcov.el` allows you to use rcov from Emacs conveniently.
+
+* Run unit tests and jump to uncovered code by <code>C-x `</code>
+* Run unit tests and save the current coverage status.
+* Run unit tests and jump to uncovered code introduced since the last run.
+* View cross-reference annotated code.
+
+## Installation
+
+Copy <tt>rcov.el</tt> to the appropriate directory, which is in load-path then require it.
+
+`(require 'rcov)`
+
+## Usage
+
+There are some commands to run RCov in Emacs.  All of them will display RCov window, whose `major-mode` is `compilation-mode`.  This allow you to jump to uncovered code using C-x `. rcov-command-line, rcovsave-command-line, and rcovdiff-command-line define command line to run rcov. If you do not use RCov from Rake, you must modify them.
+
+### Finding uncovered code
+
+Type the following while editing your program:
+  
+`M-x rcov`
+  
+### Setting the reference point
+
+RCov's `--text-coverage-diff` 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 `--save` option. Type the following to save the current status in Emacs:
+
+`M-x rcovsave`
+
+If you do not use RCov from Rake, you must modify `rcovsave-command-line` variable.
+
+### Finding new uncovered code
+
+Type the following to save the current status in Emacs:
+  
+`M-x rcovdiff`
+
+### Viewing cross-reference annotated code
+
+If you read cross-reference annotated code, issue
+
+`rake rcov RCOVOPTS='-a'`
+
+at the beginning.  This command creates a `coverage` directory and many `*.rb` files in it.  Filenames of these Ruby scripts are converted from original path.  You can browse them by normally `C-x C-f`.  You can think of `-a` option as `--xrefs` option and output format is Ruby script.  After `find-file-ed` annotated script, the `major-mode` is `rcov-xref-mode`,
+which is derived from `ruby-mode` and specializes navigation.
+
+* `Tab` and `M-Tab` goes forward/backward links.
+* `Ret` follows selected link.
+
+This feature is useful to read third-party code or to follow control flow.

data/doc/readme_for_rake.markdown

@@ -0,0 +1,51 @@
+# Code coverage analysis automation with Rake
+
+Since 0.4.0, RCov features a `Rcov::RcovTask` task for rake
+which can be used to automate test coverage analysis.  Basic usage is as
+follows:
+<pre><code>
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/test*.rb']
+  # t.verbose = true     # uncomment to see the executed command
+end
+</pre></code>
+
+This will create by default a task named `rcov`, and also a task to remove the output directory where the XHTML report is generated.  The latter will be named `clobber_rcov`, and will be added to the main `clobber` target.
+
+## Passing command line options to RCov
+
+You can provide a description, change the name of the generated tasks (the one used to generate the report(s) and the `clobber_` one) and pass options to RCov:
+<pre><code>
+desc "Analyze code coverage of the unit tests."
+Rcov::RcovTask.new(:coverage) do |t|
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+  ## get a text report on stdout when rake is run:
+  t.rcov_opts << "--text-report"  
+  ## only report files under 80% coverage
+  t.rcov_opts << "--threshold 80"
+end
+</pre></code>
+
+This will generate a `coverage` task and the associated `clobber_coverage` task to remove the directory the report is dumped to (`coverage` by default).  You can specify a different destination directory, which comes handy if you have several `RcovTask`s; the `clobber_*` will take care of removing that directory:
+<pre><code>
+desc "Analyze code coverage for the FileStatistics class."
+Rcov::RcovTask.new(:rcov_sourcefile) do |t|
+  t.test_files = FileList['test/test_FileStatistics.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.output_dir = "coverage.sourcefile"
+end
+ 
+Rcov::RcovTask.new(:rcov_ccanalyzer) do |t|
+  t.test_files = FileList['test/test_CodeCoverageAnalyzer.rb']
+  t.verbose = true
+  t.rcov_opts << "--test-unit-only"
+  t.output_dir = "coverage.ccanalyzer"
+end
+</pre></code>
+
+## Options passed through the `rake` command line
+
+You can override the options defined in the RcovTask by passing the new options at the time you invoke rake. The documentation for the `Rcov::RcovTask` explains how this can be done.

data/doc/readme_for_vim.markdown

@@ -0,0 +1,34 @@
+# rcov.vim
+
+`rcov.vim` 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 `rcov.vim` to the appropriate `compiler` directory (typically `$HOME/.vim/compiler`).
+
+### Usage
+
+#### Setting the reference point
+
+RCov's `--text-coverage-diff` 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 `--save` 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 for rake]("http://github.com/relevance/rcov/blob/master/doc/readme_for_rake.markdown") 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.

data/ext/rcovrt/1.8/callsite.c

@@ -0,0 +1,216 @@
+#include <ruby.h>
+#include <env.h>
+#include <node.h>
+#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;       
+
+static VALUE caller_info = 0;
+static VALUE method_def_site_info = 0;
+
+static caller_stack_len = 1;
+
+static VALUE record_callsite_info(VALUE args) {
+  VALUE caller_ary;
+  VALUE curr_meth;
+  VALUE count_hash;
+  VALUE count;
+  VALUE *pargs = (VALUE *)args;
+
+  caller_ary = pargs[0];
+  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 */
+    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);
+
+  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));
+  */
+
+  return Qnil;
+}
+
+static VALUE record_method_def_site(VALUE args) {
+  type_def_site *pargs = (type_def_site *)args;
+  VALUE def_site_info;
+  VALUE hash;
+
+  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);
+  */
+  
+  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 curr_meth;
+  VALUE args[2];
+  int status;
+
+  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));
+
+  args[0] = caller_ary;
+  args[1] = curr_meth;
+  rb_protect(record_callsite_info, (VALUE)args, &status);
+
+  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);
+}
+
+static VALUE cov_install_callsite_hook(VALUE self) {
+  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;
+}
+
+static VALUE cov_remove_callsite_hook(VALUE self) {
+  if(!callsite_hook_set_p) 
+    return Qfalse;
+  else {
+    rb_remove_event_hook(coverage_event_callsite_hook);
+    callsite_hook_set_p = 0;
+    return Qtrue;
+  }
+}
+
+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);
+  return ret;
+}
+
+static VALUE cov_reset_callsite(VALUE self) {
+  if(callsite_hook_set_p) {
+    rb_raise(rb_eRuntimeError, "Cannot reset the callsite info in the middle of a traced run.");
+    return Qnil;
+  }
+
+  caller_info = rb_hash_new();
+  method_def_site_info = rb_hash_new();
+  return Qnil;
+}
+
+void Init_rcov_callsite() {
+  VALUE mRcov;
+  VALUE mRCOV__;
+  ID id_rcov = rb_intern("Rcov");
+  ID id_coverage__ = rb_intern("RCOV__");
+  ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
+
+  if(rb_const_defined(rb_cObject, id_rcov)) 
+    mRcov = rb_const_get(rb_cObject, id_rcov);
+  else
+    mRcov = rb_define_module("Rcov");
+  
+  if(rb_const_defined(mRcov, id_coverage__))
+    mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
+  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);
+  rb_define_singleton_method(mRCOV__, "reset_callsite", cov_reset_callsite, 0);
+}

data/ext/rcovrt/1.8/rcovrt.c

@@ -0,0 +1,287 @@
+#include <ruby.h>
+#include <env.h>
+#include <node.h>
+#include <st.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define COVERAGE_DEBUG_EVENTS 0
+
+#define RCOVRT_VERSION_MAJOR 2
+#define RCOVRT_VERSION_MINOR 0
+#define RCOVRT_VERSION_REV   0
+
+static VALUE mRcov;
+static VALUE mRCOV__;
+static VALUE oSCRIPT_LINES__;
+static ID id_cover;
+static st_table* coverinfo = 0;
+static char coverage_hook_set_p;
+
+struct cov_array {
+  unsigned int len;
+  unsigned int *ptr;
+};
+
+static struct cov_array *cached_array = 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 */
+    return NULL;
+  } 
+  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;
+    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 */
+    assert(carray && "failed to create valid carray");
+  }
+
+  if(mark_only) {
+    if(!carray->ptr[sourceline])
+      carray->ptr[sourceline] = 1;
+  } else {
+    if (carray && carray->len > sourceline) {
+      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) {
+        if (frame->prev->last_func == frame->last_func) continue;
+      }
+      coverage_increase_counter_uncached(n->nd_file, nd_line(n) - 1, 1);
+    }
+    else {
+      coverage_increase_counter_uncached(n->nd_file, nd_line(n) - 1, 1);
+    }
+    break;
+  }
+}
+
+static void coverage_increase_counter_cached(char *sourcefile, int 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);
+}
+
+static void coverage_event_coverage_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass) {
+  char *sourcefile;
+  unsigned int sourceline;
+  static unsigned int in_hook = 0;
+ 
+  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(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) {
+    in_hook--;
+      return;
+  }
+  
+  sourcefile = node->nd_file;
+  sourceline = nd_line(node) - 1;
+  
+  coverage_increase_counter_cached(sourcefile, sourceline);
+  
+  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();
+    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;
+}
+
+static int populate_cover(st_data_t key, st_data_t value, st_data_t cover) {
+  VALUE rcover;
+  VALUE rkey;
+  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++)
+    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);
+  free(carray);
+
+  return ST_CONTINUE;
+}
+
+static VALUE cov_remove_coverage_hook(VALUE self) {
+  if(!coverage_hook_set_p) 
+    return Qfalse;
+  else {
+    rb_remove_event_hook(coverage_event_coverage_hook);
+    coverage_hook_set_p = 0;
+    return Qtrue;
+  }
+}
+
+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));
+  }
+
+  cover = rb_hash_new();
+
+  if(coverinfo)
+    st_foreach(coverinfo, populate_cover, cover);
+
+  rb_define_const(mRCOV__, "COVER", cover);
+
+  return cover;
+}
+
+static VALUE cov_reset_coverage(VALUE self) {
+  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_free_table(coverinfo);
+  coverinfo = 0;
+
+  return Qnil;
+}
+
+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;
+}
+
+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)) 
+    mRcov = rb_const_get(rb_cObject, id_rcov);
+  else
+    mRcov = rb_define_module("Rcov");
+  
+  if(rb_const_defined(mRcov, id_coverage__))
+    mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
+  else
+    mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
+  
+  if(rb_const_defined(rb_cObject, id_script_lines__))
+    oSCRIPT_LINES__ = rb_const_get(rb_cObject, rb_intern("SCRIPT_LINES__"));
+  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();
+}