spicycode-rcov 0.8.1.5.6 → 0.8.1.5.7

data/Rakefile

@@ -17,8 +17,7 @@ require 'rake/clean'
 ENV["RCOVPATH"] = "bin/rcov"
 
 # The following task is largely equivalent to:
-#   Rcov::RcovTask.new
-# (really!)
+# Rcov::RcovTask.new
 desc "Create a cross-referenced code coverage report."
 Rcov::RcovTask.new do |t|
   t.test_files = FileList['test/*_test.rb']
@@ -53,6 +52,7 @@ if RUBY_PLATFORM == 'java'
   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
@@ -73,122 +73,24 @@ end
 
 desc "Run the unit tests"
 task :test => [:test_rcovrt]
-#, :test_pure_ruby] disabled since 1.8.5 broke them
+
+desc "install by setup.rb"
+task :install do
+  sh "sudo ruby setup.rb install"
+end
+
+task :default => :test
 
 desc "Generate rdoc documentation for the rcov library"
 Rake::RDocTask.new("rdoc") { |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title    = "rcov"
   rdoc.options << "--line-numbers" << "--inline-source"
-  rdoc.rdoc_files.include('readme_for_api')
-  rdoc.rdoc_files.include('readme_for_rake')
-  rdoc.rdoc_files.include('readme_for_rant')
-  rdoc.rdoc_files.include('readme_for_vim')
+  rdoc.rdoc_files.include('doc/readme_for_api')
+  rdoc.rdoc_files.include('doc/readme_for_rake')
+  rdoc.rdoc_files.include('doc/readme_for_rant')
+  rdoc.rdoc_files.include('doc/readme_for_vim')
   rdoc.rdoc_files.include('lib/**/*.rb')
 }
 
