simplecov 0.18.0.beta1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd6ab6b1c33e8b2503dc00691a8ae500ae0caf885fc2dba52bbe102d696d926
-  data.tar.gz: 41c70724c0beb18bd66f665cb078a8b9cf95d1dbb770bf1eb0601156c12370e0
+  metadata.gz: ce12d99507e5e8bd75399d80855c495907b8dda937fb5e2a33d2895e9f74e370
+  data.tar.gz: ae53aefe53c30c3b1d6c1c0b70aa34c1193642d4a879f77a0c3522960fc92773
 SHA512:
-  metadata.gz: ba1dcb50ce7ef6765a9f519bda006388d587c67cd103bcf6d0f4bd4d4427ebef240de13772e8925f62d70dd232310bd705b66fbda1c39c25444dcd329b9dedc1
-  data.tar.gz: cc1160ba31aa5ecdcb46a255e3147e78f649789d542d1363343fec803ec9c5c96759272990ba67ceb75a0a07116325f962a69354d8a01477a905b491bba86275
+  metadata.gz: e9a60e36936b9b5018a6998ade1742373bfa67b96688411ab42c90ac82ca6280abe9d407dcef4d45398ed28803ca876d6f82ce0cabc878d6141897cca4dab91e
+  data.tar.gz: 7056045c2385516ce0029af14558bd95c9c84bc85319d82bddfcf2011b7db87a5291168bb739c1ff02d8830e133065b3f2fda605e03b7c2e6ed094b61bff9240

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+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.
+
+## 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
+
+0.18.0.beta3 (2020-01-20)
+========================
+
+## Enhancements
+* Instead of ignoring old `.resultset.json`s that are inside the merge timeout, adapt and respect them
+
+## Bugfixes
+* Remove the constant warning printing if you still have a `.resultset.json` in pre 0.18 layout that is within your merge timeout
+
+0.18.0.beta2 (2020-01-19)
+===================
+
+## Enhancements
+* only turn on the requested coverage criteria (when activating branch coverage before SimpleCov would also instruct Ruby to take Method coverage)
+* Change how branch coverage is displayed, now it's `branch_type: hit_count` which should be more self explanatory. See [#830](https://github.com/colszowka/simplecov/pull/830) for an example and feel free to give feedback!
+* Allow early running exit tasks and avoid the `at_exit` hook through the `SimpleCov.run_exit_tasks!` method. (thanks [@macumber](https://github.com/macumber))
+* Allow manual collation of result sets through the `SimpleCov.collate` entrypoint. See the README for more details (thanks [@ticky](https://github.com/ticky))
+* Within `case`, even if there is no `else` branch declared show missing coverage for it (aka no branch of it). See [#825](https://github.com/colszowka/simplecov/pull/825)
+* Stop symbolizing all keys when loading cache (should lead to be faster and consume less memory)
+* Cache whether we can use/are using branch coverage (should be slightly faster)
+
+## Bugfixes
+* Fix a crash that happened when an old version of our internal cache file `.resultset.json` was still present
+
 0.18.0.beta1 (2020-01-05)
 ===================
 
@@ -8,7 +50,7 @@ This release is still beta because we'd love for you to test out branch coverage
 On a personal note from [@PragTob](https://github.com/PragTob/) thanks to [ruby together](https://rubytogether.org/) for sponsoring this work on SimpleCov making it possible to deliver this and subsequent releases.
 
 ## Breaking
-* Dropped official support for all EOL'ed rubies meaning we only officially support 2.4+ - older rubies might still work but are not guaranteed to do so. Older release should still work. (thanks [@deivid-rodriguez](https://github.com/deivid-rodriguez))
+* Dropped support for all EOL'ed rubies meaning we only support 2.4+. Simplecov can no longer be installed on older rubies, but older simplecov releases should still work. (thanks [@deivid-rodriguez](https://github.com/deivid-rodriguez))
 * Dropped the `rake simplecov` task that "magically" integreated with rails. It was always undocumented, caused some issues and [had some issues](https://github.com/colszowka/simplecov/issues/689#issuecomment-561572327). Use the integration as described in the README please :)
 
 ## Enhancements

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"
 
@@ -170,6 +171,17 @@ to use SimpleCov with them. Here's an overview of the known ones:
       <a href="https://github.com/colszowka/simplecov/pull/185">#185</a>
     </td>
   </tr>
+  <tr>
+    <th>
+      knapsack_pro
+    </th>
+    <td>
+      To make SimpleCov work with Knapsack Pro Queue Mode to split tests in parallel on CI jobs you need to provide CI node index number to the <code>SimpleCov.command_name</code> in <code>KnapsackPro::Hooks::Queue.before_queue</code> hook.
+    </td>
+    <td>
+      <a href="https://knapsackpro.com/faq/question/how-to-use-simplecov-in-queue-mode">Tip</a>
+    </td>
+  </tr>
   <tr>
     <th>
       RubyMine
@@ -308,12 +320,16 @@ return if number.odd?
 ```
 
 If all the code in that method was covered you'd never know if the guard clause was ever
-triggered with line coverage as just evaluating the condition marks it as covered.
+triggered! With line coverage as just evaluating the condition marks it as covered.
 
-In the HTML report the lines of code will be annotated like `hit_count, positive_or_negative_branch`:
+In the HTML report the lines of code will be annotated like `branch_type: hit_count`:
 
-* `2, +` - the positive branch was executed twice
-* `0, -` - the negative branch was never executed
+* `then: 2` - the then branch (of an `if`) was executed twice
+* `else: 0` - the else branch (of an `if` or `case`) was never executed
+
+Not that even if you don't declare an `else` branch it will still show up in the coverage
+reports meaning that the condition of the `if` was not hit or that no `when` of `case`
+was hit during the test runs.
 
 **Is branch coverage strictly better?** No. Branch coverage really only concerns itself with
 conditionals - meaning coverage of sequential code is of no interest to it. A file without
@@ -461,12 +477,11 @@ end
 
 You normally want to have your coverage analyzed across ALL of your test suites, right?
 
-Simplecov automatically caches coverage results in your (coverage_path)/.resultset.json. Those results will then
-be automatically merged when generating the result, so when coverage is set up properly for Cucumber and your
-unit / functional / integration tests, all of those test suites will be taken into account when building the
-coverage report.
-
-There are two things to note here though:
+Simplecov automatically caches coverage results in your
+(coverage_path)/.resultset.json, and will merge or override those with
+subsequent runs, depending on whether simplecov considers those subsequent runs
+as different test suites or as the same test suite as the cached results. To
+make this distinction, simplecov has the concept of "test suite names".
 
 ### Test suite names
 
@@ -520,14 +535,84 @@ SimpleCov.command_name "features" + (ENV['TEST_ENV_NUMBER'] || '')
 
 [simplecov-html] prints the used test suites in the footer of the generated coverage report.
 
-### Timeout for merge
 
-Of course, your cached coverage data is likely to become invalid at some point. Thus, result sets that are older than
-`SimpleCov.merge_timeout` will not be used any more. By default, the timeout is 600 seconds (10 minutes), and you can
-raise (or lower) it by specifying `SimpleCov.merge_timeout 3600` (1 hour), or, inside a configure/start block, with
-just `merge_timeout 3600`.
+### Merging test runs under the same execution environment
+
+Test results are automatically merged with previous runs in the same execution
+environment when generating the result, so when coverage is set up properly for
+Cucumber and your unit / functional / integration tests, all of those test
+suites will be taken into account when building the coverage report.
+
+#### Timeout for merge
+
+Of course, your cached coverage data is likely to become invalid at some point. Thus, when automatically merging
+subsequent test runs, result sets that are older than `SimpleCov.merge_timeout` will not be used any more. By default,
+the timeout is 600 seconds (10 minutes), and you can raise (or lower) it by specifying `SimpleCov.merge_timeout 3600`
+(1 hour), or, inside a configure/start block, with just `merge_timeout 3600`.
+
+You can deactivate this automatic merging altogether with `SimpleCov.use_merging false`.
+
+### Merging test runs under different execution environments
+
+If your tests are done in parallel across multiple build machines, you can fetch them all and merge them into a single
+result set using the `SimpleCov.collate` method. This can be added to a Rakefile or script file, having downloaded a set of
+`.resultset.json` files from each parallel test run.
+
+```ruby
+# lib/tasks/coverage_report.rake
+namespace :coverage do
+  desc "Collates all result sets generated by the different test runners"
+  task :report do
+    require 'simplecov'
+
+    SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
+  end
+end
+```
+
+`SimpleCov.collate` also takes an optional simplecov profile and an optional
+block for configuration, just the same as `SimpleCov.start` or
+`SimpleCov.configure`.  This means you can configure a separate formatter for
+the collated output. For instance, you can make the formatter in
+`SimpleCov.start` the `SimpleCov::Formatter::SimpleFormatter`, and only use more
+complex formatters in the final `SimpleCov.collate` run.
+
+```ruby
+# spec/spec_helper.rb
+require 'simplecov'
+
+SimpleCov.start 'rails' do
+  # Disambiguates individual test runs
+  command_name "Job #{ENV["TEST_ENV_NUMBER"]}" if ENV["TEST_ENV_NUMBER"]
+
+  if ENV['CI']
+    formatter SimpleCov::Formatter::SimpleFormatter
+  else
+    formatter SimpleCov::Formatter::MultiFormatter.new([
+      SimpleCov::Formatter::SimpleFormatter,
+      SimpleCov::Formatter::HTMLFormatter
+    ])
+  end
 
-You can deactivate merging altogether with `SimpleCov.use_merging false`.
+  track_files "**/*.rb"
+end
+```
+
+```ruby
+# lib/tasks/coverage_report.rake
+namespace :coverage do
+  task :report do
+    require 'simplecov'
+
+    SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
+      formatter SimpleCov::Formatter::MultiFormatter.new([
+        SimpleCov::Formatter::SimpleFormatter,
+        SimpleCov::Formatter::HTMLFormatter
+      ])
+    end
+  end
+end
+```
 
 ## Running coverage only on demand
 

data/lib/simplecov/combine/files_combiner.rb

@@ -15,10 +15,9 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        {
-          :lines => Combine.combine(LinesCombiner, coverage_a[:lines], coverage_b[:lines]),
-          :branches => Combine.combine(BranchesCombiner, coverage_a[:branches], coverage_b[:branches])
-        }
+        combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
+        combination["branches"] = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"]) if SimpleCov.branch_coverage?
+        combination
       end
     end
   end

data/lib/simplecov/combine/results_combiner.rb

@@ -20,26 +20,26 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(*results)
-        results.reduce({}) do |result, next_result|
-          combine_result_sets(result, next_result)
+        results.reduce({}) do |combined_results, next_result|
+          combine_result_sets(combined_results, next_result)
         end
       end
 
       #
       # Manage combining results on files level
       #
-      # @param [Hash] result_a
-      # @param [Hash] result_b
+      # @param [Hash] combined_results
+      # @param [Hash] result
       #
       # @return [Hash]
       #
-      def combine_result_sets(result_a, result_b)
-        results_files = result_a.keys | result_b.keys
+      def combine_result_sets(combined_results, result)
+        results_files = combined_results.keys | result.keys
 
-        results_files.each_with_object({}) do |file_name, combined_results|
-          combined_results[file_name] = combine_file_coverage(
-            result_a[file_name],
-            result_b[file_name]
+        results_files.each_with_object({}) do |file_name, file_combination|
+          file_combination[file_name] = combine_file_coverage(
+            combined_results[file_name],
+            result[file_name]
           )
         end
       end

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
 
     #
@@ -313,7 +320,7 @@ module SimpleCov
     # * :line - coverage based on lines aka has this line been executed?
     # * :branch - coverage based on branches aka has this branch (think conditions) been executed?
     #
-    # If not set the default is is `:line`
+    # If not set the default is `:line`
     #
     # @param [Symbol] criterion
     #
@@ -335,23 +342,48 @@ module SimpleCov
       @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
     end
 
+    def coverage_criterion_enabled?(criterion)
+      coverage_criteria.member?(criterion)
+    end
+
+    def clear_coverage_criteria
+      @coverage_criteria = nil
+    end
+
     def branch_coverage?
-      branch_coverage_supported? && coverage_criteria.member?(:branch)
+      branch_coverage_supported? && coverage_criterion_enabled?(:branch)
     end
 
-    def branch_coverage_supported?
-      require "coverage"
-      !Coverage.method(:start).arity.zero?
+    def coverage_start_arguments_supported?
+      # safe to cache as within one process this value should never
+      # change
+      return @coverage_start_arguments_supported if defined?(@coverage_start_arguments_supported)
+
+      @coverage_start_arguments_supported = begin
+        require "coverage"
+        !Coverage.method(:start).arity.zero?
+      end
     end
 
+    alias branch_coverage_supported? coverage_start_arguments_supported?
+
   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 strenght 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, total)
+      @strength = compute_strength(total_strength, @total)
+    end
+
+  private
+
+    def compute_percent(covered, total)
+      return 100.0 if total.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

@@ -25,7 +25,9 @@ at_exit do
   # If we are in a different process than called start, don't interfere.
   next if SimpleCov.pid != Process.pid
 
-  SimpleCov.set_exit_exception
+  # If SimpleCov is no longer running then don't run exit tasks
+  next unless SimpleCov.running
+
   SimpleCov.run_exit_tasks!
 end
 

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/last_run.rb

@@ -15,7 +15,7 @@ module SimpleCov
         json = File.read(last_run_path)
         return nil if json.strip.empty?
 
-        JSON.parse(json)
+        JSON.parse(json, symbolize_names: true)
       end
 
       def write(json)

data/lib/simplecov/result.rb

@@ -20,15 +20,16 @@ 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
     # coverage data)
     def initialize(original_result)
-      @original_result = original_result.freeze
-      @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage), :symbolize_names => true)) if File.file?(filename.to_s)
+      result = adapt_result(original_result)
+      @original_result = result.freeze
+      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
+        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
       end.compact.sort_by(&:filename))
       filter!
     end
@@ -61,36 +62,51 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
+      {
+        command_name => {
+          "coverage" => coverage,
+          "timestamp" => created_at.to_i
+        }
+      }
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       command_name, data = hash.first
 
-      result = SimpleCov::Result.new(
-        symbolize_names_of_coverage_results(data["coverage"])
-      )
+      result = SimpleCov::Result.new(data["coverage"])
 
       result.command_name = command_name
       result.created_at = Time.at(data["timestamp"])
       result
     end
 
-    # Manage symbolize the keys of coverage hash.
-    # JSON.parse gives coverage hash with stringified keys what breaks some logics
-    # inside the process that expects them as symboles.
-    #
-    # @return [Hash]
-    def self.symbolize_names_of_coverage_results(coverage_data)
-      coverage_data.each_with_object({}) do |(file_name, file_coverage_result), coverage_results|
-        coverage_results[file_name] = file_coverage_result.each_with_object({}) do |(k, v), cov_elem|
-          cov_elem[k.to_sym] = v
-        end
+  private
+
+    # We changed the format of the raw result data in simplecov, as people are likely
+    # to have "old" resultsets lying around (but not too old so that they're still
+    # considered we can adapt them).
+    # See https://github.com/colszowka/simplecov/pull/824#issuecomment-576049747
+    def adapt_result(result)
+      if pre_simplecov_0_18_result?(result)
+        adapt_pre_simplecov_0_18_result(result)
+      else
+        result
       end
     end
 
-  private
+    # pre 0.18 coverage data pointed from file directly to an array of line coverage
+    def pre_simplecov_0_18_result?(result)
+      _key, data = result.first
+
+      data.is_a?(Array)
+    end
+
+    def adapt_pre_simplecov_0_18_result(result)
+      result.map do |file_path, line_coverage_data|
+        [file_path, {"lines" => line_coverage_data}]
+      end.to_h
+    end
 
     def coverage
       keys = original_result.keys & filenames

data/lib/simplecov/result_adapter.rb

@@ -20,7 +20,7 @@ module SimpleCov
 
       result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
         if cover_statistic.is_a?(Array)
-          adapted_result.merge!(file_name => {:lines => cover_statistic})
+          adapted_result.merge!(file_name => {"lines" => cover_statistic})
         else
           adapted_result.merge!(file_name => cover_statistic)
         end