simplecov 0.22.0 → 1.1.1

data/lib/simplecov/result.rb

@@ -2,6 +2,8 @@
 
 require "digest/sha1"
 require "forwardable"
+require_relative "result/missing_source_files_reporter"
+require_relative "result/source_file_builder"
 
 module SimpleCov
   #
@@ -10,9 +12,18 @@ module SimpleCov
   #
   class Result
     extend Forwardable
+
     # Returns the original Coverage.result used for this instance of SimpleCov::Result
     attr_reader :original_result
-    # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+    # Every path the producing process was told to track, loaded or not. Carried
+    # into the resultset so a merge elsewhere can inject the ones nobody loaded
+    # without needing that process's `cover` / `track_files` config. See #1250.
+    attr_reader :tracked_files
+    # Invocation and top-level worker identities used only for parallel-result
+    # coordination. They do not change which fresh suites are merged.
+    attr_reader :run_id, :worker_id
+    # Returns all files that are applicable to this result (sans filters!) as instances of
+    # SimpleCov::SourceFile. Aliased as :source_files
     attr_reader :files
     alias source_files files
     # Explicitly set the Time this result has been created
@@ -20,20 +31,48 @@ module SimpleCov
     # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
     attr_writer :command_name
 
-    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength,
+                   :covered_lines, :missed_lines,
+                   :total_branches, :covered_branches, :missed_branches,
+                   :total_methods, :covered_methods, :missed_methods,
+                   :coverage_statistics, :coverage_statistics_by_file
     def_delegator :files, :lines_of_code, :total_lines
 
+    # Bundles the filter and grouping configuration a Result applies to its
+    # source files after building them. Each field defaults to the SimpleCov
+    # singleton's configuration, so ordinary callers never construct one;
+    # tests pass a custom instance to opt out of (or extend) the project's
+    # filters or groups (e.g. `filters: []` to keep every file). Grouping the
+    # three together keeps Result#initialize's parameter list small.
+    class FilterConfig
+      attr_reader :filters, :cover_filters, :groups
+
+      def initialize(filters: SimpleCov.filters, cover_filters: SimpleCov.cover_filters, groups: SimpleCov.groups)
+        @filters = filters
+        @cover_filters = cover_filters
+        @groups = groups
+      end
+    end
+
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
-    # coverage data)
-    def initialize(original_result, command_name: nil, created_at: nil)
-      result = original_result
-      @original_result = result.freeze
+    # coverage data).
+    #
+    # `filter_config` defaults to the SimpleCov singleton's filter / group
+    # configuration so existing call sites are unchanged. Pass a custom
+    # FilterConfig to opt out — useful for tests that build synthetic Results
+    # and don't want the project's filters or groups applied.
+    def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
+                   tracked_files: [], run_id: nil, worker_id: nil, report: false, filter_config: FilterConfig.new)
+      @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
-      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
-      end.compact.sort_by(&:filename))
-      filter!
+      initialize_coordination_metadata(tracked_files, run_id, worker_id)
+      @groups_config = filter_config.groups
+      builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
+      @files = builder.call
+      warn_about_missing_source_files(builder.missing_source_files, original_result.size) if report
+      apply_cover_filters!(filter_config.cover_filters)
+      apply_filters!(filter_config.filters)
     end
 
     # Returns all filenames for source files contained in this result
@@ -41,14 +80,43 @@ module SimpleCov
       files.map(&:filename)
     end
 
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
+    # Returns the SimpleCov::SourceFile for the given path, or nil if no
+    # matching file is in this result. The path is resolved against
+    # SimpleCov.root, so callers can pass either an absolute path or a
+    # project-relative one.
+    def source_file_for(path)
+      target = File.expand_path(path, SimpleCov.root)
+      files.find { |file| file.filename == target }
+    end
+
+    # Returns the {line:/branch:/method:} coverage_statistics hash for the
+    # given file path, or nil if no matching source file is in this
+    # result. See SimpleCov::Result#source_file_for for path resolution.
+    def coverage_for(path)
+      source_file_for(path)&.coverage_statistics
+    end
+
+    # Returns a Hash of groups for this result. Define groups using SimpleCov.group 'Models', 'app/models'
     def groups
-      @groups ||= SimpleCov.grouped(files)
+      @groups ||= SimpleCov.grouped(files, groups: @groups_config)
     end
 
