simplecov 0.18.5 → 0.19.0

data/CONTRIBUTING.md

@@ -1,6 +1,6 @@
 ## Reporting Issues
 
-You can report issues at https://github.com/colszowka/simplecov/issues
+You can report issues at https://github.com/simplecov-ruby/simplecov/issues
 
 Before you go ahead please search existing issues for your problem, chances are someone else already reported it.
 
@@ -10,7 +10,7 @@ To make sure that we can help you quickly please include and check the following
     - please ensure you are requiring and starting SimpleCov before requiring any application code.
     - If running via rake, please ensure you are requiring SimpleCov at the top of your Rakefile
       For example, if running via RSpec, this would be at the top of your spec_helper.
-    - Have you tried using a [`.simplecov` file](https://github.com/colszowka/simplecov#using-simplecov-for-centralized-config)?
+    - Have you tried using a [`.simplecov` file](https://github.com/simplecov-ruby/simplecov#using-simplecov-for-centralized-config)?
  * Include the SimpleCov version you are running in your report.
  * If you are not running the latest version (please check), and you cannot update it,
    please specify in your report why you can't update to the latest version.
@@ -28,7 +28,7 @@ Thanks!
 
 To fetch & test the library for development, do:
 
-    $ git clone https://github.com/colszowka/simplecov.git
+    $ git clone https://github.com/simplecov-ruby/simplecov.git
     $ cd simplecov
     $ bundle
     $ bundle exec rake

data/ISSUE_TEMPLATE.md

@@ -8,7 +8,7 @@ To make sure that we can help you quickly please include and check the following
     - please ensure you are requiring and starting SimpleCov before requiring any application code.
     - If running via rake, please ensure you are requiring SimpleCov at the top of your Rakefile
       For example, if running via RSpec, this would be at the top of your spec_helper.
-    - Have you tried using a [`.simplecov` file](https://github.com/colszowka/simplecov#using-simplecov-for-centralized-config)?
+    - Have you tried using a [`.simplecov` file](https://github.com/simplecov-ruby/simplecov#using-simplecov-for-centralized-config)?
  * Include the SimpleCov version you are running in your report.
  * If you are not running the latest version (please check), and you cannot update it,
    please specify in your report why you can't update to the latest version.

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.*
@@ -167,8 +167,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 +192,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 +203,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 +218,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 +231,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>
@@ -429,7 +429,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 +440,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 +614,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
@@ -794,7 +841,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 +856,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 +915,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,7 @@ 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-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,6 +1,6 @@
 # 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)

data/lib/simplecov.rb

@@ -7,8 +7,8 @@ if defined?(JRUBY_VERSION) && defined?(JRuby)
 
   # @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
@@ -23,9 +23,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 +50,9 @@ module SimpleCov
     def start(profile = nil, &block)
       require "coverage"
       initial_setup(profile, &block)
+      require_relative "./simplecov/process" if SimpleCov.enabled_for_subprocesses?
+      make_parallel_tests_available
+
       @result = nil
       self.pid = Process.pid
 
@@ -84,13 +85,11 @@ module SimpleCov
 
       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
+        Result.from_hash(JSON.parse(File.read(filename)) || {})
       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(*results)
 
       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,16 @@ 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: {covered_percent: round_coverage(result.covered_percent)})
+    end
+
+    #
+    # @api private
+    #
+    # Rounding down to be extra strict, see #679
+    def round_coverage(coverage)
+      coverage.floor(2)
     end
 
   private
@@ -315,7 +312,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 +416,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"]