simplecov 1.0.0 → 1.1.1

data/lib/simplecov/atomic_file.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tempfile"
+
+module SimpleCov
+  # Replaces an artifact through a collision-safe temporary file in the
+  # destination directory, so readers see either the old or complete new file.
+  module AtomicFile
+    DEFAULT_MODE = 0o666
+    private_constant :DEFAULT_MODE
+
+    def self.write(path, content, binary: false)
+      directory = File.dirname(path)
+      FileUtils.mkdir_p(directory)
+      mode = destination_mode(path)
+
+      Tempfile.create([".simplecov-", ".tmp"], directory) do |temp|
+        replace(temp, path, content, mode, binary: binary)
+      end
+
+      nil
+    end
+
+    def self.replace(temp, path, content, mode, binary:)
+      temp.binmode if binary
+      temp.write(content)
+      temp.close
+      File.chmod(mode, temp.path)
+      rename_over(temp.path, path)
+    ensure
+      temp.close unless temp.closed?
+      FileUtils.rm_f(temp.path)
+    end
+    private_class_method :replace
+
+    # On POSIX systems rename replaces the destination atomically. On
+    # Windows it fails with EACCES when the destination is open in a
+    # reader or mid-replacement by a concurrent writer, so retry briefly
+    # there before giving up.
+    def self.rename_over(temp_path, path)
+      attempts = 0
+      begin
+        File.rename(temp_path, path)
+      rescue Errno::EACCES
+        # simplecov:disable branch — which arm runs is fixed by the platform
+        raise unless Gem.win_platform?
+
+        # simplecov:enable branch
+        # simplecov:disable — Windows-only; unreachable where dogfood runs
+        attempts += 1
+        raise if attempts >= 10
+
+        sleep(0.01)
+        retry
+        # simplecov:enable
+      end
+    end
+    private_class_method :rename_over
+
+    def self.destination_mode(path)
+      return DEFAULT_MODE & ~File.umask if File.symlink?(path)
+
+      File.stat(path).mode & 0o777
+    rescue Errno::ENOENT
+      DEFAULT_MODE & ~File.umask
+    end
+    private_class_method :destination_mode
+  end
+end

data/lib/simplecov/cli/clean.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "optparse"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
@@ -9,11 +10,14 @@ module SimpleCov
     # `--dry-run` flag prints what would be deleted without touching
     # disk, for when you're not sure what's in there.
     module Clean
+      extend CommandHelpers
+
     module_function
 
-      def run(args, stdout:, **)
+      def run(args, stdout:, stderr:, **)
         opts = parse(args)
         dir = SimpleCov::CLI.coverage_dir
+        return error(stderr, "refusing to remove unsafe coverage directory #{dir.inspect}") unless safe_to_remove?(dir)
         return announce(stdout, opts, "#{dir} doesn't exist; nothing to do") || 0 unless File.directory?(dir)
 
         sweep(dir, opts, stdout)
@@ -22,7 +26,7 @@ module SimpleCov
 
       def sweep(dir, opts, stdout)
         if opts[:dry_run]
-          announce(stdout, opts, "would remove #{dir} (#{Dir["#{dir}/**/*"].size} entries)")
+          announce(stdout, opts, "would remove #{dir} (#{entry_count(dir)} entries)")
         else
           require "fileutils"
           FileUtils.rm_rf(dir)
@@ -30,8 +34,44 @@ module SimpleCov
         end
       end
 
+      # FNM_DOTMATCH so the dotfiles rm_rf will actually delete
+      # (.resultset.json, .last_run.json) count too; the glob still
+      # yields the directory's own "." entry, which rm_rf does not
+      # remove separately.
+      def entry_count(dir)
+        Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH).count { |path| !path.end_with?("/.") }
+      end
+
       def announce(stdout, opts, message)
