+ coverage compat

Author: palkan

Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 
 gem "debug", platform: :mri
 gem "bootsnap", platform: [:mri, :truffleruby]
+gem "simplecov"
 
 gemspec
 

lib/require-hooks/api.rb

@@ -14,6 +14,7 @@ def initialize(patterns: nil, exclude_patterns: nil)
       @hijack_load = []
 
       @empty = nil
+      @readonly = nil
     end
 
     def to_key
@@ -31,6 +32,12 @@ def empty?
       @empty = @around_load.empty? && @source_transform.empty? && @hijack_load.empty?
     end
 
+    def readonly?
+      return @readonly unless @readonly.nil?
+
+      @readonly = @source_transform.empty? && @hijack_load.empty?
+    end
+
     def source_transform?
       @source_transform.any?
     end
@@ -162,5 +169,25 @@ def context_for(path)
 
       ctx
     end
+
+    # Hack to enable coverage for hooked files.
+    # Requires eval coverage to be on.
+    def setup_path_coverage(path, contents = nil)
+      return unless defined?(Coverage) && Coverage.running?
+
+      return unless eval_coverage_enabled?
+
+      Kernel.eval("\n" * (contents || File.read(path)).lines.size, TOPLEVEL_BINDING, path, 1) # rubocop:disable Style/EvalWithLocation,Security/Eval
+    end
+
+    private
+
+    def eval_coverage_enabled?
+      return @eval_coverage_enabled if defined?(@eval_coverage_enabled)
+      probe_path = File.join(__dir__, "coverage_probe.rb")
+      Kernel.eval("proc { |val| val }", TOPLEVEL_BINDING, probe_path, 1) # rubocop:disable Style/EvalWithLocation
+
+      @eval_coverage_enabled = Coverage.peek_result.key?(probe_path)
+    end
   end
 end

lib/require-hooks/mode/bootsnap.rb

@@ -35,7 +35,29 @@ def load_iseq(path)
 
         ctx.run_around_load_callbacks(path) do
           iseq = super
-          return unless iseq
+          # Bootsnap returns nil when the coverage is on,
+          unless iseq
+            next unless defined?(Coverage) && Coverage.running?
+
+            iseq =
+              if ctx.source_transform? || ctx.hijack?
+                new_contents = ctx.perform_source_transform(path)
+
+                RequireHooks.setup_path_coverage(path, new_contents)
+
+                hijacked = ctx.try_hijack_load(path, new_contents)
+
+                if hijacked
+                  raise TypeError, "Unsupported bytecode format for #{path}: #{hijack.class}" unless hijacked.is_a?(::RubyVM::InstructionSequence)
+                  hijacked
+                elsif new_contents
+                  RubyVM::InstructionSequence.compile(new_contents, path, path, 1)
+                end
+              else
+                RequireHooks.setup_path_coverage(path)
+                RubyVM::InstructionSequence.compile_file(path)
+              end
+          end
 
           iseq.eval
           EMPTY_ISEQ

lib/require-hooks/mode/kernel_patch.rb

@@ -12,11 +12,18 @@ def load(path, ctx: nil)
           next load_without_require_hooks(path) unless ctx.source_transform? || ctx.hijack?
 
           new_contents = ctx.perform_source_transform(path)
+
           hijacked = ctx.try_hijack_load(path, new_contents)
 
-          return try_evaluate(path, hijacked) if hijacked
+          if hijacked
+            RequireHooks.setup_path_coverage(path, new_contents)
+
+            return try_evaluate(path, hijacked)
+          end
 
           if new_contents
+            RequireHooks.setup_path_coverage(path, new_contents)
+
             evaluate(new_contents, path)
             true
           else

lib/require-hooks/mode/load_iseq.rb

@@ -14,6 +14,9 @@ def load_iseq(path)
         iseq =
           if ctx.source_transform? || ctx.hijack?
             new_contents = ctx.perform_source_transform(path)
+
+            RequireHooks.setup_path_coverage(path, new_contents)
+
             hijacked = ctx.try_hijack_load(path, new_contents)
 
             if hijacked
@@ -24,7 +27,10 @@ def load_iseq(path)
             end
           end
 
+        RequireHooks.setup_path_coverage(path)
+
         iseq ||= (defined?(super) ? super : RubyVM::InstructionSequence.compile_file(path))
+
         iseq.eval
         EMPTY_ISEQ
       end

spec/require-hooks/bootsnap_spec.rb

@@ -50,4 +50,19 @@
       err.should include("bootsnap-syntax-error.rb:1")
     end
   end
+
+  context "coverage" do
+    # Eval coverage is only avaiable from 3.2
+    next unless RUBY_VERSION >= "3.2.0"
+
+    it "does not break coverage tracking" do
+      run_ruby(
+        File.join(__dir__, "fixtures", "coverage.rb").to_s,
+        env: {"BOOTSNAP" => "1"}
+      ) do |_status, output, _err|
+        output.should include("./hello.rb: [")
+        output.should include("./coverable.rb: [1, 1, 1, nil, nil, nil, 1]\n")
+      end
+    end
+  end
 end

spec/require-hooks/coverage_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../support/command_testing"
+
+describe "require-hooks vs coverage" do
+  # Eval coverage is only avaiable from 3.2
+  next unless RUBY_VERSION >= "3.2.0"
+  # Truffle doesn't support it either
+  next if defined?(TruffleRuby)
+
+  it "does not break coverage tracking" do
+    run_ruby(
+      File.join(__dir__, "fixtures", "coverage.rb").to_s
+    ) do |_status, output, _err|
+      output.should include("./hello.rb: [")
+      output.should include("./coverable.rb: [1, 1, 1, nil, nil, nil, 1]\n")
+    end
+  end
+end

spec/require-hooks/fixtures/coverable.rb

@@ -0,0 +1,7 @@
+class Coverable
+  def self.call
+    "cover up"
+  end
+end
+
+Coverable.call

spec/require-hooks/fixtures/coverage.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+$events = []
+
+if ENV["BOOTSNAP"]
+  require "bootsnap"
+  Bootsnap.setup(
+    cache_dir: File.join(__dir__, "tmp/cache"),
+    development_mode: true,
+    load_path_cache: true,
+    compile_cache_iseq: true,
+    compile_cache_yaml: true
+  )
+end
+
+require "simplecov"
+# Prevent the coverage/ creation
+SimpleCov.at_exit {}
+SimpleCov.start do
+  enable_coverage_for_eval
+end
+
+require "require-hooks/setup"
+
+RequireHooks.around_load(patterns: ["*/fixtures/coverable.rb"]) do |path, &block|
+  $events << "before-hook"
+  block.call.tap { $events << "after-hook" }
+end
+
+load File.join(__dir__, "hello.rb")
+load File.join(__dir__, "coverable.rb")
+
+puts Coverage.peek_result.map { |k, v| "#{k.gsub(__dir__, ".")}: #{v[:lines].inspect}" }.join("\n")