-    # Applies the configured SimpleCov.formatter on this result
+    # Applies the configured SimpleCov.formatter on this result. Returns
+    # nil if formatting has been opted out of (`SimpleCov.formatter false`
+    # / `SimpleCov.formatters []`) — the cheap path for non-final
+    # processes in a parallel CI run, which only need their
+    # `.resultset.json` on disk. See #964.
     def format!
-      SimpleCov.formatter.new.format(self)
+      formatter = SimpleCov.formatter
+      return nil if formatter.nil?
+
+      formatted = Formatter.format(formatter, self)
+      # Recorded regardless of how the run ends, so a parent process's
+      # clobber-prevention backstop can tell a report was produced even
+      # when this run's checks or tests failed (unlike .last_run.json,
+      # which only successful runs write).
+      SimpleCov::ReportStamp.touch
+      formatted
     end
 
     # Defines when this result has been created. Defaults to Time.now
@@ -64,31 +132,82 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {
-        command_name => {
-          "coverage" => coverage,
-          "timestamp" => created_at.to_i
-        }
-      }
+      data = {"coverage" => coverage, "timestamp" => created_at.to_f} #: Hash[String, untyped]
+      data["run_id"] = run_id if run_id
+      data["worker_id"] = worker_id if worker_id
+      # Omitted when empty so a run that tracks nothing writes the shape it
+      # always has, and so the key only appears where it carries information.
+      data["tracked_files"] = tracked_files unless tracked_files.empty?
+      {command_name => data}
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       hash.map do |command_name, data|
-        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]),
+                                    tracked_files: data["tracked_files"] || [], run_id: data["run_id"],
+                                    worker_id: data["worker_id"])
       end
     end
 
   private
 
+    def initialize_coordination_metadata(tracked_files, run_id, worker_id)
+      @tracked_files = tracked_files.to_a
+      @run_id = run_id
+      @worker_id = worker_id
+    end
+
+    def warn_about_missing_source_files(missing, input_size)
+      return if missing.empty?
+
+      # Emit only from the process that writes the final report. The merged
+      # result is rebuilt in every parallel worker (each one stores its own
+      # slice), so without this gate the warning prints once per worker — this
+      # is the same signal SimpleCov uses to pick the process that runs the
+      # report and threshold checks. It's intentionally not gated on
+      # print_errors: the default at_fork sets print_errors false on workers,
+      # and in many parallel runners the final-report process is itself a
+      # worker, so a print_errors gate would suppress the one warning we want.
+      # See issues #980 and #1171.
+      return unless SimpleCov.final_result_process?
+
+      MissingSourceFilesReporter.new(
+        missing,
+        input_size: input_size,
+        every_entry_dropped: @files.empty? && missing.size == input_size
+      ).warn!
+    end
+
+    # A live result's criterion keys are Symbols (`:lines`, `:branches`),
+    # while entries parsed back from `.resultset.json` carry Strings, and
+    # the combiners read only String keys. Serialize with String keys so a
+    # live result merged against a stored entry contributes its counts
+    # instead of being silently dropped for every shared file.
     def coverage
-      keys = original_result.keys & filenames
-      Hash[keys.zip(original_result.values_at(*keys))]
+      original_result.slice(*filenames).transform_values do |file_coverage|
+        file_coverage.transform_keys(&:to_s)
+      end
     end
 
-    # Applies all configured SimpleCov filters on this result's source files
-    def filter!
-      @files = SimpleCov.filtered(files)
+    # Applies the given filter chain to `@files`, dropping each source
+    # file that any filter matches.
+    def apply_filters!(filters)
+      filters.each do |filter|
+        @files = SimpleCov::FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+      end
+    end
+
+    # When any `cover` matcher is configured, restrict `@files` to source
+    # files matching at least one of them. With no cover matchers configured
+    # this is a no-op, preserving the historical "everything required, then
+    # filtered" universe.
+    def apply_cover_filters!(cover_filters)
+      return if cover_filters.empty?
+
+      @files = SimpleCov::FileList.new(
+        @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
+      )
     end
   end
 end

data/lib/simplecov/result_adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "coverage"
+
 module SimpleCov
   #
   # Responsible for adapting the format of the coverage result whether it's default or with statistics