-task :default => :test
-
-desc "install by setup.rb"
-task :install do
-  sh "sudo ruby setup.rb install"
-end
-
-
-PKG_FILES = ["bin/rcov", "lib/rcov.rb", "lib/rcov/lowlevel.rb", "lib/rcov/xx.rb", "lib/rcov/version.rb", "lib/rcov/rant.rb", "lib/rcov/report.rb", "lib/rcov/rcovtask.rb", "ext/rcovrt/extconf.rb", "ext/rcovrt/rcovrt.c", "ext/rcovrt/callsite.c", "LEGAL", "LICENSE", "Rakefile", "Rantfile", "readme_for_rake", "readme_for_rant", "readme_for_vim", "readme_for_emacs", "readme_for_vim", "readme_for_api", "THANKS", "test/functional_test.rb", "test/file_statistics_test.rb", "test/assets/sample_03.rb", "test/assets/sample_05-new.rb", "test/code_coverage_analyzer_test.rb", "test/assets/sample_04.rb", "test/assets/sample_02.rb", "test/assets/sample_05-old.rb", "test/assets/sample_01.rb", "test/turn_off_rcovrt.rb", "test/call_site_analyzer_test.rb", "test/assets/sample_05.rb", "rcov.vim", "rcov.el", "setup.rb", "BLURB", "CHANGES"]
-
-# gem management tasks  Use these to build the java code before creating the gem package
-# this code can also be used to generate the MRI gem.  But I left the gemspec file in too.
-spec = Gem::Specification.new do |s|
-  s.name = %q{rcov}
-  s.version = Rcov::VERSION
-
-  s.required_rubygems_version = nil if s.respond_to? :required_rubygems_version=
-  s.authors = ["Mauricio Fernandez"]
-  s.cert_chain = nil
-  s.date = %q{2007-11-21}
-  s.default_executable = %q{rcov}
-  s.description = %q{rcov is a code coverage tool for Ruby. It is commonly used for viewing overall test unit coverage of target code.  It features fast execution (20-300 times faster than previous tools), multiple analysis modes, XHTML and several kinds of text reports, easy automation with Rake via a RcovTask, fairly accurate coverage information through code linkage inference using simple heuristics, colorblind-friendliness...}
-  s.email = %q{mfp@acm.org}
-  s.executables = ["rcov"]
-  s.extensions = ["ext/rcovrt/extconf.rb"]
-  s.platform = Gem::Platform::RUBY
-  s.extra_rdoc_files = ["readme_for_api", "readme_for_rake", "readme_for_rant", "readme_for_vim"]
-  s.files = PKG_FILES
-  s.has_rdoc = true
-  s.homepage = %q{http://eigenclass.org/hiki.rb?rcov}
-  s.rdoc_options = ["--main", "readme_for_api", "--title", "rcov code coverage tool"]
-  s.require_paths = ["lib"]
-  s.required_ruby_version = Gem::Requirement.new("> 0.0.0")
-  s.rubygems_version = %q{1.2.0}
-  s.summary = %q{Code coverage analysis tool for Ruby}
-  s.test_files = ["test/functional_test.rb", "test/file_statistics_test.rb", "test/code_coverage_analyzer_test.rb", "test/call_site_analyzer_test.rb"]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 1
-
-    if current_version >= 3 then
-    else
-    end
-  else
-  end
-end
-
-# tasks added in to support generating the JRuby gem.
-if RUBY_PLATFORM == 'java'
-  spec.platform = "jruby"
-  spec.extensions = []
-  # add the jruby extension to the file list
-  PKG_FILES << "lib/rcovrt.jar"  
-  
-  def java_classpath_arg
-    begin
-      require 'java'
-      classpath = java.lang.System.getProperty('java.class.path')
-    rescue LoadError
-    end
-  
-    if classpath.empty?
-      classpath = FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
-    end
-  
-    classpath ? "-cp #{classpath}" : ""
-  end
-  
-  
-  CLEAN.include ["ext/java/classes", "lib/rcovrt.jar", "pkg"]
-  
-  def compile_java
-    mkdir_p "ext/java/classes"
-    sh "javac -g -target 1.5 -source 1.5 -d ext/java/classes #{java_classpath_arg} #{FileList['ext/java/src/**/*.java'].join(' ')}"
-  end
-  
-  def make_jar
-    require 'fileutils'
-    lib = File.join(File.dirname(__FILE__), 'lib')
-    FileUtils.mkdir(lib) unless File.exists? lib
-    sh "jar cf lib/rcovrt.jar -C ext/java/classes/ ." 
-  end
-  
-  file 'lib/rcovrt.jar' => FileList["ext/java/src/*.java"] do
-    compile_java
-    make_jar
-  end
-  
-  desc "compile the java extension and put it into the lib directory"
-  task :java_compile => ["lib/rcovrt.jar"]
-  
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.need_tar = true
-  p.gem_spec = spec  
-end
-
-# extend the gem task to include the java_compile
-if RUBY_PLATFORM == 'java'
-  Rake::Task["pkg"].enhance(["java_compile"])
-end
-
 # vim: set sw=2 ft=ruby:

data/bin/rcov

@@ -265,7 +265,7 @@ EOF
                  "method specified by SELECTOR",
                  "(format: Foo::Bar#method, A::B.method)") do |selector|
         case selector
