Tighten Ruby idioms across several files

Switch the project-root path check in UselessResultsRemover from `=~`
to `match?` (real boolean, skips `$~` capture) and rebuild the prefix
regex with `chomp + append` rather than a mutating `+= unless`. Rewrite
`ResultAdapter#adapt` as a `to_h` block over the input hash with an
`adapt_one` helper, separating the pre-0.18 array-shape path from the
modern hash-shape path.

Replace `!ENV.fetch("NAME", nil).nil?` with `ENV.key?("NAME")` across
the parallel-adapter detection paths, fold the double `key?` check in
`Profiles#fetch_proc` into one, read each env var once in
`CommandGuesser#parallel_data`, and replace the manual `each` plus
early `return` in `cli/coverage.rb`'s `lookup` with `Hash#find`. All
behavior-preserving.

Author: sferik

lib/simplecov/cli/coverage.rb

@@ -59,10 +59,7 @@ def locate_match(opts, stderr)
       def lookup(coverage_hash, path)
         absolute = File.expand_path(path)
         suffix   = "/#{path}"
-        coverage_hash.each do |fname, payload|
-          return [fname, payload] if fname == absolute || fname == path || fname.end_with?(suffix)
-        end
-        nil
+        coverage_hash.find { |fname, _| fname == absolute || fname == path || fname.end_with?(suffix) }
       end
 
       def emit(match, opts, stdout)

lib/simplecov/command_guesser.rb

@@ -19,13 +19,17 @@ def guess
 
     private
 
+      # When parallel_tests (or a compatible runner) is driving the suite,
+      # tag the command name with this worker's position in the pool.
       def parallel_data
-        # If being run from inside parallel_tests set the command name according to the process number
-        return unless ENV["PARALLEL_TEST_GROUPS"] && ENV["TEST_ENV_NUMBER"]
-
+        groups = ENV.fetch("PARALLEL_TEST_GROUPS", nil)
         number = ENV.fetch("TEST_ENV_NUMBER", nil)
+        return unless groups && number
+
+        # parallel_tests sets the first worker's TEST_ENV_NUMBER to "" rather
+        # than "1"; restore the position so the rendered label reads cleanly.
         number = "1" if number.empty?
-        "(#{number}/#{ENV.fetch('PARALLEL_TEST_GROUPS', nil)})"
+        "(#{number}/#{groups})"
       end
 
       COMMAND_LINE_FRAMEWORKS = {

lib/simplecov/parallel_adapters/generic.rb

@@ -23,7 +23,7 @@ module ParallelAdapters
     class GenericAdapter < Base
       class << self
         def active?
-          !ENV.fetch("TEST_ENV_NUMBER", nil).nil?
+          ENV.key?("TEST_ENV_NUMBER")
         end
 
         # parallel_tests sets the first worker's TEST_ENV_NUMBER to "";

lib/simplecov/parallel_adapters/parallel_tests.rb

@@ -16,7 +16,7 @@ class << self
         def active?
           ensure_loaded
           # !! to coerce `defined?` (returns nil or "constant") to a proper bool.
-          !!(defined?(::ParallelTests) && !ENV.fetch("TEST_ENV_NUMBER", nil).nil?)
+          !!(defined?(::ParallelTests) && ENV.key?("TEST_ENV_NUMBER"))
         end
 
         # Pick the *first* started process to do the final-result work,
@@ -69,7 +69,7 @@ def ensure_loaded
         end
 
         def env_suggests_parallel_tests?
-          !ENV.fetch("TEST_ENV_NUMBER", nil).nil? && !ENV.fetch("PARALLEL_TEST_GROUPS", nil).nil?
+          ENV.key?("TEST_ENV_NUMBER") && ENV.key?("PARALLEL_TEST_GROUPS")
         end
       end
     end

lib/simplecov/profiles.rb

@@ -42,9 +42,9 @@ def load(name)
     def fetch_proc(name)
       name = name.to_sym
       autoload_profile(name) unless key?(name)
-      raise SimpleCov::ConfigurationError, "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      return self[name] if key?(name)
 
-      self[name]
+      raise SimpleCov::ConfigurationError, "Could not find SimpleCov Profile called '#{name}'"
     end
 
   private

lib/simplecov/result_adapter.rb

@@ -18,19 +18,25 @@ def self.call(*args)
     def adapt
       return unless result
 
-      result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
-        if cover_statistic.is_a?(Array)
-          adapted_result.merge!(file_name => {"lines" => cover_statistic})
-        else
-          adapt_oneshot_lines_if_needed(file_name, cover_statistic)
-          normalize_method_keys(cover_statistic)
-          adapted_result.merge!(file_name => cover_statistic)
-        end
+      result.to_h do |file_name, cover_statistic|
+        [file_name, adapt_one(file_name, cover_statistic)]
       end
     end
 
   private
 
+    # Pre-0.18 resultsets pointed each filename straight at a line-coverage
+    # array; everything since uses the `{lines:, branches:, methods:}`
+    # shape. Newer entries also need their methods table massaged before
+    # downstream code merges across processes.
+    def adapt_one(file_name, cover_statistic)
+      return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
+
+      adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      normalize_method_keys(cover_statistic)
+      cover_statistic
+    end
+
     # Normalize memory addresses in method coverage keys so that results
     # from different processes can be merged. Anonymous class names like
     # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs.

lib/simplecov/useless_results_remover.rb

@@ -1,22 +1,19 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  #
-  # Select the files that related to working scope directory of SimpleCov
-  #
+  # Drop coverage entries whose paths live outside `SimpleCov.root` so the
+  # report only reflects the project's own source. Vendored gems, stdlib
+  # files, and anything else that happens to have been touched during the
+  # run never make it into the formatted result.
   module UselessResultsRemover
     def self.call(coverage_result)
-      coverage_result.select do |path, _coverage|
-        path =~ root_regx
-      end
+      coverage_result.select { |path, _coverage| path.match?(root_regx) }
     end
 
+    # The `/i` flag covers case-insensitive matches on Windows / macOS-HFS+
+    # where the on-disk path's case can differ from `SimpleCov.root`'s.
     def self.root_regx
-      @root_regx ||= begin
-        prefix = SimpleCov.root
-        prefix += File::SEPARATOR unless prefix.end_with?(File::SEPARATOR)
-        /\A#{Regexp.escape(prefix)}/i
-      end
+      @root_regx ||= /\A#{Regexp.escape(SimpleCov.root.chomp(File::SEPARATOR) + File::SEPARATOR)}/i
     end
   end
 end