-        stdout.puts("simplecov clean: #{message}") unless opts[:quiet]
+        stdout.puts("simplecov #{command_name}: #{message}") unless opts[:quiet]
+      end
+
+      def safe_to_remove?(dir)
+        target = canonical_path(dir)
+        # A filesystem root is its own dirname ("/" everywhere, drive
+        # roots like "D:/" on Windows). The descendant check below only
+        # protects roots that happen to contain the cwd or project root,
+        # which misses other drives, so refuse roots outright.
+        return false if File.dirname(target) == target
+
+        protected_paths.none? { |path| path == target || descendant_of?(path, target) }
+      end
+
+      def protected_paths
+        project_root = SimpleCov::CLI::Dotfile.find
+        [Dir.pwd, (File.dirname(project_root) if project_root)].compact.map { |path| canonical_path(path) }.uniq
+      end
+
+      # Canonical paths only carry a trailing separator on a filesystem
+      # root, and roots are refused before this check runs.
+      def descendant_of?(path, possible_ancestor)
+        path.start_with?("#{possible_ancestor}#{File::SEPARATOR}")
+      end
+
+      def canonical_path(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
       end
 
       def parse(args)

data/lib/simplecov/cli/command_helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SimpleCov
+  module CLI
+    # Plumbing the subcommands repeat, which their modules `extend`: the
+    # standard option trio the read-only commands share, the parse
+    # scaffold around it, the one-line error helper (prefixed with the
+    # command's own name), and the human-readable stats row `coverage`
+    # and `report` both print.
+    module CommandHelpers
+      STATS_ROW_FORMAT = "  %<label>-7s %<pct>s (%<covered>d / %<total>d)"
+
+      # "simplecov merge: ..." — derived from the extending module's
+      # name. The self cast collapses the mixin's view of `self` to the
+      # Module that extends it, which is what carries `name`.
+      def command_name
+        (_ = self).name.split("::").last.downcase
+      end
+
+      def error(stderr, message)
+        stderr.puts("simplecov #{command_name}: #{message}")
+        1
+      end
+
+      # The --input / --json / --no-color trio every read-only
+      # subcommand accepts.
+      def common_options(parser, opts)
+        parser.on("--input PATH") { |v| opts[:input] = v }
+        parser.on("--json")       { opts[:json] = true }
+        parser.on("--no-color")   { opts[:no_color] = true }
+      end
+
+      # The parse scaffold every read-only subcommand repeats: seed the
+      # shared defaults (plus the command's own), wire up the common
+      # option trio, yield the parser for command-specific flags, and
+      # return the parsed opts alongside the positional arguments.
+      def parse_common(args, defaults = {})
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false} #: Hash[Symbol, untyped]
+        opts.merge!(defaults)
+        rest =
+          OptionParser.new do |parser|
+            common_options(parser, opts)
+            yield parser, opts if block_given?
+          end.parse(args)
+        [opts, rest]
+      end
+
+      def stats_row(label, percent_text, covered, total)
+        format(STATS_ROW_FORMAT, label: "#{label}:", pct: percent_text, covered: covered.to_i, total: total.to_i)
+      end
+    end
+  end
+end

data/lib/simplecov/cli/coverage.rb

@@ -2,17 +2,14 @@
 
 require "json"
 require "optparse"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
     # `simplecov coverage <path>` — print per-criterion stats for one
     # file from a JSONFormatter coverage.json.
     module Coverage
-      CRITERIA = [
-        {label: "Line",   pct: "lines_covered_percent",    cov: "covered_lines",    tot: "total_lines"},
-        {label: "Branch", pct: "branches_covered_percent", cov: "covered_branches", tot: "total_branches"},
-        {label: "Method", pct: "methods_covered_percent",  cov: "covered_methods",  tot: "total_methods"}
-      ].freeze
+      extend CommandHelpers
 
     module_function
 
@@ -28,13 +25,7 @@ module SimpleCov
       end
 
       def parse(args, stderr:)
-        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false}
-        rest =
-          OptionParser.new do |o|
-            o.on("--input PATH") { |v| opts[:input] = v }
-            o.on("--json") { opts[:json] = true }
-            o.on("--no-color") { opts[:no_color] = true }
-          end.parse(args)
+        opts, rest = parse_common(args)
         return stderr.puts("simplecov coverage: missing file argument") && nil if rest.empty?
 
         opts[:path] = rest.first
@@ -42,14 +33,18 @@ module SimpleCov
       end
 
       def locate_match(opts, stderr)
-        return stderr.puts("simplecov coverage: #{opts[:input]} not found") && nil unless File.exist?(opts[:input])
+        coverage = CoverageFile.load_coverage(opts[:input], command: "coverage", stderr: stderr)
+        return unless coverage
 
-        data = JSON.parse(File.read(opts[:input]))
-        match = lookup(data.fetch("coverage", {}), opts[:path])
-        return match if match
+        match = lookup(coverage, opts[:path])
+        if match.nil?
+          stderr.puts("simplecov coverage: no entry for #{opts[:path]} in #{opts[:input]}")
+          return nil
+        end
+        # A wrong-typed entry used to escape here and crash print_human.
+        return match if match.last.is_a?(Hash)
 