-        when /([^.]+)(#|\.)(.*)/: options.report_cov_bug_for = selector
+        when /([^.]+)(#|\.)(.*)/ then options.report_cov_bug_for = selector
         else
             raise OptionParser::InvalidArgument, selector
         end

data/doc/readme_for_emacs

@@ -0,0 +1,64 @@
+
+<tt>rcov.el</tt> allows you to use rcov from Emacs conveniently.
+* Run unit tests and jump to uncovered code by <tt>C-x `</tt>.
+* 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 displays +rcov+ window, whose major-mode is compilation-mode.
+Therefore you can jump to uncovered code by <tt>C-x `</tt>.
+
++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 <tt>--text-coverage-diff</tt> 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 <tt>--save</tt> 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 +coverage+ directory and many *.rb files in it.
+Filenames of these Ruby scripts are converted from original path.
+You can browse them by normally <tt>C-x C-f</tt>.
+You can think of <tt>-a</tt> option as <tt>--xrefs</tt> 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.
+
+<tt>Tab</tt> and <tt>M-Tab</tt> goes forward/backward links.
+<tt>Ret</tt> follows selected link.
+
+This feature is useful to read third-party code or to follow control flow.

data/ext/rcovrt/1.9/callsite.c

@@ -0,0 +1,258 @@
+#include <ruby.h>
+#include <ruby/st.h>
+#include <stdlib.h>
+
+static char callsite_hook_set_p;
+
+typedef struct {
+        const char *sourcefile;
+        unsigned int sourceline;
+        VALUE curr_meth;
+} type_def_site;       
+static VALUE caller_info = 0;
+static VALUE method_def_site_info = 0;
+
+static int caller_stack_len = 1;
+
+/*
+ *
+ * callsite hook and associated functions
+ *
+ * */
+
+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_PTR(rb_inspect(curr_meth)),
+                  RSTRING_PTR(rb_inspect(caller_ary)), 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_PTR(rb_inspect(pargs->curr_meth)));
+  / * */
+  
+  return Qnil;
+}
+
+static VALUE
+callsite_custom_backtrace(int lev)
+{
+  ID id;
+  VALUE klass;
+  VALUE klass_path;
+  VALUE eval_string;
+  
+  rb_frame_method_id_and_class(&id, &klass);
+  if (id == ID_ALLOCATOR)
+    return Qnil;
+  if (klass) {
+    if (TYPE(klass) == T_ICLASS) {
+      klass = RBASIC(klass)->klass;
+    }
+    else if (FL_TEST(klass, FL_SINGLETON)) {
+      klass = rb_iv_get(klass, "__attached__");
+    }
+  }
+  // rb_sprintf("\"#<Class:%s>\"", RSTRING_PTR(klass_path))
+  
+  /*
+  klass = class << klass; self end unless klass === eval("self", binding)
+  */
+  
+  klass_path = rb_class_path(klass);
+  VALUE reciever = rb_funcall(rb_binding_new(), rb_intern("eval"), 1, rb_str_new2("self"));
+  if (rb_funcall(klass, rb_intern("=="), 1, reciever) == Qtrue) {
+    klass_path = rb_sprintf("\"#<Class:%s>\"", RSTRING_PTR(klass_path));
+    OBJ_FREEZE(klass_path);
+  }
+  
+  eval_string = rb_sprintf("caller[%d, 1].map do |line|\nmd = /^([^:]*)(?::(\\d+)(?::in `(?:block in )?(.*)'))?/.match(line)\nraise \"Bad backtrace format\" unless md\n[%s, md[3] ? md[3].to_sym : nil, md[1], (md[2] || '').to_i]\nend", lev, RSTRING_PTR(klass_path));
+  return rb_eval_string(RSTRING_PTR(eval_string));
+}
+
+static void
+coverage_event_callsite_hook(rb_event_flag_t event, VALUE 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);
+
+  VALUE klass_path;
+  curr_meth = rb_ary_new();
+   
+  rb_frame_method_id_and_class(&mid, &klass);
+  
+  if (mid == ID_ALLOCATOR)
+    return; //Qnil;
+  if (klass) {
+    if (TYPE(klass) == T_ICLASS) {
+      klass = RBASIC(klass)->klass;
+    }
+    else if (FL_TEST(klass, FL_SINGLETON)) {
+      klass = rb_iv_get(klass, "__attached__");
+    }
+  }
+  
+  /*
+  klass = class << klass; self end unless klass === eval("self", binding)
+  */
+  
+  klass_path = rb_class_path(klass);
+  VALUE reciever = rb_funcall(rb_binding_new(), rb_intern("eval"), 1, rb_str_new2("self"));
+  if (rb_funcall(klass, rb_intern("=="), 1, reciever) == Qtrue) {
+    klass_path = rb_sprintf("#<Class:%s>", RSTRING_PTR(klass_path));
+   OBJ_FREEZE(klass_path);
+  }
+    
+  rb_ary_push(curr_meth, klass_path);
+  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) {
+    type_def_site args;
+
+    args.sourcefile = rb_sourcefile();
+    args.sourceline = rb_sourceline();
+    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;
+          VALUE something = 0;
+          rb_add_event_hook(coverage_event_callsite_hook, 
+                  RUBY_EVENT_CALL, something);
+          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);
+}
+/* vim: set sw=8 expandtab: */

data/ext/rcovrt/1.9/rcovrt.c

