relevance-rcov 0.9.3-java

data/ext/java/src/CoverageHook.java

@@ -0,0 +1,117 @@
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.RubyEvent;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class CoverageHook extends RcovHook {
+  
+  private static CoverageHook hook;
+  
+  public static CoverageHook getCoverageHook() {
+    if (hook == null) {
+      hook = new CoverageHook();
+    }
+    
+    return hook;
+  }
+  
+  private boolean active;
+  private RubyHash cover;
+  
+  private CoverageHook() {
+    super();
+  }
+  
+  public boolean isActive() {
+    return active;
+  }
+  
+  public void setActive(boolean active) {
+    this.active = active;
+  }
+  
+  public void eventHandler(ThreadContext context, String event, String file, int line, String name, IRubyObject type) {
+    //Line numbers are 1s based.  Arrays are zero based.  We need to compensate for that.
+    line -= 1;
+    
+    // Make sure that we have SCRIPT_LINES__ and it's a hash
+    RubyHash scriptLines = getScriptLines(context.getRuntime());
+    if (scriptLines == null || !scriptLines.containsKey(file)) {
+      return;
+    }
+    
+    // make sure the file's source lines are in SCRIPT_LINES__
+    cover = getCover(context.getRuntime());
+    RubyArray lines = (RubyArray) scriptLines.get(file);
+    if (lines == null || cover == null){
+      return;
+    }
+    
+    // make sure file's counts are in COVER and set to zero
+    RubyArray counts = (RubyArray) cover.get(file);
+    if (counts == null) {
+      counts = context.getRuntime().newArray();
+      for (int i = 0; i < lines.size(); i++) {
+        counts.add(Long.valueOf(0));
+      }
+      cover.put(file, counts);
+    }
+    
+    // in the case of code generation (one example is instance_eval for routes optimization)
+    // We could get here and see that we are not matched up with what we expect
+    if (counts.size() <= line ) {
+      for (int i=counts.size(); i<= line; i++) {
+        counts.add(Long.valueOf(0));
+      }
+    }
+    
+    if (!context.isWithinTrace()) {
+      try {
+        context.setWithinTrace(true);
+        // update counts in COVER
+        Long count = (Long) counts.get(line);
+        if (count == null) {
+          count = Long.valueOf(0);
+        }
+        count = Long.valueOf(count.longValue() + 1);
+        counts.set(line , count);
+      }
+      finally{
+        context.setWithinTrace(false);
+      }
+    }
+  }
+  
+  public boolean isInterestedInEvent(RubyEvent event) {
+    return event == RubyEvent.CALL || event == RubyEvent.LINE || event == RubyEvent.RETURN || event == RubyEvent.CLASS || event == RubyEvent.C_RETURN || event == RubyEvent.C_CALL;
+  }
+  
+  /*
+   * Returns the COVER hash, setting up the COVER constant if necessary.
+   * @param runtime
+   * @return
+   */
+  public RubyHash getCover(Ruby runtime) {
+    if (cover == null) {
+      cover = RubyHash.newHash(runtime);
+    }
+    
+    return cover;
+  }
+  
+  public RubyHash getScriptLines(Ruby runtime) {
+    IRubyObject scriptLines = runtime.getObject().getConstantAt("SCRIPT_LINES__");
+    if (scriptLines instanceof RubyHash) {
+      return (RubyHash) scriptLines;
+    } else {
+      return null;
+    }
+  }
+  
+  public IRubyObject resetCoverage(Ruby runtime) {
+    getCover(runtime).clear();
+    return runtime.getNil();
+  }
+}

data/ext/java/src/RcovHook.java

@@ -0,0 +1,9 @@
+import org.jruby.runtime.EventHook;
+
+public abstract class RcovHook extends EventHook {
+  /** returns true if the hook is set */
+  abstract boolean isActive();
+
+  /** used to mark the hook set or unset */
+  abstract void setActive(boolean active);
+}

data/ext/java/src/RcovrtService.java