@@ -11,20 +13,149 @@ module SimpleCov
       @result = result
     end
 
-    def self.call(*args)
-      new(*args).adapt
+    def self.call(*)
+      new(*).adapt
     end
 
     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
-          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 and branches tables
+    # massaged before downstream code reports or merges them.
+    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)
+      aggregate_duplicated_branches(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.
+    # 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+/
+    private_constant :ADDRESS_PATTERN
+
+    ADDRESS_PLACEHOLDER = "0x0"
+    private_constant :ADDRESS_PLACEHOLDER
+
+    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # method keys. `module_function` and class methods get recorded both as
+    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
+    # entries pointing at the same source location; only one of the two is
+    # ever reachable at runtime, so we merge them. Only applies to named
+    # constants — anonymous-class addresses like `#<Class:0x0>` are left
+    # alone (handled by ADDRESS_PATTERN above).
+    SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
+    private_constant :SINGLETON_WRAPPER_PATTERN
+
+    # Ruby's method coverage records one entry per DEFINED METHOD, not per
+    # source location: a block handed to `define_method` /
+    # `define_singleton_method` from a shared code path yields a separate
+    # `[receiver, name, location]` entry for every class it's defined on
+    # (a module's `included` hook defining onto each descendant) AND for
+    # every name it's defined under (a builder looping `define_method key`
+    # over a container), all pointing at the same source. A file-based
+    # report can only express "was the method at this location ever
+    # executed", so entries are aggregated by location alone, summing
+    # hits — otherwise each receiver or name whose generated copy never
+    # ran shows as a phantom uncovered method on a line whose line
+    # coverage is 100%. Regular `def`s map one location to one name, so
+    # they are unaffected. The first entry's (normalized) key is kept for
+    # display. See issue #1234.
+    def normalize_method_keys(cover_statistic)
+      methods = cover_statistic[:methods]
+      return unless methods
+
+      aggregated = {} #: Hash[untyped, [untyped, Integer]]
+      methods.each_with_object(aggregated) do |(key, count), memo|
+        location = key[2..] #: Array[untyped]
+        retained_key, existing = memo[location] || [normalize_method_key(key), 0]
+        memo[location] = [retained_key, existing + count]
       end
+      cover_statistic[:methods] = aggregated.values.to_h
+    end
+
+    def normalize_method_key(key)
+      normalized_key = key.dup
+      normalized_key[0] = class_display_name(key[0])
+                          .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                          .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      normalized_key
+    end
+
+    # Rendering a class name can execute user code: a singleton class's
+    # `to_s` renders its attached object via `#inspect`, which a module can
+    # shadow with an incompatible signature (Liquid::Utils defines
+    # `inspect(value, max_depth = 2)` as a module_function, so rendering
+    # `#<Class:Liquid::Utils>` raises ArgumentError). A coverage report
+    # must never crash the host suite over that, so on failure rebuild the
+    # singleton wrapper from `Module#name` via bound methods (which cannot
+    # be shadowed), falling back to the address form, which
+    # ADDRESS_PATTERN then normalizes. See issue #1236.
+    def class_display_name(klass)
+      klass.to_s
+    rescue StandardError
+      singleton_wrapper_name(klass) || Object.instance_method(:to_s).bind_call(klass)
+    end
+
+    def singleton_wrapper_name(klass)
+      return nil unless klass.is_a?(Class) && klass.singleton_class?
+
+      attached = klass.attached_object
+      # simplecov:disable branch — CRuby only reaches the rescue via a
+      # Module/Class attached object (instance singletons render from the
+      # class name chain without calling user inspect), so the non-Module
+      # arm is defensive.
+      name = Module.instance_method(:name).bind_call(attached) if attached.is_a?(Module)
+      # simplecov:enable branch
+      name && "#<Class:#{name}>"
+    end
+
+    # Ruby's eval coverage records a fresh set of branch entries for every
+    # COMPILE of an eval'd string: a template rendered through multiple view
+    # classes (e.g. hanami-view compiles each template once per view) yields
+    # several `[:if, id, location]` conditions at identical coordinates in
+    # the same file, each counting only the renders that flowed through that
+    # compile. Reported as-is they inflate the branch denominator and turn a
+    # side covered under a different compile into a phantom miss (issue
+    # #1235). Aggregate them by (type, location) — combining a branches hash
+    # with an empty one dedups within it, since BranchesCombiner keys arms
+    # on location identity. Regular (non-eval) source can never produce two
+    # conditions at the same location, so this is a no-op outside eval.
+    def aggregate_duplicated_branches(cover_statistic)
+      branches = cover_statistic[:branches]
+      return unless branches
+
+      cover_statistic[:branches] = Combine::BranchesCombiner.combine(branches, {})
+    end
+
+    def adapt_oneshot_lines_if_needed(file_name, cover_statistic)
+      return unless cover_statistic.key?(:oneshot_lines)
+
+      oneshot_lines = cover_statistic.delete(:oneshot_lines)
+      line_stub     = build_line_stub(file_name, oneshot_lines)
+      oneshot_lines.each { |covered_line| line_stub[covered_line - 1] = 1 }
+      cover_statistic[:lines] = line_stub
+    end
+
+    def build_line_stub(file_name, oneshot_lines)
+      Coverage.line_stub(file_name)
+    rescue Errno::ENOENT, SyntaxError
+      Array.new(oneshot_lines.max || 0, nil)
     end
   end
 end

data/lib/simplecov/result_merger/legacy_format_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # We changed the format of the raw result data in simplecov, as people
+    # are likely to have "old" resultsets lying around (but not too old so
+    # that they're still considered we can adapt them). See
+    # https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
+    module LegacyFormatAdapter
+    module_function
+
+      def call(result)
+        pre_0_18?(result) ? upgrade(result) : result
+      end
+
+      # Pre-0.18 coverage data pointed from file directly to an array of
+      # line coverage rather than a `{"lines" => [...]}` hash.
+      def pre_0_18?(result)
+        _key, data = result.first
+        data.is_a?(Array)
+      end
+
+      def upgrade(result)
+        result.transform_values { |line_coverage_data| {"lines" => line_coverage_data} }
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_file.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  module ResultMerger
+    # Read + parse a `.resultset.json` file with the same tolerance the
+    # historical `ResultMerger` had: a missing or empty file quietly
+    # returns `{}`, an unparseable one warns and returns `{}`, and parse
+    # success returns the decoded Hash with any malformed entries
+    # warned about and dropped.
+    module ResultsetFile
+    module_function
+
+      def parse(path)
+        data = read(path)
+        decode(data)
+      end
+
+      # A missing or blank file quietly means "no results yet"; anything
+      # else — a 1-byte truncation included — flows through decode so
+      # corruption warns instead of silently vanishing (the old
+      # `length < 2` check swallowed exactly those). Read first and
+      # rescue rather than check exist? (racy against a concurrent
+      # clean).
+      def read(path)
+        data = File.read(path)
+        return if data.match?(/\A\s*\z/)
+
+        data
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def decode(content)
+        return {} unless content
+
+        parsed = JSON.parse(content)
+        return {} if parsed.nil? # a "null" file has long meant an empty resultset
+
+        # Valid JSON need not be an object ("[1,2]" and "\"x\"" parse
+        # fine), but everything downstream iterates command => data
+        # pairs, so anything else would crash out of the middle of a
+        # merge. Same tolerance as a parse failure: warn and move on.
+        parsed.is_a?(Hash) ? drop_malformed_entries(parsed) : invalid_resultset
+      rescue StandardError
+        invalid_resultset
+      end
+
+      # Each surviving entry must have the shape every consumer relies
+      # on: a Hash carrying a Numeric "timestamp" (the merge-timeout
+      # check) and a Hash "coverage" (the merge fold). A truncated or
+      # hand-edited entry would otherwise crash out of the middle of an
+      # at_exit merge, so it gets the same warn-and-move-on treatment
+      # as an unparseable file.
+      def drop_malformed_entries(resultset)
+        malformed, valid = resultset.partition { |_command_name, data| !well_formed_entry?(data) }
+        return resultset if malformed.empty?
+
+        warn "[SimpleCov]: Warning! Ignoring malformed resultset entries: #{malformed.map(&:first).sort.join(', ')}"
+        valid.to_h
+      end
+
+      def well_formed_entry?(data)
+        data.is_a?(Hash) && data["timestamp"].is_a?(Numeric) && data["coverage"].is_a?(Hash)
+      end
+
+      def invalid_resultset
+        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
+        {}
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_run_identity.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    # Run/worker metadata queries used by resultset storage and parallel
+    # coordination. Kept separate from the coverage-folding implementation.
+    module ResultsetRunIdentity
+      # One namespaced identity per distinct worker that wrote to the
+      # current run: `[:worker, id]` for entries that carry a worker id,
+      # `[:legacy, command_name]` for fresh entries written without one
+      # (an old SimpleCov writing to the same resultset). Pairs rather
+      # than mangled strings, so a resultset mixing both kinds can never
+      # alias a real worker id to a synthesized legacy identity.
+      def worker_identities_for_run(results, run_id, started_at)
+        results.filter_map do |command_name, data|
+          next unless current_run_entry?(data, run_id, started_at)
+
+          worker_id = data["worker_id"]
+          worker_id.to_s.empty? ? [:legacy, command_name] : [:worker, worker_id.to_s]
+        end.uniq
+      end
+
+      def current_run_entry?(entry, run_id, started_at)
+        return false unless entry.is_a?(Hash)
+
+        entry_run_id = entry["run_id"]
+        return fresh_entry?(entry, started_at) unless entry_run_id
+        return false unless run_id && entry_run_id == run_id
+        return true if SimpleCov::RunIdentity.authoritative?
+
+        fresh_entry?(entry, started_at)
+      end
+
+      def fresh_entry?(entry, started_at)
+        timestamp = entry["timestamp"]
+        timestamp.is_a?(Numeric) && started_at && timestamp >= started_at.to_f
+      end
+
+      # Whether `entry` was written by a runner concurrent with this
+      # process: either it shares our run id (`current_run_entry?`), or it
+      # was written strictly after our process started. A mismatched run
+      # id must not defeat the timestamp check — a subprocess we shelled
+      # out to (fork+exec) generates its own random run id, and its
+      # freshly written entry is exactly the data issue #581 protects
+      # from being clobbered. Strict id matching is reserved for worker
+      # counting (`worker_identities_for_run`), where admitting a stale
+      # entry would end a sibling wait early.
+      def concurrent_runner_entry?(entry, incoming = nil)
+        return false unless entry.is_a?(Hash)
+
+        incoming_run_id = incoming["run_id"] if incoming.is_a?(Hash)
+        started_at = SimpleCov.process_start_time
+        return true if current_run_entry?(entry, incoming_run_id, started_at)
+
+        written_after_start?(entry, started_at)
+      end
+
+      # Strictly after, unlike `fresh_entry?`: an entry stamped at the
+      # exact instant we started is treated as leftover from a previous
+      # run, so a same-second stale entry is still overwritten.
+      def written_after_start?(entry, started_at)
+        timestamp = entry["timestamp"]
+        timestamp.is_a?(Numeric) && started_at && timestamp > started_at.to_f
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger/resultset_store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "monitor"
+require_relative "../atomic_file"
+
+module SimpleCov
+  module ResultMerger
+    # Reads and writes the persistent `.resultset.json` cache, including
+    # file-lock synchronization between processes and atomic temp-file
+    # renames so concurrent readers don't observe a truncated file.
+    module ResultsetStore
+      LOCK_MONITOR = Monitor.new
+      private_constant :LOCK_MONITOR
+
+    module_function
+
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
+      end
+
+      def writelock_path
+        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+      end
+
+      # Compact JSON, not pretty-printed: this is a machine-read cache
+      # that every parallel worker rewrites wholesale, and on a large
+      # project pretty printing nearly doubles the bytes written, read
+      # back, and parsed on each of those store-merge round trips.
+      def write(resultset)
+        AtomicFile.write(resultset_path, "#{JSON.generate(resultset)}\n")
+      end
+
+      # Serialize threads before taking the process-wide file lock. Nested
+      # calls by the owning thread bypass flock so they cannot deadlock on a
+      # second descriptor for the same lock file.
+      def synchronize(&)
+        return yield if LOCK_MONITOR.mon_owned?
+
+        LOCK_MONITOR.synchronize { with_flock(&) }
+      end
+
+      def with_flock
+        FileUtils.mkdir_p(SimpleCov.coverage_path)
+        File.open(writelock_path, "w+") do |f|
+          f.flock(File::LOCK_EX)
+          yield
+        end
+      end
+    end
+  end
+end