@@ -0,0 +1,315 @@
+#include <ruby.h>
+#include <ruby/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; 
+
+/* 
+ *
+ * coverage hook and associated functions 
+ *
+ * */
+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_LEN(arr), sizeof(unsigned int));
+          carray->len = RARRAY_LEN(arr);
+          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()
+{
+  // if @coverage_hook_activated
+  //   COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
+  //   COVER[file][line - 1] ||= 0
+  //   COVER[file][line - 1] += 1
+  // end
+  
+  coverage_increase_counter_uncached(rb_sourcefile(), rb_sourceline(), 1);
+}
+
+
+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_flag_t event, VALUE 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;
+ }
+
+ // printf("NODE? %s , %s\n", rb_id2name(rb_frame_this_func()), RSTRING_PTR(rb_inspect(node)));
+ 
+ sourcefile = rb_sourcefile();
+ sourceline = rb_sourceline();
+ 
+ if (0 == sourceline || 0 == sourcefile) {
+         in_hook--;
+         return;
+ }
+
+ 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 */
+           VALUE holder = 0;
+           rb_add_event_hook(coverage_event_coverage_hook, 
+                        RUBY_EVENT_ALL & ~RUBY_EVENT_C_CALL &
+                        ~RUBY_EVENT_C_RETURN & ~RUBY_EVENT_CLASS, holder);
+          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++)
+         rb_ary_push(rval, UINT2NUM(carray->ptr[i]));
+
+ 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();
+}
+/* vim: set sw=8 expandtab: */

data/ext/rcovrt/extconf.rb

@@ -6,8 +6,18 @@ unless RUBY_PLATFORM == 'java' then
     have_library("gcov", "__gcov_open")
   
     $CFLAGS << " -fprofile-arcs -ftest-coverage"
-    create_makefile("rcovrt")
+    if RUBY_VERSION =~ /1.9/
+      $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+      create_makefile("rcovrt", "1.9/")
+    else
+      create_makefile("rcovrt", "1.8/")
+    end
   else
-    create_makefile("rcovrt")
+    if RUBY_VERSION =~ /1.9/
+      $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+      create_makefile("rcovrt", "1.9/")
+    else
+      create_makefile("rcovrt", "1.8/")
+    end
   end
 end

data/lib/rcov.rb

@@ -917,8 +917,8 @@ class CallSiteAnalyzer < DifferentialAnalyzer
   def expand_name(classname_or_fullname, methodname = nil)
     if methodname.nil?
       case classname_or_fullname
-      when /(.*)#(.*)/: classname, methodname = $1, $2
-      when /(.*)\.(.*)/: classname, methodname = "#<Class:#{$1}>", $2
+      when /(.*)#(.*)/ then classname, methodname = $1, $2
+      when /(.*)\.(.*)/ then classname, methodname = "#<Class:#{$1}>", $2
       else
         raise ArgumentError, "Incorrect method name"
       end

data/lib/rcov/report.rb

@@ -99,8 +99,8 @@ class Formatter # :nodoc:
         @ignore_files = options[:ignore]
         @dont_ignore_files = options[:dont_ignore]
         @sort_criterium = case options[:sort]