@@ -0,0 +1,130 @@
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyObjectAdapter;
+import org.jruby.RubySymbol;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.javasupport.JavaEmbedUtils;
+import org.jruby.javasupport.JavaUtil;
+
+public class RcovrtService implements BasicLibraryService {
+  
+  private static RubyObjectAdapter rubyApi;
+  
+  public boolean basicLoad(Ruby runtime) {
+    RubyModule rcov = runtime.getOrCreateModule("Rcov");
+    RubyModule rcov__ = runtime.defineModuleUnder("RCOV__", rcov);
+    IRubyObject sl = runtime.getObject().getConstantAt("SCRIPT_LINES__");
+    
+    if (sl == null) {
+        runtime.getObject().setConstant("SCRIPT_LINES__", RubyHash.newHash(runtime));
+    }
+    
+    rubyApi = JavaEmbedUtils.newObjectAdapter();
+    rcov__.defineAnnotatedMethods(RcovrtService.class);
+    return true;
+  }
+  
+  @JRubyMethod(name="reset_callsite", meta = true)
+  public static IRubyObject resetCallsite(IRubyObject recv) {
+    CallsiteHook hook = CallsiteHook.getCallsiteHook();
+    if (hook.isActive()) {
+      throw RaiseException.createNativeRaiseException(recv.getRuntime(),
+        new RuntimeException("Cannot reset the callsite info in the middle of a traced run."));
+    }
+    return hook.resetDefsites();
+  }
+  
+  @JRubyMethod(name="reset_coverage", meta = true)
+  public static IRubyObject resetCoverage(IRubyObject recv) {
+    CoverageHook hook = CoverageHook.getCoverageHook();
+    if (hook.isActive()) {
+      throw RaiseException.createNativeRaiseException(recv.getRuntime(),
+        new RuntimeException("Cannot reset the coverage info in the middle of a traced run."));
+    }
+    return hook.resetCoverage(recv.getRuntime());
+  }
+  
+  @JRubyMethod(name="remove_coverage_hook", meta = true)
+  public static IRubyObject removeCoverageHook(IRubyObject recv) {
+    return removeRcovHook(recv, CoverageHook.getCoverageHook());
+  }
+  
+  @JRubyMethod(name="install_coverage_hook", meta = true)
+  public static IRubyObject installCoverageHook(IRubyObject recv) {
+    return installRcovHook(recv, CoverageHook.getCoverageHook());
+  }
+  
+  /*
+     TODO: I think this is broken. I'm not sure why, but recreating
+     cover all the time seems bad.
+  */
+  @JRubyMethod(name="generate_coverage_info", meta = true)
+  public static IRubyObject generateCoverageInfo(IRubyObject recv) {
+    Ruby run = recv.getRuntime();
+    RubyHash cover = (RubyHash)CoverageHook.getCoverageHook().getCover(run);
+    RubyHash xcover = RubyHash.newHash(run);
+    RubyArray keys = cover.keys();
+    RubyArray temp;
+    ThreadContext  ctx = run.getCurrentContext();
+    for (int i=0; i < keys.length().getLongValue(); i++) {
+      IRubyObject key = keys.aref(JavaUtil.convertJavaToRuby(run, Long.valueOf(i)));
+      temp = ((RubyArray)cover.op_aref(ctx, key)).aryDup();
+      xcover.op_aset(ctx,key, temp);
+    }
+    RubyModule rcov__ = (RubyModule) recv.getRuntime().getModule("Rcov").getConstant("RCOV__");
+    
+    if (rcov__.const_defined_p(ctx, RubySymbol.newSymbol(recv.getRuntime(), "COVER")).isTrue()) {
+        rcov__.remove_const(ctx, recv.getRuntime().newString("COVER"));
+    }
+    rcov__.defineConstant( "COVER", xcover );
+    
+    return xcover;
+  }
+  
+  @JRubyMethod(name="remove_callsite_hook", meta = true)
+  public static IRubyObject removeCallsiteHook(IRubyObject recv) {
+    return removeRcovHook( recv, CallsiteHook.getCallsiteHook() );
+  }
+  
+  @JRubyMethod(name="install_callsite_hook", meta = true)
+  public static IRubyObject installCallsiteHook(IRubyObject recv) {
+    return installRcovHook( recv, CallsiteHook.getCallsiteHook() );
+  }
+  
+  @JRubyMethod(name="generate_callsite_info", meta = true)
+  public static IRubyObject generateCallsiteInfo(IRubyObject recv) {
+    return CallsiteHook.getCallsiteHook().getCallsiteInfo( recv.getRuntime() ).dup();
+  }
+  
+  @JRubyMethod(name="ABI", meta = true)
+  public static IRubyObject getAbi(IRubyObject recv) {
+    RubyArray ary = recv.getRuntime().newArray();
+    ary.add(RubyFixnum.int2fix( recv.getRuntime(), 2L));
+    ary.add(RubyFixnum.int2fix( recv.getRuntime(), 0L));
+    ary.add(RubyFixnum.int2fix( recv.getRuntime(), 0L));
+    return ary;
+  }
+  
+  private static IRubyObject removeRcovHook(IRubyObject recv, RcovHook hook) {
+    hook.setActive(false);
+    recv.getRuntime().removeEventHook(hook);
+    return recv.getRuntime().getFalse();
+  }
+  
+  private static IRubyObject installRcovHook( IRubyObject recv, RcovHook hook ) {
+    if (!hook.isActive()) {
+      hook.setActive(true);
+      recv.getRuntime().addEventHook(hook);
+      return recv.getRuntime().getTrue();
+    } else {
+      return recv.getRuntime().getFalse();
+    }
+  }
+}

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