simplecov 0.18.4 → 0.21.0

data/README.md

@@ -1,4 +1,4 @@
-SimpleCov [![Gem Version](https://badge.fury.io/rb/simplecov.svg)](https://badge.fury.io/rb/simplecov) [![Build Status](https://github.com/colszowka/simplecov/workflows/stable/badge.svg?branch=master)][Continuous Integration] [![Code Climate](https://codeclimate.com/github/colszowka/simplecov.svg)](https://codeclimate.com/github/colszowka/simplecov) [![Inline docs](http://inch-ci.org/github/colszowka/simplecov.svg)](http://inch-ci.org/github/colszowka/simplecov)
+SimpleCov [![Gem Version](https://badge.fury.io/rb/simplecov.svg)](https://badge.fury.io/rb/simplecov) [![Build Status](https://github.com/simplecov-ruby/simplecov/workflows/stable/badge.svg?branch=main)][Continuous Integration] [![Maintainability](https://api.codeclimate.com/v1/badges/c071d197d61953a7e482/maintainability)](https://codeclimate.com/github/simplecov-ruby/simplecov/maintainability) [![Inline docs](http://inch-ci.org/github/simplecov-ruby/simplecov.svg?branch=main)](http://inch-ci.org/github/simplecov-ruby/simplecov)
 =========
 
 **Code coverage for Ruby**
@@ -10,14 +10,14 @@ SimpleCov [![Gem Version](https://badge.fury.io/rb/simplecov.svg)](https://badge
   * [Continuous Integration]
 
 [Coverage]: https://ruby-doc.org/stdlib/libdoc/coverage/rdoc/Coverage.html "API doc for Ruby's Coverage library"
-[Source Code]: https://github.com/colszowka/simplecov "Source Code @ GitHub"
+[Source Code]: https://github.com/simplecov-ruby/simplecov "Source Code @ GitHub"
 [API documentation]: http://rubydoc.info/gems/simplecov/frames "RDoc API Documentation at Rubydoc.info"
 [Configuration]: http://rubydoc.info/gems/simplecov/SimpleCov/Configuration "Configuration options API documentation"
-[Changelog]: https://github.com/colszowka/simplecov/blob/master/CHANGELOG.md "Project Changelog"
+[Changelog]: https://github.com/simplecov-ruby/simplecov/blob/main/CHANGELOG.md "Project Changelog"
 [Rubygem]: http://rubygems.org/gems/simplecov "SimpleCov @ rubygems.org"
-[Continuous Integration]: https://github.com/colszowka/simplecov/actions?query=workflow%3Astable "SimpleCov is built around the clock by github.com"
-[Dependencies]: https://gemnasium.com/colszowka/simplecov "SimpleCov dependencies on Gemnasium"
-[simplecov-html]: https://github.com/colszowka/simplecov-html "SimpleCov HTML Formatter Source Code @ GitHub"
+[Continuous Integration]: https://github.com/simplecov-ruby/simplecov/actions?query=workflow%3Astable "SimpleCov is built around the clock by github.com"
+[Dependencies]: https://gemnasium.com/simplecov-ruby/simplecov "SimpleCov dependencies on Gemnasium"
+[simplecov-html]: https://github.com/simplecov-ruby/simplecov-html "SimpleCov HTML Formatter Source Code @ GitHub"
 
 SimpleCov is a code coverage analysis tool for Ruby. It uses [Ruby's built-in Coverage][Coverage] library to gather code
 coverage data, but makes processing its results much easier by providing a clean API to filter, group, merge, format,
@@ -37,8 +37,8 @@ configured automatically when you launch SimpleCov. If you're curious, you can f
 
 *Code and Bug Reports*
 
-* [Issue Tracker](https://github.com/colszowka/simplecov/issues)
-* See [CONTRIBUTING](https://github.com/colszowka/simplecov/blob/master/CONTRIBUTING.md) for how to contribute along
+* [Issue Tracker](https://github.com/simplecov-ruby/simplecov/issues)
+* See [CONTRIBUTING](https://github.com/simplecov-ruby/simplecov/blob/main/CONTRIBUTING.md) for how to contribute along
 with some common problems to check out before creating an issue.
 
 *Questions, Problems, Suggestions, etc.*
@@ -73,9 +73,10 @@ Getting started
     analysis to happen on. When testing a server process (e.g. a JSON API
     endpoint) via a separate test process (e.g. when using Selenium) where you
     want to see all code executed by the `rails server`, and not just code
-    executed in your actual test files, you'll want to add something like this
+    executed in your actual test files, you need to require SimpleCov in the
+    server process. For rails for instance, you'll want to add something like this
     to the top of `bin/rails`, but below the "shebang" line (`#! /usr/bin/env
-    ruby`):
+    ruby`) and after config/boot is required:
 
     ```ruby
     if ENV['RAILS_ENV'] == 'test'
@@ -167,8 +168,8 @@ to use SimpleCov with them. Here's an overview of the known ones:
       race conditions occur when results are merged.
     </td>
     <td>
-      <a href="https://github.com/colszowka/simplecov/issues/64">#64</a> &amp;
-      <a href="https://github.com/colszowka/simplecov/pull/185">#185</a>
+      <a href="https://github.com/simplecov-ruby/simplecov/issues/64">#64</a> &amp;
+      <a href="https://github.com/simplecov-ruby/simplecov/pull/185">#185</a>
     </td>
   </tr>
   <tr>
@@ -192,7 +193,7 @@ to use SimpleCov with them. Here's an overview of the known ones:
       to explicitly set the output root using `SimpleCov.root('foo/bar/baz')`
     </td>
     <td>
-      <a href="https://github.com/colszowka/simplecov/issues/95">#95</a>
+      <a href="https://github.com/simplecov-ruby/simplecov/issues/95">#95</a>
     </td>
   </tr>
   <tr>
@@ -203,11 +204,11 @@ to use SimpleCov with them. Here's an overview of the known ones:
       Because of how Spork works internally (using preforking), there used to
       be trouble when using SimpleCov with it, but that has apparently been
       resolved with a specific configuration strategy. See <a
-      href="https://github.com/colszowka/simplecov/issues/42#issuecomment-4440284">this</a>
+      href="https://github.com/simplecov-ruby/simplecov/issues/42#issuecomment-4440284">this</a>
       comment.
     </td>
     <td>
-      <a href="https://github.com/colszowka/simplecov/issues/42#issuecomment-4440284">#42</a>
+      <a href="https://github.com/simplecov-ruby/simplecov/issues/42#issuecomment-4440284">#42</a>
     </td>
   </tr>
   <tr>
@@ -218,7 +219,7 @@ to use SimpleCov with them. Here's an overview of the known ones:
       <a href="#want-to-use-spring-with-simplecov">See section below.</a>
     </td>
     <td>
-      <a href="https://github.com/colszowka/simplecov/issues/381">#381</a>
+      <a href="https://github.com/simplecov-ruby/simplecov/issues/381">#381</a>
     </td>
   </tr>
   <tr>
@@ -231,7 +232,7 @@ to use SimpleCov with them. Here's an overview of the known ones:
       (Dec 11th, 2011) should have this problem resolved.
     </td>
     <td>
-      <a href="https://github.com/colszowka/simplecov/issues/45">#45</a> &amp;
+      <a href="https://github.com/simplecov-ruby/simplecov/issues/45">#45</a> &amp;
       <a href="https://github.com/test-unit/test-unit/pull/12">test-unit/test-unit#12</a>
     </td>
   </tr>
@@ -294,7 +295,6 @@ information to be lost.
 Add branch coverage measurement statistics to your results. Supported in CRuby versions 2.5+.
 
 ```ruby
-# or in configure or just SimpleCov.enable_coverage :branch
 SimpleCov.start do
   enable_coverage :branch
 end
@@ -340,6 +340,22 @@ Hence, we recommend looking at both metrics together. Branch coverage might also
 overall metric to look at - while you might be missing only 10% of your lines that might
 account for 50% of your branches for instance.
 
+## Primary Coverage
+
+By default, the primary coverage type is `line`. To set the primary coverage to something else, use the following:
+
+```ruby
+# or in configure SimpleCov.primary_coverage :branch
+SimpleCov.start do
+  enable_coverage :branch
+  primary_coverage :branch
+end
+```
+
+Primary coverage determines what will come in first all output, and the type of coverage to check if you don't specify the type of coverage when customizing exit behavior (`SimpleCov.minimum_coverage 90`).
+
+Note that coverage must first be enabled for non-default coverage types.
+
 ## Filters
 
 Filters can be used to remove selected files from your coverage data. By default, a filter is applied that removes all
@@ -429,7 +445,7 @@ end
 # :nocov:
 ```
 
-The name of the token can be changed to your liking. [Learn more about the nocov feature.]( https://github.com/colszowka/simplecov/blob/master/features/config_nocov_token.feature)
+The name of the token can be changed to your liking. [Learn more about the nocov feature.]( https://github.com/simplecov-ruby/simplecov/blob/main/features/config_nocov_token.feature)
 
 **Note:** You shouldn't have to use the nocov token to skip private methods that are being included in your coverage. If
 you appropriately test the public interface of your classes and objects you should automatically get full coverage of
@@ -440,7 +456,7 @@ your private methods.
 By default, SimpleCov filters everything outside of the `SimpleCov.root` directory. However, sometimes you may want
 to include coverage reports for things you include as a gem, for example a Rails Engine.
 
-Here's an example by [@lsaffie](https://github.com/lsaffie) from [#221](https://github.com/colszowka/simplecov/issues/221)
+Here's an example by [@lsaffie](https://github.com/lsaffie) from [#221](https://github.com/simplecov-ruby/simplecov/issues/221)
 that shows how you can achieve just that:
 
 ```ruby
@@ -614,6 +630,53 @@ namespace :coverage do
 end
 ```
 
+## Running simplecov against subprocesses
+
+`SimpleCov.enable_for_subprocesses` will allow SimpleCov to observe subprocesses starting using `Process.fork`.
+This modifies ruby's core Process.fork method so that SimpleCov can see into it, appending `" (subprocess #{pid})"`
+to the `SimpleCov.command_name`, with results that can be merged together using SimpleCov's merging feature.
+
+To configure this, use `.at_fork`.
+
+```ruby
+SimpleCov.enable_for_subprocesses true
+SimpleCov.at_fork do |pid|
+  # This needs a unique name so it won't be ovewritten
+  SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{pid})"
+  # be quiet, the parent process will be in charge of output and checking coverage totals
+  SimpleCov.print_error_status = false
+  SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+  SimpleCov.minimum_coverage 0
+  # start
+  SimpleCov.start
+end
+```
+
+NOTE: SimpleCov must have already been started before `Process.fork` was called.
+
+### Running simplecov against spawned subprocesses
+
+Perhaps you're testing a ruby script with `PTY.spawn` or `Open3.popen`, or `Process.spawn` or etc.
+SimpleCov can cover this too.
+
+Add a .simplecov_spawn.rb file to your project root
+```ruby
+# .simplecov_spawn.rb
+require 'simplecov' # this will also pick up whatever config is in .simplecov
+                    # so ensure it just contains configuration, and doesn't call SimpleCov.start.
+SimpleCov.command_name 'spawn' # As this is not for a test runner directly, script doesn't have a pre-defined base command_name
+SimpleCov.at_fork.call(Process.pid) # Use the per-process setup described previously
+SimpleCov.start # only now can we start.
+```
+Then, instead of calling your script directly, like:
+```ruby
+PTY.spawn('my_script.rb') do # ...
+```
+Use bin/ruby to require the new .simplecov_spawn file, then your script
+```ruby
+PTY.spawn('ruby -r./.simplecov_spawn my_script.rb') do # ...
+```
+
 ## Running coverage only on demand
 
 The Ruby STDLIB Coverage library that SimpleCov builds upon is *very* fast (on a ~10 min Rails test suite, the speed
@@ -739,30 +802,36 @@ to help ensure coverage is relatively consistent, rather than being skewed by pa
 
 ```ruby
 SimpleCov.minimum_coverage_by_file 80
+# same as above (the default is to check line coverage by file)
+SimpleCov.minimum_coverage_by_file line: 80
+# check for a minimum line coverage by file of 90% and minimum 80% branch coverage
+SimpleCov.minimum_coverage_by_file line: 90, branch: 80
 ```
 
-(not yet supported for branch coverage)
-
 ### Maximum coverage drop
 
 You can define the maximum coverage drop percentage at once. SimpleCov will return non-zero if exceeded.
 
 ```ruby
 SimpleCov.maximum_coverage_drop 5
+# same as above (the default is to check line drop)
+SimpleCov.maximum_coverage_drop line: 5
+# check for a maximum line drop of 5% and maximum 10% branch drop
+SimpleCov.maximum_coverage_drop line: 5, branch: 10
 ```
 
-(not yet supported for branch coverage)
-
 ### Refuse dropping coverage
 
 You can also entirely refuse dropping coverage between test runs:
 
 ```ruby
 SimpleCov.refuse_coverage_drop
+# same as above (the default is to only refuse line drop)
+SimpleCov.refuse_coverage_drop :line
+# refuse drop for line and branch
+SimpleCov.refuse_coverage_drop :line, :branch
 ```
 
-(not yet supported for branch coverage)
-
 ## Using your own formatter
 
 You can use your own formatter with:
@@ -786,6 +855,20 @@ SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
 ])
 ```
 
+## JSON formatter
+
+SimpleCov is packaged with a separate gem called [simplecov_json_formatter](https://github.com/codeclimate-community/simplecov_json_formatter) that provides you with a JSON formatter, this formatter could be useful for different use cases, such as for CI consumption or for reporting to external services.
+
+In order to use it you will need to manually load the installed gem like so:
+
+```ruby
+require "simplecov_json_formatter"
+SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
+```
+
+> _Note:_ In case you plan to report your coverage results to CodeClimate services, know that SimpleCov will automatically use the
+>  JSON formatter along with the HTML formatter when the `CC_TEST_REPORTER_ID` variable is present in the environment.
+
 ## Available formatters, editor integrations and hosted services
 
   * [Open Source formatter and integration plugins for SimpleCov](doc/alternate-formatters.md)
@@ -794,7 +877,7 @@ SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
 
 ## Ruby version compatibility
 
-SimpleCov is built in [Continuous Integration] on Ruby 2.4+ as well as JRuby 9.2+.
+SimpleCov is built in [Continuous Integration] on Ruby 2.5+ as well as JRuby 9.2+.
 
 Note for JRuby => You need to pass JRUBY_OPTS="--debug" or create .jrubyrc and add debug.fullTrace=true
 
@@ -809,7 +892,7 @@ with them, you'll find that it often misreports coverage with the default config
 issue. Don't despair!
 
 One solution is to [explicitly call eager
-load](https://github.com/colszowka/simplecov/issues/381#issuecomment-347651728)
+load](https://github.com/simplecov-ruby/simplecov/issues/381#issuecomment-347651728)
 in your `test_helper.rb` / `spec_helper.rb` after calling `SimpleCov.start`.
 
 ```ruby
@@ -868,7 +951,7 @@ Everyone participating in this project's development, issue trackers and other c
 
 ## Contributing
 
-See the [contributing guide](https://github.com/colszowka/simplecov/blob/master/CONTRIBUTING.md).
+See the [contributing guide](https://github.com/simplecov-ruby/simplecov/blob/main/CONTRIBUTING.md).
 
 ## Kudos
 

data/doc/alternate-formatters.md

@@ -1,7 +1,7 @@
 ## Alternate coverage report formatters
 
 The community around simplecov provides a whole bunch of alternate formatters beyond the official
-[simplecov-html](https://github.com/colszowka/simplecov-html) gem.
+[simplecov-html](https://github.com/simplecov-ruby/simplecov-html) gem.
 
 If you have built or found one that is missing here, please send a Pull Request for this document!
 
@@ -15,6 +15,11 @@ A formatter that generates a coverage badge for use in your project's readme usi
 
 A formatter that generates a small coverage badge for use in your project's readme using the SVG.
 
+#### [simplecov_badger](https://github.com/traels-it/simplecov_badger)
+*by traels.it*
+
+A formatter that uploads your coverage to a server, that will then host a SVG badge of the score. No need to have the badge stored in repository.
+
 #### [simplecov-cobertura](https://github.com/dashingrocket/simplecov-cobertura)
 *by Jesse Bowes*
 
@@ -55,7 +60,12 @@ A formatter that prints the coverage of the file under test when you run a singl
 
 t_wada AA formatter for SimpleCov
 
-#### [simplecov-material(https://github.com/chiefpansancolt/simplecov-material)
+#### [simplecov-tailwindcss](https://github.com/chiefpansancolt/simplecov-tailwindcss)
+*by [Chiefpansancolt](https://github.com/chiefpansancolt)*
+
+A TailwindCSS & TailwindUI Designed HTML formatter with clean and easy search of files with a tabular left Navigation.
+
+#### [simplecov-material](https://github.com/chiefpansancolt/simplecov-material)
 *by [Chiefpansancolt](https://github.com/chiefpansancolt)*
 
 A Material Designed HTML formatter with clean and easy search of files with a tabular left Navigation.

data/doc/commercial-services.md

@@ -4,6 +4,11 @@ There is a bunch of services that offer integration with your existing CI pipeli
 reports. Please note these are not associated with the SimpleCov project itself, so please report problems with
 these integrations with their respective owners.
 
+#### [Codacy](https://github.com/codacy/codacy-coverage-reporter)
+*by [Codacy](https://www.codacy.com/)*
+
+Upload coverage reports to [codacy.com](https://www.codacy.com/), a hosted (or self-hosted) software quality analysis platform that also includes coverage reporting.
+
 #### [codeclimate](https://github.com/codeclimate/ruby-test-reporter)
 *by [Code Climate](https://codeclimate.com/)*
 

data/lib/minitest/simplecov_plugin.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-# How minitest plugins. See https://github.com/colszowka/simplecov/pull/756 for why we need this.
+# How minitest plugins. See https://github.com/simplecov-ruby/simplecov/pull/756 for why we need this.
 # https://github.com/seattlerb/minitest#writing-extensions
 module Minitest
   def self.plugin_simplecov_init(_options)
-    SimpleCov.external_at_exit = true
+    if defined?(SimpleCov)
+      SimpleCov.external_at_exit = true
 
-    Minitest.after_run do
-      SimpleCov.at_exit_behavior if SimpleCov.respond_to?(:at_exit_behavior)
+      Minitest.after_run do
+        SimpleCov.at_exit_behavior
+      end
     end
   end
 end

data/lib/simplecov.rb

@@ -3,19 +3,17 @@
 require "English"
 
 # Coverage may be inaccurate under JRUBY.
-if defined?(JRUBY_VERSION) && defined?(JRuby)
+if defined?(JRUBY_VERSION) && defined?(JRuby) && !org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
 
   # @see https://github.com/jruby/jruby/issues/1196
   # @see https://github.com/metricfu/metric_fu/pull/226
-  # @see https://github.com/colszowka/simplecov/issues/420
-  # @see https://github.com/colszowka/simplecov/issues/86
+  # @see https://github.com/simplecov-ruby/simplecov/issues/420
+  # @see https://github.com/simplecov-ruby/simplecov/issues/86
   # @see https://jira.codehaus.org/browse/JRUBY-6106
 
-  unless org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
-    warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
-      ' or do JRUBY_OPTS="--debug"' \
-      ' or set the "debug.fullTrace=true" option in your .jrubyrc'
-  end
+  warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
+    ' or do JRUBY_OPTS="--debug"' \
+    ' or set the "debug.fullTrace=true" option in your .jrubyrc'
 end
 
 #
@@ -23,9 +21,7 @@ end
 #
 module SimpleCov
   class << self
-    attr_accessor :running
-    attr_accessor :pid
-    attr_reader :exit_exception
+    attr_accessor :running, :pid
 
     # Basically, should we take care of at_exit behavior or something else?
     # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
@@ -52,6 +48,11 @@ module SimpleCov
     def start(profile = nil, &block)
       require "coverage"
       initial_setup(profile, &block)
+      require_relative "./simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
+                                                ::Process.respond_to?(:fork)
+
+      make_parallel_tests_available
+
       @result = nil
       self.pid = Process.pid
 
@@ -60,6 +61,7 @@ module SimpleCov
 
     #
     # Collate a series of SimpleCov result files into a single SimpleCov output.
+    #
     # You can optionally specify configuration with a block:
     #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
     #    OR
@@ -77,20 +79,17 @@ module SimpleCov
     # available config options, or checkout the README for more in-depth
     # information about coverage collation
     #
-    def collate(result_filenames, profile = nil, &block)
-      raise "There's no reports to be merged" if result_filenames.empty?
+    # By default `collate` ignores the merge_timeout so all results of all files specified will be
+    # merged together. If you want to honor the merge_timeout then provide the keyword argument
+    # `ignore_timeout: false`.
+    #
+    def collate(result_filenames, profile = nil, ignore_timeout: true, &block)
+      raise "There are no reports to be merged" if result_filenames.empty?
 
       initial_setup(profile, &block)
 
-      results = result_filenames.flat_map do |filename|
-        # Re-create each included instance of SimpleCov::Result from the stored run data.
-        (JSON.parse(File.read(filename)) || {}).map do |command_name, coverage|
-          SimpleCov::Result.from_hash(command_name => coverage)
-        end
-      end
-
       # Use the ResultMerger to produce a single, merged result, ready to use.
-      @result = SimpleCov::ResultMerger.merge_and_store(*results)
+      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
 
       run_exit_tasks!
     end
@@ -103,7 +102,6 @@ module SimpleCov
       return @result if result?
 
       # Collect our coverage result
-
       process_coverage_result if running
 
       # If we're using merging of results, store the current result
@@ -173,54 +171,71 @@ module SimpleCov
       @result = nil
     end
 
+    def at_exit_behavior
+      # If we are in a different process than called start, don't interfere.
+      return if SimpleCov.pid != Process.pid
+
+      # If SimpleCov is no longer running then don't run exit tasks
+      SimpleCov.run_exit_tasks! if SimpleCov.running
+    end
+
+    # @api private
     #
-    # Capture the current exception if it exists
-    # This will get called inside the at_exit block
+    # Called from at_exit block
     #
-    def set_exit_exception
-      @exit_exception = $ERROR_INFO
+    def run_exit_tasks!
+      error_exit_status = exit_status_from_exception
+
+      at_exit.call
+
+      exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
+      process_results_and_report_error if ready_to_process_results?
     end
 
+    #
+    # @api private
     #
     # Returns the exit status from the exit exception
     #
     def exit_status_from_exception
-      return SimpleCov::ExitCodes::SUCCESS unless exit_exception
+      # Capture the current exception if it exists
+      @exit_exception = $ERROR_INFO
+      return nil unless @exit_exception
 
-      if exit_exception.is_a?(SystemExit)
-        exit_exception.status
+      if @exit_exception.is_a?(SystemExit)
+        @exit_exception.status
       else
         SimpleCov::ExitCodes::EXCEPTION
       end
     end
 
-    def at_exit_behavior
-      # If we are in a different process than called start, don't interfere.
-      return if SimpleCov.pid != Process.pid
-
-      # If SimpleCov is no longer running then don't run exit tasks
-      SimpleCov.run_exit_tasks! if SimpleCov.running
+    # @api private
+    def previous_error?(error_exit_status)
+      # Normally it'd be enough to check for previous error but when running test_unit
+      # status is 0
+      error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS
     end
 
-    # @api private
     #
-    # Called from at_exit block
+    # @api private
     #
-    def run_exit_tasks!
-      set_exit_exception
-
-      exit_status = SimpleCov.exit_status_from_exception
+    # Thinking: Move this behavior earlier so if there was an error we do nothing?
+    def exit_and_report_previous_error(exit_status)
+      warn("Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected") if print_error_status
+      Kernel.exit(exit_status)
+    end
 
-      SimpleCov.at_exit.call
+    # @api private
+    def ready_to_process_results?
+      final_result_process? && result?
+    end
 
-      # Don't modify the exit status unless the result has already been
-      # computed
-      exit_status = SimpleCov.process_result(SimpleCov.result, exit_status) if SimpleCov.result?
+    def process_results_and_report_error
+      exit_status = process_result(result)
 
       # Force exit with stored status (see github issue #5)
-      # unless it's nil or 0 (see github issue #281)
-      if exit_status&.positive?
-        $stderr.printf("SimpleCov failed with exit %<exit_status>d\n", exit_status: exit_status) if print_error_status
+      if exit_status.positive?
+        warn("SimpleCov failed with exit #{exit_status} due to a coverage related error") if print_error_status
         Kernel.exit exit_status
       end
     end
@@ -230,55 +245,29 @@ module SimpleCov
     # Usage:
     #   exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
     #
-    def process_result(result, exit_status)
-      return exit_status if exit_status != SimpleCov::ExitCodes::SUCCESS # Existing errors
-
-      covered_percent = result.covered_percent.floor(2)
-      result_exit_status = result_exit_status(result, covered_percent)
-      write_last_run(covered_percent) if result_exit_status == SimpleCov::ExitCodes::SUCCESS # No result errors
-      final_result_process? ? result_exit_status : SimpleCov::ExitCodes::SUCCESS
+    def process_result(result)
+      result_exit_status = result_exit_status(result)
+      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
+      result_exit_status
     end
 
     # @api private
-    #
-    # rubocop:disable Metrics/MethodLength
-    def result_exit_status(result, covered_percent)
-      covered_percentages = result.covered_percentages.map { |percentage| percentage.floor(2) }
-      if (minimum_violations = minimum_coverage_violated(result)).any?
-        report_minimum_violated(minimum_violations)
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file }
-        $stderr.printf(
-          "File (%<file>s) is only (%<least_covered_percentage>.2f%%) covered. This is below the expected minimum coverage per file of (%<min_coverage>.2f%%).\n",
-          file: result.least_covered_file,
-          least_covered_percentage: covered_percentages.min,
-          min_coverage: SimpleCov.minimum_coverage_by_file
-        )
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif (last_run = SimpleCov::LastRun.read)
-        coverage_diff = last_run[:result][:covered_percent] - covered_percent
-        if coverage_diff > SimpleCov.maximum_coverage_drop
-          $stderr.printf(
-            "Coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
-            drop_percent: coverage_diff,
-            max_drop: SimpleCov.maximum_coverage_drop
-          )
-          SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-        else
-          SimpleCov::ExitCodes::SUCCESS
-        end
-      else
-        SimpleCov::ExitCodes::SUCCESS
-      end
+    CoverageLimits = Struct.new(:minimum_coverage, :minimum_coverage_by_file, :maximum_coverage_drop, keyword_init: true)
+    def result_exit_status(result)
+      coverage_limits = CoverageLimits.new(
+        minimum_coverage: minimum_coverage, minimum_coverage_by_file: minimum_coverage_by_file,
+        maximum_coverage_drop: maximum_coverage_drop
+      )
+
+      ExitCodes::ExitCodeHandling.call(result, coverage_limits: coverage_limits)
     end
-    # rubocop:enable Metrics/MethodLength
 
     #
     # @api private
     #
     def final_result_process?
-      # checking for ENV["TEST_ENV_NUMBER"] to determine if the tess are being run in parallel
-      !defined?(ParallelTests) || !ENV["TEST_ENV_NUMBER"] || ParallelTests.number_of_running_processes <= 1
+      # checking for ENV["TEST_ENV_NUMBER"] to determine if the tests are being run in parallel
+      !defined?(ParallelTests) || !ENV["TEST_ENV_NUMBER"] || ParallelTests.last_process?
     end
 
     #
@@ -293,8 +282,19 @@ module SimpleCov
     #
     # @api private
     #
-    def write_last_run(covered_percent)
-      SimpleCov::LastRun.write(result: {covered_percent: covered_percent})
+    def write_last_run(result)
+      SimpleCov::LastRun.write(result:
+        result.coverage_statistics.transform_values do |stats|
+          round_coverage(stats.percent)
+        end)
+    end
+
+    #
+    # @api private
+    #
+    # Rounding down to be extra strict, see #679
+    def round_coverage(coverage)
+      coverage.floor(2)
     end
 
   private
@@ -315,7 +315,7 @@ module SimpleCov
       # This blog post gives a good run down of the coverage criterias introduced
       # in Ruby 2.5: https://blog.bigbinary.com/2018/04/11/ruby-2-5-supports-measuring-branch-and-method-coverages.html
       # There is also a nice writeup of the different coverage criteria made in this
-      # comment  https://github.com/colszowka/simplecov/pull/692#discussion_r281836176 :
+      # comment  https://github.com/simplecov-ruby/simplecov/pull/692#discussion_r281836176 :
       # Ruby < 2.5:
       # https://github.com/ruby/ruby/blob/v1_9_3_374/ext/coverage/coverage.c
       # traditional mode (Array)
@@ -419,61 +419,50 @@ module SimpleCov
       @result = SimpleCov::Result.new(add_not_loaded_files(@result))
     end
 
-    def minimum_coverage_violated(result)
-      coverage_achieved = minimum_coverage.map do |criterion, percent|
-        {
-          criterion: criterion,
-          minimum_expected: percent,
-          actual: result.coverage_statistics[criterion].percent
-        }
-      end
+    # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772
+    def make_parallel_tests_available
+      return if defined?(ParallelTests)
+      return unless probably_running_parallel_tests?
 
-      coverage_achieved.select do |achieved|
-        achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-      end
+      require "parallel_tests"
+    rescue LoadError
+      warn("SimpleCov guessed you were running inside parallel tests but couldn't load it. Please file a bug report with us!")
     end
 
-    def report_minimum_violated(violations)
-      violations.each do |violation|
-        $stderr.printf(
-          "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-          covered: violation.fetch(:actual).floor(2),
-          minimum_coverage: violation.fetch(:minimum_expected),
-          criterion: violation.fetch(:criterion).capitalize
-        )
-      end
+    def probably_running_parallel_tests?
+      ENV["TEST_ENV_NUMBER"] && ENV["PARALLEL_TEST_GROUPS"]
     end
   end
 end
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
+# requires are down here here for a load order reason I'm not sure what it is about
 require "set"
 require "forwardable"
-require "simplecov/configuration"
+require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
-require "simplecov/coverage_statistics"
-require "simplecov/exit_codes"
-require "simplecov/profiles"
-require "simplecov/source_file/line"
-require "simplecov/source_file/branch"
-require "simplecov/source_file"
-require "simplecov/file_list"
-require "simplecov/result"
-require "simplecov/filter"
-require "simplecov/formatter"
-require "simplecov/last_run"
-require "simplecov/lines_classifier"
-require "simplecov/result_merger"
-require "simplecov/command_guesser"
-require "simplecov/version"
-require "simplecov/result_adapter"
-require "simplecov/combine"
-require "simplecov/combine/branches_combiner"
-require "simplecov/combine/files_combiner"
-require "simplecov/combine/lines_combiner"
-require "simplecov/combine/results_combiner"
-require "simplecov/useless_results_remover"
-require "simplecov/simulate_coverage"
+require_relative "simplecov/coverage_statistics"
+require_relative "simplecov/exit_codes"
+require_relative "simplecov/profiles"
+require_relative "simplecov/source_file/line"
+require_relative "simplecov/source_file/branch"
+require_relative "simplecov/source_file"
+require_relative "simplecov/file_list"
+require_relative "simplecov/result"
+require_relative "simplecov/filter"
+require_relative "simplecov/formatter"
+require_relative "simplecov/last_run"
+require_relative "simplecov/lines_classifier"
+require_relative "simplecov/result_merger"
+require_relative "simplecov/command_guesser"
+require_relative "simplecov/version"
+require_relative "simplecov/result_adapter"
+require_relative "simplecov/combine"
+require_relative "simplecov/combine/branches_combiner"
+require_relative "simplecov/combine/files_combiner"
+require_relative "simplecov/combine/lines_combiner"
+require_relative "simplecov/combine/results_combiner"
+require_relative "simplecov/useless_results_remover"
+require_relative "simplecov/simulate_coverage"
 
 # Load default config
-require "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]
+require_relative "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]