-        stderr.puts("simplecov coverage: no entry for #{opts[:path]} in #{opts[:input]}")
-        nil
+        CoverageFile.report_invalid(stderr, "coverage", opts[:input], "entry for #{opts[:path]} must be an object")
       end
 
       # Match either the absolute path, the literal string passed, or
@@ -65,7 +60,8 @@ module SimpleCov
       def emit(match, opts, stdout)
         filename, payload = match
         if opts[:json]
-          stdout.puts(JSON.pretty_generate(filename => payload))
+          entry = {filename => payload} #: Hash[untyped, untyped]
+          stdout.puts(JSON.pretty_generate(entry))
         else
           print_human(filename, payload, stdout, SimpleCov::CLI.color_enabled?(opts, stdout))
         end
@@ -73,18 +69,17 @@ module SimpleCov
 
       def print_human(filename, payload, stdout, color)
         stdout.puts(filename)
-        CRITERIA.each { |c| emit_criterion(stdout, payload, c, color) }
+        CoverageFile::CRITERIA.each_value { |c| emit_criterion(stdout, payload, c, color) }
       end
 
       def emit_criterion(stdout, payload, criterion, color)
-        return unless payload.key?(criterion[:pct])
-
-        pct = payload[criterion[:pct]].to_f
-        stdout.puts(format("  %<label>-7s %<pct>s (%<covered>d / %<total>d)",
-                           label: "#{criterion[:label]}:",
-                           pct: SimpleCov::Color.colorize_percent(pct, enabled: color),
-                           covered: payload[criterion[:cov]] || 0,
-                           total: payload[criterion[:tot]] || 0))
+        return unless payload.key?(criterion[:percent])
+
+        pct = payload[criterion[:percent]].to_f
+        stdout.puts(stats_row(criterion[:label],
+                              SimpleCov::Color.colorize_percent(pct, enabled: color),
+                              payload[criterion[:covered]],
+                              payload[criterion[:total]]))
       end
     end
   end

data/lib/simplecov/cli/coverage_file.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../coverage_json"
+
+module SimpleCov
+  module CLI
+    # Shared input boundary for commands that consume JSONFormatter's
+    # coverage.json. It validates only the stable outer shape so older schema
+    # versions remain readable.
+    module CoverageFile
+      # The coverage.json fields backing each criterion, keyed by the
+      # criterion's singular name. The one table the coverage, uncovered,
+      # and diff subcommands all read from, so a schema change lands in
+      # exactly one place.
+      CRITERIA = {
+        line: {label: "Line", percent: "lines_covered_percent",
+               covered: "covered_lines", total: "total_lines"},
+        branch: {label: "Branch", percent: "branches_covered_percent",
+                 covered: "covered_branches", total: "total_branches"},
+        method: {label: "Method", percent: "methods_covered_percent",
+                 covered: "covered_methods", total: "total_methods"}
+      }.freeze
+
+    module_function
+
+      def load_document(path, command:, stderr:)
+        SimpleCov::CoverageJSON.load(path)
+      rescue Errno::ENOENT
+        report_missing(stderr, command, path)
+      rescue SimpleCov::CoverageJSON::Error => e
+        report_invalid(stderr, command, path, e.message)
+      rescue SystemCallError => e
+        report_unreadable(stderr, command, path, e.message)
+      end
+
+      def load_coverage(path, command:, stderr:)
+        document = load_document(path, command: command, stderr: stderr)
+        return unless document
+
+        none = {} #: Hash[String, untyped]
+        coverage = document.fetch("coverage", none)
+        return coverage if coverage.is_a?(Hash)
+
+        report_invalid(stderr, command, path, '"coverage" must be an object')
+      end
+
+      def report_invalid(stderr, command, path, reason)
+        detail = reason.lines.first.to_s.strip
+        stderr.puts("simplecov #{command}: input file #{path.inspect} isn't valid JSON (#{detail})")
+        nil
+      end
+
+      def report_missing(stderr, command, path)
+        stderr.puts("simplecov #{command}: #{path} not found")
+        nil
+      end
+
+      def report_unreadable(stderr, command, path, reason)
+        detail = reason.lines.first.to_s.strip
+        stderr.puts("simplecov #{command}: cannot read #{path.inspect} (#{detail})")
+        nil
+      end
+    end
+  end
+end