-            when :loc : lambda{|fname, finfo| finfo.num_code_lines}
-            when :coverage : lambda{|fname, finfo| finfo.code_coverage}
+            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]
@@ -773,7 +773,7 @@ EOS
                         tr_(:class => color_classes[color_class_index]) {
                             td_ {
                                 case f.name
-                                when "TOTAL":
+                                when "TOTAL" then
                                     t_ { "TOTAL" }
                                 else
                                     a_(:href => mangle_filename(f.name)){ t_ { f.name } }

data/test/call_site_analyzer_test.rb

@@ -73,37 +73,25 @@ class TestCallSiteAnalyzer < Test::Unit::TestCase
 
   def test_basic_defsite_recording
     @a.run_hooked{ @o.f1 }
-    verify_defsite_equal(["./test/assets/sample_03.rb", 3],
-                 @a.defsite("Rcov::Test::Temporary::Sample03", "f1"))
-    verify_defsite_equal(["./test/assets/sample_03.rb", 7],
-                 @a.defsite("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_defsite_equal(["./test/assets/sample_03.rb", 7],
-                 @a.defsite("Rcov::Test::Temporary::Sample03#f2"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 3], @a.defsite("Rcov::Test::Temporary::Sample03", "f1"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 7], @a.defsite("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_defsite_equal(["./test/assets/sample_03.rb", 7], @a.defsite("Rcov::Test::Temporary::Sample03#f2"))
   end
 
   def test_basic_callsite_recording
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
-    #verify_callsites_equal({["./test/sample_03.rb:4:in `f1'"] => 10},
-    #             @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    #verify_callsites_equal({["./test/sample_03.rb:4:in `f1'"] => 10},
-    #             @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03#f2"))
   end
 
   def test_basic_callsite_recording_API
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
     callsites = @a.callsites("Rcov::Test::Temporary::Sample03", "f2")
     callsite = callsites.keys[0]
     #expand path is used here to compensate for differences between JRuby and MRI
@@ -117,12 +105,8 @@ class TestCallSiteAnalyzer < Test::Unit::TestCase
     @a.run_hooked{ @o.class.g1 }
     assert(@a.analyzed_classes.include?("#<Class:Rcov::Test::Temporary::Sample03>"))
     assert_equal(%w[g1 g2], @a.analyzed_methods("#<Class:Rcov::Test::Temporary::Sample03>"))
-    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end,
-                             :g1, "./test/assets/sample_03.rb", 15]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03.g2"))
-    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end,
-                              :g1, "./test/assets/sample_03.rb", 15]] => 10},
-                 @a.callsites("#<Class:Rcov::Test::Temporary::Sample03>","g2"))
+    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end, :g1, "./test/assets/sample_03.rb", 15]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03.g2"))
+    verify_callsites_equal({[[class << Rcov::Test::Temporary::Sample03; self end, :g1, "./test/assets/sample_03.rb", 15]] => 10}, @a.callsites("#<Class:Rcov::Test::Temporary::Sample03>","g2"))
   end
 
 
@@ -130,24 +114,17 @@ class TestCallSiteAnalyzer < Test::Unit::TestCase
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
     @a.run_hooked{ @o.f1 }
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 20},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 20}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
     @a.run_hooked{ @o.f3 }
     assert_equal(%w[f1 f2 f3], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 120,
-                  [[Rcov::Test::Temporary::Sample03, :f3,
-                    "./test/assets/sample_03.rb", 11]]=>100 },
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 120, 
+                            [[Rcov::Test::Temporary::Sample03, :f3, "./test/assets/sample_03.rb", 11]] => 100 }, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_reset
@@ -158,10 +135,7 @@ class TestCallSiteAnalyzer < Test::Unit::TestCase
     end
     assert(@a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
     assert_equal(%w[f1 f2], @a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 10},
-                 @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
-
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, @a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_nested_callsite_recording
@@ -171,37 +145,27 @@ class TestCallSiteAnalyzer < Test::Unit::TestCase
       b.run_hooked { @o.f1 }
       assert(b.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
       assert_equal(%w[f1 f2], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/assets/sample_03.rb", 4]] => 10},
-                   b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
       @o.f1
       assert_equal(%w[f1 f2], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/assets/sample_03.rb", 4]] => 10},
-                   b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 10}, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
 
       assert(a.analyzed_classes.include?("Rcov::Test::Temporary::Sample03"))
       assert_equal(%w[f1 f2], a.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                                "./test/assets/sample_03.rb", 4]] => 20},
-                   a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+      verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 20}, a.callsites("Rcov::Test::Temporary::Sample03", "f2"))
     end
+    
     b.run_hooked{ @o.f3 }
     assert_equal(%w[f1 f2 f3], b.analyzed_methods("Rcov::Test::Temporary::Sample03"))
-    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1,
-                              "./test/assets/sample_03.rb", 4]] => 110,
-                  [[Rcov::Test::Temporary::Sample03, :f3,
-                    "./test/assets/sample_03.rb", 11]]=>100 },
-                 b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
+    verify_callsites_equal({[[Rcov::Test::Temporary::Sample03, :f1, "./test/assets/sample_03.rb", 4]] => 110,
+                            [[Rcov::Test::Temporary::Sample03, :f3, "./test/assets/sample_03.rb", 11]]=>100 }, b.callsites("Rcov::Test::Temporary::Sample03", "f2"))
   end
 
   def test_expand_name
     assert_equal(["Foo", "foo"], @a.instance_eval{ expand_name("Foo#foo") })
     assert_equal(["Foo", "foo"], @a.instance_eval{ expand_name("Foo", "foo") })
-    assert_equal(["#<Class:Foo>", "foo"],
-                 @a.instance_eval{ expand_name("Foo.foo") })
-    assert_equal(["#<Class:Foo>", "foo"],
-                 @a.instance_eval{ expand_name("#<Class:Foo>", "foo") })
+    assert_equal(["#<Class:Foo>", "foo"], @a.instance_eval{ expand_name("Foo.foo") })
+    assert_equal(["#<Class:Foo>", "foo"], @a.instance_eval{ expand_name("#<Class:Foo>", "foo") })
   end
 end

data/test/code_coverage_analyzer_test.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 class TestCodeCoverageAnalyzer < Test::Unit::TestCase
-    LINES = <<-EOF.to_a
+  LINES = <<-EOF.split "\n"
 puts 1
 if foo
   bar
@@ -88,9 +88,9 @@ EOF
     analyzer = Rcov::CodeCoverageAnalyzer.new
     analyzer.run_hooked{ load sample_file }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info) unless PLATFORM =~ /java/
+    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info) unless (defined? PLATFORM && PLATFORM =~ /java/) || RUBY_VERSION =~ /1.9/
     # JRUBY reports an if x==blah as hitting this type of line once, JRUBY also optimizes this stuff so you'd have to run with --debug to get "extra" information.  MRI hits it twice.
-    assert_equal([1, 1, 0, 0, 1, 0, 11], count_info) if PLATFORM =~ /java/
+    assert_equal([1, 2, 0, 0, 1, 0, 11], count_info) if RUBY_VERSION =~ /1.9/
 
     analyzer.reset
     #set_trace_func proc { |event, file, line, id, binding, classname| printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname if (file =~ /sample_02.rb/) }     
@@ -98,13 +98,15 @@ EOF
     sample_file = File.join(File.dirname(__FILE__), "assets/sample_02.rb")
     analyzer.run_hooked{ load sample_file }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([8, 1, 0, 0, 0], count_info)
