Bump minimum Ruby to 3.1 and intercept fork via Process._fork

Process._fork is the official extension point: Kernel#fork,
Process.fork, IO.popen("-") all funnel through it, and prepended
modules compose with other libraries. Updates gemspec, .rubocop.yml
TargetRubyVersion, the stable.yml matrix, and the README ruby-version
blurb. The autocorrects (RedundantFreeze on regex literals,
Naming/BlockForwarding to anonymous &) ride along.

Author: sferik

.github/workflows/stable.yml

@@ -14,8 +14,6 @@ jobs:
 
       matrix:
         ruby-version:
-          - '2.7'
-          - '3.0'
           - '3.1'
           - '3.2'
           - '3.3'

.rubocop.yml

@@ -16,7 +16,7 @@ AllCops:
     - "tmp/**/*"
     - "vendor/bundle/**/*"
     - "vendor/bundle/**/.*"
-  TargetRubyVersion: 2.7
+  TargetRubyVersion: 3.1
   NewCops: enable
 
 Layout/AccessModifierIndentation:

README.md

@@ -937,7 +937,7 @@ SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
 
 ## Ruby version compatibility
 
-SimpleCov is built in [Continuous Integration] on Ruby 2.5+ and JRuby 9.4+.
+SimpleCov is built in [Continuous Integration] on Ruby 3.1+ and JRuby 9.4+.
 
 Note for JRuby => You need to pass JRUBY_OPTS="--debug" or create .jrubyrc and add debug.fullTrace=true
 

features/step_definitions/web_steps.rb

@@ -2,8 +2,8 @@
 
 # Cucumber world helpers for scoping Capybara assertions to a selector.
 module WithinHelpers
-  def with_scope(locator, &block)
-    locator ? within(locator, &block) : yield
+  def with_scope(locator, &)
+    locator ? within(locator, &) : yield
   end
 end
 World(WithinHelpers)

lib/simplecov.rb

@@ -43,12 +43,12 @@ class << self
     #
     # Please check out the RDoc for SimpleCov::Configuration to find about available config options
     #
-    def start(profile = nil, &block)
+    def start(profile = nil, &)
       require "coverage"
       warn_if_jruby_full_trace_disabled
-      initial_setup(profile, &block)
+      initial_setup(profile, &)
       require_relative "simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
-                                              ::Process.respond_to?(:fork)
+                                              ::Process.respond_to?(:_fork)
 
       make_parallel_tests_available
 
@@ -336,7 +336,7 @@ def initial_setup(profile, &block)
 
     #
     # Trigger Coverage.start with the configured criteria. Every supported
-    # runtime (CRuby >= 2.7, JRuby >= 9.4, TruffleRuby >= 22) accepts the
+    # runtime (CRuby >= 3.1, JRuby >= 9.4, TruffleRuby >= 22) accepts the
     # criteria-hash form, so no compatibility fallback is needed.
     #
     def start_coverage_measurement

lib/simplecov/configuration.rb

@@ -408,17 +408,17 @@ def refuse_coverage_drop(*criteria)
     # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
     #   on how to define your own filter classes
     #
-    def add_filter(filter_argument = nil, &filter_proc)
-      filters << parse_filter(filter_argument, &filter_proc)
+    def add_filter(filter_argument = nil, &)
+      filters << parse_filter(filter_argument, &)
     end
 
     #
     # Define a group for files. Works similar to add_filter, only that the first
     # argument is the desired group name and files PASSING the filter end up in the group
     # (while filters exclude when the filter is applicable).
     #
-    def add_group(group_name, filter_argument = nil, &filter_proc)
-      groups[group_name] = parse_filter(filter_argument, &filter_proc)
+    def add_group(group_name, filter_argument = nil, &)
+      groups[group_name] = parse_filter(filter_argument, &)
     end
 
     SUPPORTED_COVERAGE_CRITERIA = %i[line branch method oneshot_line].freeze

lib/simplecov/directive.rb

@@ -38,15 +38,15 @@ module SimpleCov
   class Directive
     CATEGORIES = %i[line branch method].freeze
 
-    CATEGORY_PATTERN = "(?:#{CATEGORIES.join('|')})"
-    CATEGORIES_PATTERN = "(?:#{CATEGORY_PATTERN}(?:\\s*,\\s*#{CATEGORY_PATTERN})*)"
+    CATEGORY_PATTERN = "(?:#{CATEGORIES.join('|')})".freeze
+    CATEGORIES_PATTERN = "(?:#{CATEGORY_PATTERN}(?:\\s*,\\s*#{CATEGORY_PATTERN})*)".freeze
     PATTERN = /
       \#\s*simplecov\s*:\s*
       (?<mode>disable|enable)\b
       (?:\s+(?<categories>#{CATEGORIES_PATTERN}))?
       .*?
       \s*\z
-    /x.freeze
+    /x
 
     attr_reader :line_number, :mode, :categories
 

lib/simplecov/lines_classifier.rb

@@ -10,8 +10,8 @@ class LinesClassifier
     RELEVANT = 0
     NOT_RELEVANT = nil
 
-    WHITESPACE_LINE = /^\s*$/.freeze
-    COMMENT_LINE = /^\s*#/.freeze
+    WHITESPACE_LINE = /^\s*$/
+    COMMENT_LINE = /^\s*#/
     WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
 
     def self.no_cov_line

lib/simplecov/process.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
-# Patches `Process.fork` so child processes inherit SimpleCov's coverage
-# tracking when `SimpleCov.enable_for_subprocesses?` is set.
-module Process
-  class << self
-    def fork_with_simplecov(&block)
-      if defined?(SimpleCov) && SimpleCov.running
-        fork_without_simplecov do
-          SimpleCov.at_fork.call(Process.pid)
-          yield if block
-        end
-      else
-        fork_without_simplecov(&block)
-      end
-    end
+# Hooks `Process._fork` (Ruby 3.1+) so child processes inherit SimpleCov's
+# coverage tracking when `SimpleCov.enable_for_subprocesses?` is set.
+#
+# `Process._fork` is the official extension point: `Kernel#fork`,
+# `Process.fork`, `IO.popen("-")`, and similar all funnel through it.
+# Hooking `_fork` (instead of redefining `Process.fork`) composes
+# correctly with other libraries doing the same — they each prepend
+# their own module and chain via `super`.
 
-    alias fork_without_simplecov fork
-    alias fork fork_with_simplecov
+module SimpleCov
+  # Prepended onto Process's singleton class so every fork — direct or
+  # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
+  # the child.
+  module ProcessForkHook
+    def _fork
+      pid = super
+      SimpleCov.at_fork.call(::Process.pid) if pid.zero? && defined?(SimpleCov) && SimpleCov.running
+      pid
+    end
   end
 end
+
+Process.singleton_class.prepend(SimpleCov::ProcessForkHook)

lib/simplecov/result_adapter.rb

@@ -37,7 +37,7 @@ def adapt
     # Address widths vary by runtime (32-bit hosts: 8 hex chars; 64-bit
     # CRuby: 16; some JVM/TruffleRuby formats may differ), so match any
     # length of hex digits and collapse to a single placeholder.
-    ADDRESS_PATTERN = /0x\h+/.freeze
+    ADDRESS_PATTERN = /0x\h+/
     private_constant :ADDRESS_PATTERN
 
     ADDRESS_PLACEHOLDER = "0x0"