gigpark-rcov 0.8.6

data/ext/rcovrt/1.9/rcovrt.c

@@ -0,0 +1,264 @@
+#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; 
+
+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() {
+  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;
+  }
+  
+  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();
+}

data/ext/rcovrt/extconf.rb

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

data/lib/rcov.rb

@@ -0,0 +1,33 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# See LICENSE for licensing information.
+
+# NOTE: if you're reading this in the XHTML code coverage report generated by
+# rcov, you'll notice that only code inside methods is reported as covered,
+# very much like what happens when you run it with --test-unit-only.
+# This is due to the fact that we're running rcov on itself: the code below is
+# already loaded before coverage tracing is activated, so only code inside
+# methods is actually executed under rcov's inspection.
+
+require 'rcov/version'
+require 'rcov/formatters'
+require 'rcov/coverage_info'
+require 'rcov/file_statistics'
+require 'rcov/differential_analyzer'
+require 'rcov/code_coverage_analyzer'
+require 'rcov/call_site_analyzer'
+
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+module Rcov
+  # TODO: Move to Ruby 1.8.6 Backport module
+  unless RUBY_VERSION =~ /1.9/  
+    class ::String
+      def lines
+        map
+      end
+    end
+  end
+
+  autoload :RCOV__, "rcov/lowlevel.rb"
+end

data/lib/rcov/call_site_analyzer.rb