+    assert_equal([8, 1, 0, 0, 0], count_info) unless RUBY_VERSION =~ /1.9/
+    assert_equal([4, 1, 0, 0, 4], count_info) if RUBY_VERSION =~ /1.9/
 
     analyzer.reset
     assert_equal([], analyzer.analyzed_files)
     analyzer.run_hooked{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
     line_info, cov_info, count_info = analyzer.data(sample_file)
-    assert_equal([0, 1, 1, 1, 0], count_info)
+    assert_equal([0, 1, 1, 1, 0], count_info) unless RUBY_VERSION =~ /1.9/
+    assert_equal([0, 2, 1, 0, 0], count_info) if RUBY_VERSION =~ /1.9/
     analyzer.run_hooked do
       10.times{ Rcov::Test::Temporary::Sample02.foo(1, 1) }
     end

metadata

@@ -1,14 +1,16 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-rcov
 version: !ruby/object:Gem::Version 
-  version: 0.8.1.5.6
+  version: 0.8.1.5.7
 platform: ruby
 authors: 
 - Mauricio Fernandez
+- Chad Humphries
+- Aaron Bedra
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2008-08-29 00:00:00 -07:00
+date: 2009-03-17 00:00:00 -07:00
 default_executable: rcov
 dependencies: []
 
@@ -19,10 +21,10 @@ executables:
 extensions: 
 - ext/rcovrt/extconf.rb
 extra_rdoc_files: 
-- readme_for_api
-- readme_for_rake
-- readme_for_rant
-- readme_for_vim
+- doc/readme_for_api
+- doc/readme_for_rake
+- doc/readme_for_rant
+- doc/readme_for_vim
 files: 
 - bin/rcov
 - lib/rcov.rb
@@ -31,19 +33,21 @@ files:
 - lib/rcov/version.rb
 - lib/rcov/rant.rb
 - lib/rcov/report.rb
-- lib/rcov/rexml_extensions.rb
 - lib/rcov/rcovtask.rb
 - ext/rcovrt/extconf.rb
-- ext/rcovrt/rcovrt.c
-- ext/rcovrt/callsite.c
+- ext/rcovrt/1.8/rcovrt.c
+- ext/rcovrt/1.9/rcovrt.c
+- ext/rcovrt/1.8/callsite.c
+- ext/rcovrt/1.9/callsite.c
 - LEGAL
 - LICENSE
 - Rakefile
 - Rantfile
-- readme_for_rake
-- readme_for_rant
-- readme_for_vim
-- readme_for_api
+- doc/readme_for_rake
+- doc/readme_for_rant
+- doc/readme_for_vim
+- doc/readme_for_emacs
+- doc/readme_for_api
 - THANKS
 - test/functional_test.rb
 - test/file_statistics_test.rb
@@ -57,14 +61,13 @@ files:
 - test/turn_off_rcovrt.rb
 - test/call_site_analyzer_test.rb
 - test/assets/sample_05.rb
-- test/rexml_test.rb
-- rcov.vim
-- rcov.el
+- editor-extensions/rcov.vim
+- editor-extensions/rcov.el
 - setup.rb
 - BLURB
 - CHANGES
 has_rdoc: true
-homepage: http://eigenclass.org/hiki.rb?rcov
+homepage: http://github.com/spicycode/rcov
 post_install_message: 
 rdoc_options: 
 - --main

data/lib/rcov/rexml_extensions.rb

@@ -1,44 +0,0 @@
-require 'rexml/document'
-require 'rexml/formatters/pretty'
-
-module Rcov
-  module REXMLExtensions
-  
-    def self.fix_pretty_formatter_wrap
-      REXML::Formatters::Pretty.class_eval do
-        include PrettyFormatterWrapFix
-      end
-    end
-
-    # Fix for this bug: http://clint-hill.com/2008/10/02/a-bug-in-ruby-did-i-just-find-that/
-    # Also known from this fun exception:
-    #
-    #    /usr/local/ruby/lib/ruby/1.8/rexml/formatters/pretty.rb:131:in
-    #    `[]': no implicit conversion from nil to integer (TypeError)
-    #
-    # This bug was fixed in Ruby with this changeset http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=19487
-    # ...which should mean that this bug only affects Ruby 1.8.6.  The latest stable version of 1.8.7 (and up) should be fine.
-    module PrettyFormatterWrapFix
-
-      def self.included(base)
-        base.class_eval do
-          def wrap(string, width)
-            # Recursively wrap string at width.
-            return string if string.length <= width
-            place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
-            return string if place.nil?
-            return string[0,place] + "\n" + wrap(string[place+1..-1], width)
-          end
-        end
-      end
-    
-    end
-  
-    def self.init!
-      if RUBY_VERSION == "1.8.6"
-        fix_pretty_formatter_wrap
-      end
-    end
-  end
-  
-end

data/test/rexml_test.rb

@@ -1,23 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'rcov/rexml_extensions'
-
-class TestRexml < Test::Unit::TestCase
-
-  def test_wrap_with_long_lines_without_spaces_should_not_break_wrap
-    Rcov::REXMLExtensions.fix_pretty_formatter_wrap
-    pretty_formatter = ::REXML::Formatters::Pretty.new
-    long_string = "this-is-a-long-string-without-any-spaces-to-try-to-break-rexml-formatter-and-it-is-over-100-characters-long"
-    pretty_formatter.instance_eval { wrap(long_string, 100) } # avoid send, it can't bypass private methods in ruby19
-  end
-  
-  def test_wrap_original_behavior_should_be_preserved
-    pretty_formatter = REXML::Formatters::Pretty.new
-    str = "This string should be wrapped at 40 characters"
-    pretty_formatter.instance_eval do
-      str = wrap(str, 40)
-    end # avoid send, it can't bypass private methods in ruby19
-    assert_equal("This string should be wrapped at 40\ncharacters", str)
-    
-  end
-  
-end