data/lib/simplecov/cli/diff.rb

@@ -2,28 +2,20 @@
 
 require "json"
 require "optparse"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
-    # `simplecov diff <baseline>` — print the per-file line-coverage
-    # delta between coverage.json (--input) and a baseline coverage.json
+    # `simplecov diff <baseline>` — print per-file coverage deltas between
+    # coverage.json (--input) and a baseline coverage.json
     # checked in alongside the suite. Only files whose coverage moved
     # are listed; --fail-on-drop exits non-zero when any file regressed,
     # so this composes with CI as a "coverage of this PR didn't drop"
     # gate. Resolves the long-standing "diff coverage" feature request.
     module Diff
-      EPSILON = 0.005 # tolerance below which a delta is considered noise
+      extend CommandHelpers
 
-      # Per-criterion key map. coverage.json carries `lines_covered_percent`
-      # plus `branches_covered_percent` / `methods_covered_percent` when
-      # the corresponding criterion is enabled, so the diff can describe
-      # whichever criteria the baseline + current both report on.
-      CRITERIA = %i[lines branches methods].freeze
-      CRITERION_FIELDS = {
-        lines: {pct: "lines_covered_percent", total: "total_lines"},
-        branches: {pct: "branches_covered_percent", total: "total_branches"},
-        methods: {pct: "methods_covered_percent", total: "total_methods"}
-      }.freeze
+      EPSILON = 0.005 # tolerance below which a delta is considered noise
 
       STATUS_SUFFIX = {"added" => "(new file)", "removed" => "(removed)"}.freeze
 
@@ -36,11 +28,11 @@ module SimpleCov
         rows = compute_rows(opts[:current], opts[:baseline], opts[:threshold])
         rows.sort_by! { |row| row[:line_delta] }
         if opts[:json]
-          emit_json(stdout, rows)
+          stdout.puts(JSON.pretty_generate(rows))
         else
           emit_text(stdout, rows, SimpleCov::CLI.color_enabled?(opts, stdout))
         end
-        opts[:fail_on_drop] && rows.any? { |row| row[:line_delta].negative? } ? 1 : 0
+        opts[:fail_on_drop] && coverage_drop?(rows) ? 1 : 0
       end
 
       def parse(args, stderr)
@@ -53,25 +45,18 @@ module SimpleCov
       end
 
       def parse_flags(args)
-        opts = {input: SimpleCov::CLI.default_input, fail_on_drop: false, json: false, threshold: 0.0, no_color: false}
-        opts.merge(rest: option_parser(opts).parse(args))
-      end
-
-      def option_parser(opts)
-        OptionParser.new do |o|
-          o.on("--input PATH")         { |v| opts[:input] = v }
-          o.on("--fail-on-drop")       { opts[:fail_on_drop] = true }
-          o.on("--json")               { opts[:json] = true }
-          o.on("--threshold N", Float) { |v| opts[:threshold] = v }
-          o.on("--no-color")           { opts[:no_color] = true }
+        opts, rest = parse_common(args, fail_on_drop: false, threshold: 0.0) do |o, options|
+          o.on("--fail-on-drop")       { options[:fail_on_drop] = true }
+          o.on("--threshold N", Float) { |v| options[:threshold] = v }
         end
+        opts.merge(rest: rest)
       end
 
       def load_coverage(path, stderr)
-        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", {})) if File.exist?(path)
+        coverage = CoverageFile.load_coverage(path, command: "diff", stderr: stderr)
+        return unless coverage
 
-        stderr.puts("simplecov diff: #{path} not found")
-        nil
+        normalize_keys(coverage)
       end
 
       # Strip a leading slash so coverage.json files written before the
@@ -86,18 +71,23 @@ module SimpleCov
         files.filter_map { |fname| compute_row(fname, current[fname], baseline[fname], threshold) }
       end
 
+      # EPSILON keeps float noise out regardless of threshold; the
+      # threshold itself is inclusive, so a file that moved exactly N%
+      # is listed under `--threshold N`, matching the "at least N%" the
+      # usage text promises.
       def compute_row(fname, current_payload, baseline_payload, threshold)
-        deltas = CRITERIA.to_h { |c| [c, pct_for(c, current_payload) - pct_for(c, baseline_payload)] }
-        floor = [threshold.abs, EPSILON].max
-        return nil unless deltas.values.any? { |delta| delta.abs > floor }
-
-        {
-          file: fname,
-          status: status_for(current_payload, baseline_payload),
-          line_delta: deltas[:lines],
-          branch_delta: deltas[:branches],
-          method_delta: deltas[:methods]
-        }
+        deltas = compute_deltas(current_payload, baseline_payload)
+        floor = threshold.abs
+        return nil unless deltas.values.any? { |delta| delta.abs > EPSILON && delta.abs >= floor }
+
+        {file: fname, status: status_for(current_payload, baseline_payload),
+         line_delta: deltas[:line], branch_delta: deltas[:branch], method_delta: deltas[:method]}
+      end
+
+      def compute_deltas(current_payload, baseline_payload)
+        CoverageFile::CRITERIA.transform_values do |fields|
+          pct_for(fields, current_payload) - pct_for(fields, baseline_payload)
+        end
       end
 
       def status_for(current_payload, baseline_payload)
@@ -107,11 +97,10 @@ module SimpleCov
         "changed"
       end
 
-      def pct_for(criterion, payload)
-        fields = CRITERION_FIELDS.fetch(criterion)
+      def pct_for(fields, payload)
         return 0.0 unless payload.is_a?(Hash) && payload[fields[:total]].to_i.positive?
 
-        payload[fields[:pct]].to_f
+        payload[fields[:percent]].to_f
       end
 
       def emit_text(stdout, rows, color)
@@ -134,6 +123,17 @@ module SimpleCov
         ].compact
       end
 
+      # A removed file's deltas are all -baseline%, but deleting a
+      # covered file (dead code cleanup) is not a coverage regression,
+      # so removed rows never trip the --fail-on-drop gate. Drops are
+      # gated on EPSILON like row inclusion and display: a row listed
+      # for a gain in one criterion must not fail the run over float
+      # noise in another, invisible in the printed output.
+      def coverage_drop?(rows)
+        rows.reject { |row| row[:status] == "removed" }
+            .any? { |row| row.values_at(:line_delta, :branch_delta, :method_delta).min < -EPSILON }
+      end
+
       # Deltas are sign-based, not threshold-based: a +5% bump is good
       # (green) and a -5% drop is bad (red), regardless of where the
       # absolute coverage level lands.
@@ -142,10 +142,6 @@ module SimpleCov
         text = format("%<sign>s%<delta>6.2f%% %<label>s", sign: sign, delta: delta, label: label)
         SimpleCov::Color.colorize(text, delta.negative? ? :red : :green, enabled: color)
       end
-
-      def emit_json(stdout, rows)
-        stdout.puts(JSON.pretty_generate(rows))
-      end
     end
   end
 end

data/lib/simplecov/cli/dotfile.rb

@@ -18,9 +18,12 @@ module SimpleCov
         return "coverage" unless dotfile
 
         with_simplecov_loaded { read_from(dotfile) }
-      rescue LoadError, StandardError => e
-        # simplecov:disable — defensive fallback for a bad dotfile (parse
-        # error, EACCES, etc.); never fires in the project's own dogfood run
+      rescue ScriptError, StandardError => e
+        # simplecov:disable — defensive fallback for a bad dotfile; never
+        # fires in the project's own dogfood run. ScriptError covers the
+        # SyntaxError a malformed dotfile raises from `load` (it is not a
+        # StandardError) along with LoadError; StandardError covers the
+        # rest (EACCES, errors raised by the dotfile's own code, etc.).
         warn "simplecov: failed to read coverage_dir from #{dotfile}: #{e.class}: #{e.message}"
         "coverage"
         # simplecov:enable
@@ -37,11 +40,14 @@ module SimpleCov
       # inside a Ruby host that cares about isolation should arrange that
       # themselves.
       def read_from(dotfile)
-        snapshot = SimpleCov.instance_variable_get(:@coverage_dir)
+        snapshot = SimpleCov.instance_variable_get(:@coverage_dir) #: String?
         load_with_start_neutered(dotfile)
-        dir = SimpleCov.coverage_dir
+        SimpleCov.coverage_dir
+      ensure
+        # Restore even when the load raises, so a bad dotfile doesn't
+        # leave a host process's configured dir clobbered.
+        # @type var snapshot: String?
         SimpleCov.instance_variable_set(:@coverage_dir, snapshot)
-        dir
       end
 
       def find
@@ -57,8 +63,8 @@ module SimpleCov
       end
 
       def with_simplecov_loaded
