simplecov 0.18.0.beta3 → 0.18.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5ac4654ad44859d2e7b68cc5375314766127720e33d51080cc02120d35cc9cb
-  data.tar.gz: 89ceeaf8b9b1a76bd05a4f078c50a80050bd247ef067164201f9721ce7378b5b
+  metadata.gz: 3d8b7307fd45fc7c4079efec764ee740fd7c0d302b8b78e969b11a08a2c94027
+  data.tar.gz: 4a39c982bdc16b038c8d4ff88e25498d34b3bf0a1eec6ed99ed2e444a0e5ada7
 SHA512:
-  metadata.gz: 8afee26e98b841b002d097d589afbbc8b892452897423c927b817b51696bb7063e3f2e849f462434b765fb09970fbb6759d31d5362ea5c6e90eb65e82824eb78
-  data.tar.gz: ed2f4ffab150fd1da883604eccec94a087184aeaadb4b4d6f1f7273efa6020d1034b9e2eebbc8b88a9c63c54d545ccd6db4f5db58ee29f8182703ed40281342e
+  metadata.gz: e7ce525f98807869dcfafa47e154aafa8047fe8e41685cab5d051400e615b056ee5629a0e18e0203f01af675761be3a57a413d9d4f8eb6a57b4260f4a6db6986
+  data.tar.gz: 3a0cc93b7ade626e432238d9ebc18514cbad27d6ea67fbd995c19a4cd40afe6c86486396531110f5f11e29cf65fad6dc81479ef9fdd68304f982257b05abf103

data/CHANGELOG.md