@@ -0,0 +1,225 @@
+module Rcov
+  # A CallSiteAnalyzer can be used to obtain information about:
+  # * where a method is defined ("+defsite+")
+  # * where a method was called from ("+callsite+")
+  #
+  # == Example
+  # <tt>example.rb</tt>:
+  #  class X
+  #    def f1; f2 end
+  #    def f2; 1 + 1 end
+  #    def f3; f1 end
+  #  end
+  #
+  #  analyzer = Rcov::CallSiteAnalyzer.new
+  #  x = X.new
+  #  analyzer.run_hooked do 
+  #    x.f1 
+  #  end
+  #  # ....
+  #  
+  #  analyzer.run_hooked do 
+  #    x.f3
+  #    # the information generated in this run is aggregated
+  #    # to the previously recorded one
+  #  end
+  #
+  #  analyzer.analyzed_classes        # => ["X", ... ]
+  #  analyzer.methods_for_class("X")  # => ["f1", "f2", "f3"]
+  #  analyzer.defsite("X#f1")         # => DefSite object
+  #  analyzer.callsites("X#f2")       # => hash with CallSite => count
+  #                                   #    associations
+  #  defsite = analyzer.defsite("X#f1")
+  #  defsite.file                     # => "example.rb"
+  #  defsite.line                     # => 2
+  #
+  # You can have several CallSiteAnalyzer objects at a time, and it is
+  # possible to nest the #run_hooked / #install_hook/#remove_hook blocks: each
+  # analyzer will manage its data separately. Note however that no special
+  # provision is taken to ignore code executed "inside" the CallSiteAnalyzer
+  # class. 
+  #
+  # +defsite+ information is only available for methods that were called under
+  # the inspection of the CallSiteAnalyzer, i.o.w. you will only have +defsite+
+  # information for those methods for which callsite information is
+  # available.
+  class CallSiteAnalyzer < DifferentialAnalyzer
+    # A method definition site.
+    class DefSite < Struct.new(:file, :line)
+    end
+
+    # 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(:backtrace)
+      # The depth of a CallSite is the number of stack frames
+      # whose information is included in the CallSite object.
+      def depth
+        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)
+        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)
+        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)
+        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
+
+    @hook_level = 0
+    # defined this way instead of attr_accessor so that it's covered
+    def self.hook_level      # :nodoc:
+      @hook_level
+    end
+
+    def self.hook_level=(x)  # :nodoc:
+      @hook_level = x
+    end
+
+    def initialize
+      super(:install_callsite_hook, :remove_callsite_hook,
+            :reset_callsite)
+    end
+
+    # Classes whose methods have been called.
+    # Returns an array of strings describing the classes (just klass.to_s for
+    # each of them). Singleton classes are rendered as:
+    #   #<Class:MyNamespace::MyClass>
+    def analyzed_classes
+      raw_data_relative.first.keys.map{|klass, meth| klass}.uniq.sort
+    end
+
+    # Methods that were called for the given class. See #analyzed_classes for
+    # the notation used for singleton classes.
+    # Returns an array of strings or +nil+
+    def methods_for_class(classname)
+      a = raw_data_relative.first.keys.select{|kl,_| kl == classname}.map{|_,meth| meth}.sort
+      a.empty? ? nil : a
+    end
+    alias_method :analyzed_methods, :methods_for_class
+
+    # Returns a hash with <tt>CallSite => call count</tt> associations or +nil+
+    # Can be called in two ways:
+    #   analyzer.callsites("Foo#f1")         # instance method
+    #   analyzer.callsites("Foo.g1")         # singleton method of the class
+    # or
+    #   analyzer.callsites("Foo", "f1")
+    #   analyzer.callsites("#<class:Foo>", "g1")
+    def callsites(classname_or_fullname, methodname = nil)
+      rawsites = raw_data_relative.first[expand_name(classname_or_fullname, methodname)]
+      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 do |backtrace, count|
+        ret[CallSite.new(backtrace)] = count
+      end
+      ret
+    end
+
+    # Returns a DefSite object corresponding to the given method
+    # Can be called in two ways:
+    #   analyzer.defsite("Foo#f1")         # instance method
+    #   analyzer.defsite("Foo.g1")         # singleton method of the class
+    # or
+    #   analyzer.defsite("Foo", "f1")
+    #   analyzer.defsite("#<class:Foo>", "g1")
+    def defsite(classname_or_fullname, methodname = nil)
+      file, line = raw_data_relative[1][expand_name(classname_or_fullname, methodname)]
+      return nil unless file && line
+      DefSite.new(file, line)
+    end
+
+    private
+
+    def expand_name(classname_or_fullname, methodname = nil)
+      if methodname.nil?
+        case classname_or_fullname
+        when /(.*)#(.*)/ then classname, methodname = $1, $2
+        when /(.*)\.(.*)/ then classname, methodname = "#<Class:#{$1}>", $2
+        else
+          raise ArgumentError, "Incorrect method name"
+        end
+
+        return [classname, methodname]
+      end
+
+      [classname_or_fullname, methodname]
+    end
+
+    def data_default; [{}, {}] end
+
+    def raw_data_absolute
+      raw, method_def_site = RCOV__.generate_callsite_info
+      ret1 = {}
+      ret2 = {}
+      raw.each_pair do |(klass, method), hash|
+        begin  
+          key = [klass.to_s, method.to_s]
+          ret1[key] = hash.clone #Marshal.load(Marshal.dump(hash))
+          ret2[key] = method_def_site[[klass, method]]
+        #rescue Exception
+        end
+      end
+
+      [ret1, ret2]
+    end
+
+    def aggregate_data(aggregated_data, delta)
+      callsites1, defsites1 = aggregated_data
+      callsites2, defsites2 = delta
+    
+      callsites2.each_pair do |(klass, method), hash|
+        dest_hash = (callsites1[[klass, method]] ||= {})
+        hash.each_pair do |callsite, count|
+          dest_hash[callsite] ||= 0
+          dest_hash[callsite] += count
+        end
+      end
+
+      defsites1.update(defsites2)
+    end
+
+    def compute_raw_data_difference(first, last)
+      difference = {}
+      default = Hash.new(0)
+
+      callsites1, defsites1 = *first
+      callsites2, defsites2 = *last
+
+      callsites2.each_pair do |(klass, method), hash|
+        old_hash = callsites1[[klass, method]] || default
+        hash.each_pair do |callsite, count|
+          diff = hash[callsite] - (old_hash[callsite] || 0)
+          if diff > 0
+            difference[[klass, method]] ||= {}
+            difference[[klass, method]][callsite] = diff
+          end
+        end
+      end
+
+      [difference, defsites1.update(defsites2)]
+    end
+  end
+end