-        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil)
-        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil)
+        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil) #: String?
+        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil) #: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
         # SIMPLECOV_CLI lets a project's `.simplecov` opt some config into
         # CLI-only behavior — e.g. simplecov itself sets `coverage_dir`
@@ -67,6 +73,8 @@ module SimpleCov
         require "simplecov"
         yield
       ensure
+        # @type var previous_no_defaults: String?
+        # @type var previous_cli: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = previous_no_defaults
         ENV["SIMPLECOV_CLI"]         = previous_cli
       end
@@ -79,20 +87,23 @@ module SimpleCov
       def load_with_start_neutered(path)
         klass = SimpleCov.singleton_class
         names = %i[start_tracking install_at_exit_hook]
-        stash = names.to_h { |name| [name, klass.instance_method(name)] }
+        stash = names.to_h { |name| [name, klass.instance_method(name)] } #: Hash[Symbol, UnboundMethod]
         # define_method over an existing method emits a "method redefined"
         # warning under $VERBOSE; the override and restore are intentional.
         silence_verbose { names.each { |name| klass.define_method(name) { nil } } }
         load path
       ensure
+        # @type var stash: Hash[Symbol, UnboundMethod]
+        # @type var klass: Class
         silence_verbose { stash.each { |name, method| klass.define_method(name, method) } }
       end
 
       def silence_verbose
-        previous = $VERBOSE
+        previous = $VERBOSE #: bool?
         $VERBOSE = nil
         yield
       ensure
+        # @type var previous: bool?
         $VERBOSE = previous
       end
     end

data/lib/simplecov/cli/merge.rb

@@ -2,6 +2,8 @@
 
 require "json"
 require "optparse"
+require_relative "../atomic_file"
+require_relative "command_helpers"
 
 module SimpleCov
   module CLI
@@ -12,6 +14,8 @@ module SimpleCov
     # load path; lazy-required so the read-only subcommands above don't
     # pay for ResultMerger (and its Coverage runtime guard).
     module Merge
+      extend CommandHelpers
+
     module_function
 
       def run(args, stdout:, stderr:, **)
@@ -57,22 +61,28 @@ module SimpleCov
       # generic "no mergeable results" into a message that points at
       # the specific input causing the failure.
       def parse_inputs(files, stderr)
-        files.each_with_object({}) do |path, memo|
+        parsed = {} #: Hash[String, Hash[String, untyped]]
+        files.each_with_object(parsed) do |path, memo|
           data = parse_input(path, stderr) or return nil
 
           memo[path] = data
         end
       end
 
+      # Read first, classify by the exception: an exist?-then-read pair
+      # is racy, and rescuing only ENOENT crashed with a backtrace on a
+      # directory (EISDIR) or an unreadable file (EACCES).
       def parse_input(path, stderr)
-        return parse_input_error(stderr, path, "not found") unless File.exist?(path)
-
         data = JSON.parse(File.read(path))
         return data if data.is_a?(Hash) && !data.empty?
 
         parse_input_error(stderr, path, "has no resultset entries")
+      rescue Errno::ENOENT
+        parse_input_error(stderr, path, "not found")
       rescue JSON::ParserError => e
         parse_input_error(stderr, path, "isn't valid JSON (#{e.message})")
+      rescue SystemCallError => e
+        parse_input_error(stderr, path, "cannot be read (#{e.message.lines.first.to_s.strip})")
       end
 
       def parse_input_error(stderr, path, reason)
@@ -85,8 +95,9 @@ module SimpleCov
       # mistake for "no merge happened." Surface the overlap so the
       # operator can rename the workers or accept the merge knowingly.
       def warn_about_duplicate_command_names(parsed, stderr)
-        files_per_command = parsed.each_with_object({}) do |(path, data), memo|
-          data.each_key { |command_name| (memo[command_name] ||= []) << path }
+        files_per_command = {} #: Hash[String, Array[String]]
+        parsed.each do |path, data|
+          data.each_key { |command_name| (files_per_command[command_name] ||= []) << path }
         end
         files_per_command.each do |command_name, paths|
           next if paths.size < 2
@@ -102,14 +113,7 @@ module SimpleCov
       end
 
       def write(path, result)
-        require "fileutils"
-        FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, JSON.pretty_generate(result.to_hash))
-      end
-
-      def error(stderr, message)
-        stderr.puts("simplecov merge: #{message}")
-        1
+        AtomicFile.write(path, JSON.pretty_generate(result.to_hash))
       end
     end
   end