@@ -1,3 +1,66 @@
+0.18.5 (2020-02-25)
+===================
+
+Can you guess? Another bugfix release!
+
+## Bugfixes
+* minitest won't crash if SimpleCov isn't loaded - aka don't execute SimpleCov code in the minitest plugin if SimpleCov isn't loaded. Thanks to [@edariedl](https://github.com/edariedl) for the report of the peculiar problem in [#877](https://github.com/colszowka/simplecov/issues/877).
+
+0.18.4 (2020-02-24)
+===================
+
+Another small bugfix release 🙈 Fixes SimpleCov running with rspec-rails, which was broken due to our fixed minitest integration.
+
+## Bugfixes
+* SimpleCov will run again correctly when used with rspec-rails. The excellent bug report [#873](https://github.com/colszowka/simplecov/issues/873) by [@odlp](https://github.com/odlp) perfectly details what went wrong. Thanks to [@adam12](https://github.com/adam12) for the fix [#874](https://github.com/colszowka/simplecov/pull/874).
+
+
+0.18.3 (2020-02-23)
+===========
+
+Small bugfix release. It's especially recommended to upgrade simplecov-html as well because of bugs in the 0.12.0 release.
+
+## Bugfixes
+* Fix a regression related to file encodings as special characters were missing. Furthermore we now respect the magic `# encoding: ...` comment and read files in the right encoding. Thanks ([@Tietew](https://github.com/Tietew)) - see [#866](https://github.com/colszowka/simplecov/pull/866)
+* Use `Minitest.after_run` hook to trigger post-run hooks if `Minitest` is present. See [#756](https://github.com/colszowka/simplecov/pull/756) and [#855](https://github.com/colszowka/simplecov/pull/855) thanks ([@adam12](https://github.com/adam12))
+
+0.18.2 (2020-02-12)
+===================
+
+Small release just to allow you to use the new simplecov-html.
+
+## Enhancements
+* Relax simplecov-html requirement so that you're able to use [0.12.0](https://github.com/colszowka/simplecov-html/blob/master/CHANGELOG.md#0120-2020-02-12)
+
+0.18.1 (2020-01-31)
+===================
+
+Small Bugfix release.
+
+## Bugfixes
+* Just putting `# :nocov:` on top of a file or having an uneven number of them in general works again and acts as if ignoring until the end of the file. See [#846](https://github.com/colszowka/simplecov/issues/846) and thanks [@DannyBen](https://github.com/DannyBen) for the report.
+
+0.18.0 (2020-01-28)
+===================
+
+Huge release! Highlights are support for branch coverage (Ruby 2.5+) and dropping support for EOL'ed Ruby versions (< 2.4).
+Please also read the other beta patch notes.
+
+You can run with branch coverage by putting `enable_coverage :branch` into your SimpleCov configuration (like the `SimpleCov.start do .. end` block)
+
+## Enhancements
+* You can now define the minimum expected coverage by criterion like `minimum_coverage line: 90, branch: 80`
+* Memoized some internal data structures that didn't change to reduce SimpleCov overhead
+* Both `FileList` and `SourceFile` now have a `coverage` method that returns a hash that points from a coverage criterion to a `CoverageStatistics` object for uniform access to overall coverage statistics for both line and branch coverage
+
+## Bugfixes
+* we were losing precision by rounding the covered strength early, that has been removed. **For Formatters** this also means that you may need to round it yourself now.
+* Removed an inconsistency in how we treat skipped vs. irrelevant lines (see [#565](https://github.com/colszowka/simplecov/issues/565)) - SimpleCov's definition of 100% is now "You covered everything that you could" so if coverage is 0/0 that's counted as a 100% no matter if the lines were irrelevant or ignored/skipped
+
+## Noteworthy
+* `FileList` stopped inheriting from Array, it includes Enumerable so if you didn't use Array specific methods on it in formatters you should be fine
+* We needed to change an internal file format, which we use for merging across processes, to accommodate branch coverage. Sadly CodeClimate chose to use this file to report test coverage. Until a resolution is found the code climate test reporter won't work with SimpleCov for 0.18+, see [this issue on the test reporter](https://github.com/codeclimate/test-reporter/issues/413).
+
 0.18.0.beta3 (2020-01-20)
 ========================
 

data/README.md

@@ -1,5 +1,6 @@
-SimpleCov [![Gem Version](https://badge.fury.io/rb/simplecov.svg)](https://badge.fury.io/rb/simplecov) [![Build Status](https://travis-ci.org/colszowka/simplecov.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/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)
 =========
+
 **Code coverage for Ruby**
 
   * [Source Code]
@@ -14,7 +15,7 @@ SimpleCov [![Gem Version](https://badge.fury.io/rb/simplecov.svg)](https://badge
 [Configuration]: http://rubydoc.info/gems/simplecov/SimpleCov/Configuration "Configuration options API documentation"
 [Changelog]: https://github.com/colszowka/simplecov/blob/master/CHANGELOG.md "Project Changelog"
 [Rubygem]: http://rubygems.org/gems/simplecov "SimpleCov @ rubygems.org"
-[Continuous Integration]: http://travis-ci.org/colszowka/simplecov "SimpleCov is built around the clock by travis-ci.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"
 
@@ -725,6 +726,10 @@ You can define the minimum coverage percentage expected. SimpleCov will return n
 
 ```ruby
 SimpleCov.minimum_coverage 90
+# same as above (the default is to check line coverage)
+SimpleCov.minimum_coverage line: 90
+# check for a minimum line coverage of 90% and minimum 80% branch coverage
+SimpleCov.minimum_coverage line: 90, branch: 80
 ```
 
 ### Minimum coverage by file
@@ -736,6 +741,8 @@ to help ensure coverage is relatively consistent, rather than being skewed by pa
 SimpleCov.minimum_coverage_by_file 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.
@@ -744,6 +751,8 @@ You can define the maximum coverage drop percentage at once. SimpleCov will retu
 SimpleCov.maximum_coverage_drop 5
 ```
 
+(not yet supported for branch coverage)
+
 ### Refuse dropping coverage
 
 You can also entirely refuse dropping coverage between test runs:
@@ -752,6 +761,8 @@ You can also entirely refuse dropping coverage between test runs:
 SimpleCov.refuse_coverage_drop
 ```
 
+(not yet supported for branch coverage)
+
 ## Using your own formatter
 
 You can use your own formatter with:

data/lib/minitest/simplecov_plugin.rb

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

data/lib/simplecov/combine/branches_combiner.rb

@@ -10,9 +10,9 @@ module SimpleCov
     module_function
 
       #
-      # Return merged branches or the existed branche if other is missing.
+      # Return merged branches or the existed brach if other is missing.
       #
-      # Branches inside files are always same if they exists, the difference only in coverage count.
+      # Branches inside files are always same if they exist, the difference only in coverage count.
       # Branch coverage report for any conditional case is built from hash, it's key is a condition and
       # it's body is a hash << keys from condition and value is coverage rate >>.
       # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...}

data/lib/simplecov/combine.rb

@@ -9,8 +9,8 @@ module SimpleCov
     #
     # Combine two coverage based on the given combiner_module.
     #
-    # Combiners should always be called throught his interface,
-    # as it takes care of short circuting of one of the coverages is nil.
+    # Combiners should always be called through this interface,
+    # as it takes care of short-circuiting of one of the coverages is nil.
     #
     # @return [Hash]
     def combine(combiner_module, coverage_a, coverage_b)

data/lib/simplecov/configuration.rb

@@ -240,8 +240,15 @@ module SimpleCov
     # Default is 0% (disabled)
     #
     def minimum_coverage(coverage = nil)
-      minimum_possible_coverage_exceeded("minimum_coverage") if coverage && coverage > 100
-      @minimum_coverage ||= (coverage || 0).to_f.round(2)
+      return @minimum_coverage ||= {} unless coverage
+
+      coverage = {DEFAULT_COVERAGE_CRITERION => coverage} if coverage.is_a?(Numeric)
+      coverage.keys.each { |criterion| raise_if_criterion_disabled(criterion) }
+      coverage.values.each do |percent|
+        minimum_possible_coverage_exceeded("minimum_coverage") if percent && percent > 100
+      end
+
+      @minimum_coverage = coverage
     end
 
     #
@@ -362,12 +369,21 @@ module SimpleCov
 
   private
 
-    def raise_if_criterion_unsupported(criterion)
-      raise_criterion_unsupported(criterion) unless SUPPORTED_COVERAGE_CRITERIA.member?(criterion)
+    def raise_if_criterion_disabled(criterion)
+      raise_if_criterion_unsupported(criterion)
+      # rubocop:disable Style/IfUnlessModifier
+      unless coverage_criterion_enabled?(criterion)
+        raise "Coverage criterion #{criterion}, is disabled! Please enable it first through enable_coverage #{criterion} (if supported)"
+      end
+      # rubocop:enable Style/IfUnlessModifier
     end
 
-    def raise_criterion_unsupported(criterion)
-      raise "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
+    def raise_if_criterion_unsupported(criterion)
+      # rubocop:disable Style/IfUnlessModifier
+      unless SUPPORTED_COVERAGE_CRITERIA.member?(criterion)
+        raise "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
+      end
+      # rubocop:enable Style/IfUnlessModifier
     end
 
     def minimum_possible_coverage_exceeded(coverage_option)

data/lib/simplecov/coverage_statistics.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Holds the individual data of a coverage result.
+  #
+  # This is uniform across coverage criteria as they all have:
+  #
+  # * total - how many things to cover there are (total relevant loc/branches)
+  # * covered - how many of the coverables are hit
+  # * missed - how many of the coverables are missed
+  # * percent - percentage as covered/missed
+  # * strength - average hits per/coverable (will not exist for one shot lines format)
+  class CoverageStatistics
+    attr_reader :total, :covered, :missed, :strength, :percent
+
+    def self.from(coverage_statistics)
+      sum_covered, sum_missed, sum_total_strength =
+        coverage_statistics.reduce([0, 0, 0.0]) do |(covered, missed, total_strength), file_coverage_statistics|
+          [
+            covered + file_coverage_statistics.covered,
+            missed + file_coverage_statistics.missed,
+            # gotta remultiply with loc because files have different strength and loc
+            # giving them a different "weight" in total
+            total_strength + (file_coverage_statistics.strength * file_coverage_statistics.total)
+          ]
+        end
+
+      new(covered: sum_covered, missed: sum_missed, total_strength: sum_total_strength)
+    end
+
+    # Requires only covered, missed and strength to be initialized.
+    #
+    # Other values are computed by this class.
+    def initialize(covered:, missed:, total_strength: 0.0)
+      @covered  = covered
+      @missed   = missed
+      @total    = covered + missed
+      @percent  = compute_percent(covered, missed, total)
+      @strength = compute_strength(total_strength, total)
+    end
+
+  private
+
+    def compute_percent(covered, missed, total)
+      return 100.0 if missed.zero?
+
+      covered * 100.0 / total
+    end
+
+    def compute_strength(total_strength, total)
+      return 0.0 if total.zero?
+
+      total_strength.to_f / total
+    end
+  end
+end

data/lib/simplecov/defaults.rb

@@ -22,13 +22,9 @@ end
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
+  next if SimpleCov.external_at_exit?
 
-  # If SimpleCov is no longer running then don't run exit tasks
-  next unless SimpleCov.running
-
-  SimpleCov.run_exit_tasks!
+  SimpleCov.at_exit_behavior
 end
 
 # Autoload config from ~/.simplecov if present

data/lib/simplecov/file_list.rb

@@ -3,19 +3,38 @@
 module SimpleCov
   # An array of SimpleCov SourceFile instances with additional collection helper
   # methods for calculating coverage across them etc.
-  class FileList < Array
+  class FileList
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@files,
+                   # For Enumerable
+                   :each,
+                   # also delegating methods implemented in Enumerable as they have
+                   # custom Array implementations which are presumably better/more
+                   # resource efficient
+                   :size, :map, :count,
+                   # surprisingly not in Enumerable
+                   :empty?, :length,
+                   # still act like we're kinda an array
+                   :to_a, :to_ary
+
+    def initialize(files)
+      @files = files
+    end
+
+    def coverage_statistics
+      @coverage_statistics ||= compute_coverage_statistics
+    end
+
     # Returns the count of lines that have coverage
     def covered_lines
-      return 0.0 if empty?
-
-      map { |f| f.covered_lines.count }.inject(:+)
+      coverage_statistics[:line]&.covered
     end
 
     # Returns the count of lines that have been missed
     def missed_lines
-      return 0.0 if empty?
-
-      map { |f| f.missed_lines.count }.inject(:+)
+      coverage_statistics[:line]&.missed
     end
 
     # Returns the count of lines that are not relevant for coverage
@@ -45,44 +64,51 @@ module SimpleCov
 
     # Returns the overall amount of relevant lines of code across all files in this list
     def lines_of_code
-      covered_lines + missed_lines
+      coverage_statistics[:line]&.total
     end
 
     # Computes the coverage based upon lines covered and lines missed
     # @return [Float]
     def covered_percent
-      return 100.0 if empty? || lines_of_code.zero?
-
-      Float(covered_lines * 100.0 / lines_of_code)
+      coverage_statistics[:line]&.percent
     end
 
     # Computes the strength (hits / line) based upon lines covered and lines missed
     # @return [Float]
     def covered_strength
-      return 0.0 if empty? || lines_of_code.zero?
-
-      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
+      coverage_statistics[:line]&.strength
     end
 
     # Return total count of branches in all files
     def total_branches
-      return 0 if empty?
-
-      map { |file| file.total_branches.count }.inject(:+)
+      coverage_statistics[:branch]&.total
     end
 
     # Return total count of covered branches
     def covered_branches
-      return 0 if empty?
-
-      map { |file| file.covered_branches.count }.inject(:+)
+      coverage_statistics[:branch]&.covered
     end
 
     # Return total count of covered branches
     def missed_branches
-      return 0 if empty?
+      coverage_statistics[:branch]&.missed
+    end
+
+    def branch_covered_percent
+      coverage_statistics[:branch]&.percent
+    end
+
+  private
+
+    def compute_coverage_statistics
+      total_coverage_statistics = @files.each_with_object(line: [], branch: []) do |file, together|
+        together[:line] << file.coverage_statistics[:line]
+        together[:branch] << file.coverage_statistics[:branch] if SimpleCov.branch_coverage?
+      end
 
-      map { |file| file.missed_branches.count }.inject(:+)
+      coverage_statistics = {line: CoverageStatistics.from(total_coverage_statistics[:line])}
+      coverage_statistics[:branch] = CoverageStatistics.from(total_coverage_statistics[:branch]) if SimpleCov.branch_coverage?
+      coverage_statistics
     end
   end
 end

data/lib/simplecov/result.rb

@@ -20,7 +20,7 @@ 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
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics
     def_delegator :files, :lines_of_code, :total_lines
 
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of

data/lib/simplecov/source_file.rb

@@ -9,11 +9,11 @@ module SimpleCov
     # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
     attr_reader :filename
     # The array of coverage data received from the Coverage.result
-    attr_reader :coverage
+    attr_reader :coverage_data
 
-    def initialize(filename, coverage)
+    def initialize(filename, coverage_data)
       @filename = filename
-      @coverage = coverage
+      @coverage_data = coverage_data
     end
 
     # The path to this source file relative to the projects directory
@@ -25,10 +25,18 @@ module SimpleCov
     def src
       # We intentionally read source code lazily to
       # suppress reading unused source code.
-      @src ||= File.open(filename, "rb", &:readlines)
+      @src ||= load_source
     end
     alias source src
 
+    def coverage_statistics
+      @coverage_statistics ||=
+        {
+          **line_coverage_statistics,
+          **branch_coverage_statistics
+        }
+    end
+
     # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
     # and thus including coverage data. Aliased as :source_lines
     def lines
@@ -60,44 +68,7 @@ module SimpleCov
 
     # Returns the number of relevant lines (covered + missed)
     def lines_of_code
-      covered_lines.size + missed_lines.size
-    end
-
-    def build_lines
-      coverage_exceeding_source_warn if coverage["lines"].size > src.size
-      lines = src.map.with_index(1) do |src, i|
-        SimpleCov::SourceFile::Line.new(src, i, coverage["lines"][i - 1])
-      end
-      process_skipped_lines(lines)
-    end
-
-    # no_cov_chunks is zero indexed to work directly with the array holding the lines
-    def no_cov_chunks
-      @no_cov_chunks ||= build_no_cov_chunks
-    end
-
-    def build_no_cov_chunks
-      no_cov_lines = src.map.with_index(1).select { |line, _index| LinesClassifier.no_cov_line?(line) }
-
-      warn "uneven number of nocov comments detected" if no_cov_lines.size.odd?
-
-      no_cov_lines.each_slice(2).map do |(_line_start, index_start), (_line_end, index_end)|
-        index_start..index_end
-      end
-    end
-
-    def process_skipped_lines(lines)
-      # the array the lines are kept in is 0-based whereas the line numbers in the nocov
-      # chunks are 1-based and are expected to be like this in other parts (and it's also
-      # arguably more understandable)
-      no_cov_chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
-
-      lines
-    end
-
-    # Warning to identify condition from Issue #56
-    def coverage_exceeding_source_warn
-      warn "Warning: coverage data provided by Coverage [#{coverage['lines'].size}] exceeds number of lines in #{filename} [#{src.size}]"
+      coverage_statistics[:line]&.total
     end
 
     # Access SimpleCov::SourceFile::Line source lines by line number
@@ -107,27 +78,17 @@ module SimpleCov
 
     # The coverage for this file in percent. 0 if the file has no coverage lines
     def covered_percent
-      return 100.0 if no_lines?
-
-      return 0.0 if relevant_lines.zero?
-
-      Float(covered_lines.size * 100.0 / relevant_lines.to_f)
+      coverage_statistics[:line]&.percent
     end
 
     def covered_strength
-      return 0.0 if relevant_lines.zero?
-
-      (lines_strength / relevant_lines.to_f).round(1)
+      coverage_statistics[:line]&.strength
     end
 
     def no_lines?
       lines.length.zero? || (lines.length == never_lines.size)
     end
 
-    def lines_strength
-      lines.map(&:coverage).compact.reduce(:+)
-    end
-
     def relevant_lines
       lines.size - never_lines.size - skipped_lines.size
     end
@@ -143,16 +104,13 @@ module SimpleCov
     end
 
     def branches_coverage_percent
-      return 100.0 if no_branches?
-      return 0.0 if covered_branches.empty?
-
-      Float(covered_branches.size * 100.0 / total_branches.size.to_f)
+      coverage_statistics[:branch]&.percent
     end
 
     #
     # Return the relevant branches to source file
     def total_branches
-      covered_branches + missed_branches
+      @total_branches ||= covered_branches + missed_branches
     end
 
     #
@@ -161,14 +119,153 @@ module SimpleCov
       @branches_report ||= build_branches_report
     end
 
-    ## Related to source file branches statistics
+    #
+    # Select the covered branches
+    # Here we user tree schema because some conditions like case may have additional
+    # else that is not in declared inside the code but given by default by coverage report
+    #
+    # @return [Array]
+    #
+    def covered_branches
+      @covered_branches ||= branches.select(&:covered?)
+    end
+
+    #
+    # Select the missed branches with coverage equal to zero
+    #
+    # @return [Array]
+    #
+    def missed_branches
+      @missed_branches ||= branches.select(&:missed?)
+    end
+
+    def branches_for_line(line_number)
+      branches_report.fetch(line_number, [])
+    end
+
+    #
+    # Check if any branches missing on given line number
+    #
+    # @param [Integer] line_number
+    #
+    # @return [Boolean]
+    #
+    def line_with_missed_branch?(line_number)
+      branches_for_line(line_number).select { |_type, count| count.zero? }.any?
+    end
+
+  private
+
+    # no_cov_chunks is zero indexed to work directly with the array holding the lines
+    def no_cov_chunks
+      @no_cov_chunks ||= build_no_cov_chunks
+    end
+
+    def build_no_cov_chunks
+      no_cov_lines = src.map.with_index(1).select { |line_src, _index| LinesClassifier.no_cov_line?(line_src) }
+
+      # if we have an uneven number of nocovs we assume they go to the
+      # end of the file, the source doesn't really matter
+      # Can't deal with this within the each_slice due to differing
+      # behavior in JRuby: jruby/jruby#6048
+      no_cov_lines << ["", src.size] if no_cov_lines.size.odd?
+
+      no_cov_lines.each_slice(2).map do |(_line_src_start, index_start), (_line_src_end, index_end)|
+        index_start..index_end
+      end
+    end
+
+    def load_source
+      lines = []
+      # The default encoding is UTF-8
+      File.open(filename, "rb:UTF-8") do |file|
+        current_line = file.gets
+
+        if shebang?(current_line)
+          lines << current_line
+          current_line = file.gets
+        end
+
+        read_lines(file, lines, current_line)
+      end
+    end
+
+    SHEBANG_REGEX = /\A#!/.freeze
+    def shebang?(line)
+      SHEBANG_REGEX.match?(line)
+    end
+
+    def read_lines(file, lines, current_line)
+      return lines unless current_line
+
+      set_encoding_based_on_magic_comment(file, current_line)
+      lines.concat([current_line], ensure_remove_undefs(file.readlines))
+    end
+
+    RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/.freeze
+    def set_encoding_based_on_magic_comment(file, line)
+      # Check for encoding magic comment
+      # Encoding magic comment must be placed at first line except for shebang
+      if (match = RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX.match(line))
+        file.set_encoding(match[1], "UTF-8")
+      end
+    end
+
+    def ensure_remove_undefs(file_lines)
+      # invalid/undef replace are technically not really necessary but nice to
+      # have and work around a JRuby incompatibility. Also moved here from
+      # simplecov-html to have encoding shenaningans in one place. See #866
+      # also setting these option on `file.set_encoding` doesn't seem to work
+      # properly so it has to be done here.
+      file_lines.each { |line| line.encode!("UTF-8", invalid: :replace, undef: :replace) }
+    end
+
+    def build_lines
+      coverage_exceeding_source_warn if coverage_data["lines"].size > src.size
+      lines = src.map.with_index(1) do |src, i|
+        SimpleCov::SourceFile::Line.new(src, i, coverage_data["lines"][i - 1])
+      end
+      process_skipped_lines(lines)
+    end
+
+    def process_skipped_lines(lines)
+      # the array the lines are kept in is 0-based whereas the line numbers in the nocov
+      # chunks are 1-based and are expected to be like this in other parts (and it's also
+      # arguably more understandable)
+      no_cov_chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
+
+      lines
+    end
+
+    def lines_strength
+      lines.map(&:coverage).compact.reduce(:+)
+    end
+
+    # Warning to identify condition from Issue #56
+    def coverage_exceeding_source_warn
+      warn "Warning: coverage data provided by Coverage [#{coverage_data['lines'].size}] exceeds number of lines in #{filename} [#{src.size}]"
+    end
+
+    #
+    # Build full branches report
+    # Root branches represent the wrapper of all condition state that
+    # have inside the branches
+    #
+    # @return [Hash]
+    #
+    def build_branches_report
+      branches.reject(&:skipped?).each_with_object({}) do |branch, coverage_statistics|
+        coverage_statistics[branch.report_line] ||= []
+        coverage_statistics[branch.report_line] << branch.report
+      end
+    end
 
     #
     # Call recursive method that transform our static hash to array of objects
     # @return [Array]
     #
     def build_branches
-      coverage_branch_data = coverage.fetch("branches", {})
+      coverage_branch_data = coverage_data.fetch("branches", {})
       branches = coverage_branch_data.flat_map do |condition, coverage_branches|
         build_branches_from(condition, coverage_branches)
       end
@@ -230,53 +327,23 @@ module SimpleCov
       )
     end
 
-    #
-    # Select the covered branches
-    # Here we user tree schema because some conditions like case may have additional
-    # else that is not in declared inside the code but given by default by coverage report
-    #
-    # @return [Array]
-    #
-    def covered_branches
-      @covered_branches ||= branches.select(&:covered?)
-    end
-
-    #
-    # Select the missed branches with coverage equal to zero
-    #
-    # @return [Array]
-    #
-    def missed_branches
-      @missed_branches ||= branches.select(&:missed?)
-    end
-
-    def branches_for_line(line_number)
-      branches_report.fetch(line_number, [])
-    end
-
-    #
-    # Check if any branches missing on given line number
-    #
-    # @param [Integer] line_number
-    #
-    # @return [Boolean]
-    #
-    def line_with_missed_branch?(line_number)
-      branches_for_line(line_number).select { |_type, count| count.zero? }.any?
+    def line_coverage_statistics
+      {
+        line: CoverageStatistics.new(
+          total_strength: lines_strength,
+          covered:  covered_lines.size,
+          missed:   missed_lines.size
+        )
+      }
     end
 
-    #
-    # Build full branches report
-    # Root branches represent the wrapper of all condition state that
-    # have inside the branches
-    #
-    # @return [Hash]
-    #
-    def build_branches_report
-      branches.reject(&:skipped?).each_with_object({}) do |branch, coverage_statistics|
-        coverage_statistics[branch.report_line] ||= []
-        coverage_statistics[branch.report_line] << branch.report
-      end
+    def branch_coverage_statistics
+      {
+        branch: CoverageStatistics.new(
+          covered: covered_branches.size,
+          missed:  missed_branches.size
+        )
+      }
     end
   end
 end

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "0.18.0.beta3"
+  VERSION = "0.18.5"
 end

data/lib/simplecov.rb

@@ -27,6 +27,11 @@ module SimpleCov
     attr_accessor :pid
     attr_reader :exit_exception
 
+    # Basically, should we take care of at_exit behavior or something else?
+    # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
+    attr_accessor :external_at_exit
+    alias external_at_exit? external_at_exit
+
     #
     # Sets up SimpleCov to run against your project.
     # You can optionally specify a profile to use as well as configuration with a block:
@@ -189,6 +194,14 @@ module SimpleCov
       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
+    end
+
     # @api private
     #
     # Called from at_exit block
@@ -231,12 +244,8 @@ module SimpleCov
     # rubocop:disable Metrics/MethodLength
     def result_exit_status(result, covered_percent)
       covered_percentages = result.covered_percentages.map { |percentage| percentage.floor(2) }
-      if covered_percent < SimpleCov.minimum_coverage
-        $stderr.printf(
-          "Coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-          covered: covered_percent,
-          minimum_coverage: SimpleCov.minimum_coverage
-        )
+      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(
@@ -409,13 +418,40 @@ module SimpleCov
     def result_with_not_loaded_files
       @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
+
+      coverage_achieved.select do |achieved|
+        achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+      end
+    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
+    end
   end
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
 require "set"
+require "forwardable"
 require "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
+require "simplecov/coverage_statistics"
 require "simplecov/exit_codes"
 require "simplecov/profiles"
 require "simplecov/source_file/line"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta3
+  version: 0.18.5
 platform: ruby
 authors:
 - Christoph Olszowka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2020-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0.beta2
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0.beta2
+        version: '0.11'
 description: Code coverage for Ruby with a powerful configuration library and automatic
   merging of coverage across test suites
 email:
@@ -55,6 +55,7 @@ files:
 - doc/alternate-formatters.md
 - doc/commercial-services.md
 - doc/editor-integration.md
+- lib/minitest/simplecov_plugin.rb
 - lib/simplecov.rb
 - lib/simplecov/combine.rb
 - lib/simplecov/combine/branches_combiner.rb
@@ -63,6 +64,7 @@ files:
 - lib/simplecov/combine/results_combiner.rb
 - lib/simplecov/command_guesser.rb
 - lib/simplecov/configuration.rb
+- lib/simplecov/coverage_statistics.rb
 - lib/simplecov/defaults.rb
 - lib/simplecov/exit_codes.rb
 - lib/simplecov/file_list.rb
@@ -95,9 +97,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/colszowka/simplecov/issues
   changelog_uri: https://github.com/colszowka/simplecov/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.18.0.beta3
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.18.5
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/colszowka/simplecov/tree/v0.18.0.beta3
+  source_code_uri: https://github.com/colszowka/simplecov/tree/v0.18.5
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -109,9 +111,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.2
 signing_key: