simplecov 0.18.0.beta3 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5ac4654ad44859d2e7b68cc5375314766127720e33d51080cc02120d35cc9cb
-  data.tar.gz: 89ceeaf8b9b1a76bd05a4f078c50a80050bd247ef067164201f9721ce7378b5b
+  metadata.gz: ce12d99507e5e8bd75399d80855c495907b8dda937fb5e2a33d2895e9f74e370
+  data.tar.gz: ae53aefe53c30c3b1d6c1c0b70aa34c1193642d4a879f77a0c3522960fc92773
 SHA512:
-  metadata.gz: 8afee26e98b841b002d097d589afbbc8b892452897423c927b817b51696bb7063e3f2e849f462434b765fb09970fbb6759d31d5362ea5c6e90eb65e82824eb78
-  data.tar.gz: ed2f4ffab150fd1da883604eccec94a087184aeaadb4b4d6f1f7273efa6020d1034b9e2eebbc8b88a9c63c54d545ccd6db4f5db58ee29f8182703ed40281342e
+  metadata.gz: e9a60e36936b9b5018a6998ade1742373bfa67b96688411ab42c90ac82ca6280abe9d407dcef4d45398ed28803ca876d6f82ce0cabc878d6141897cca4dab91e
+  data.tar.gz: 7056045c2385516ce0029af14558bd95c9c84bc85319d82bddfcf2011b7db87a5291168bb739c1ff02d8830e133065b3f2fda605e03b7c2e6ed094b61bff9240

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+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)
 ========================
 

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"
 

data/lib/simplecov.rb

@@ -231,12 +231,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 +405,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"

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 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/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
@@ -29,6 +29,14 @@ module SimpleCov
     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,104 @@ 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, _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 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 +278,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.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta3
+  version: 0.18.0
 platform: ruby
 authors:
 - Christoph Olszowka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2020-01-28 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.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0.beta2
+        version: 0.11.0
 description: Code coverage for Ruby with a powerful configuration library and automatic
   merging of coverage across test suites
 email:
@@ -63,6 +63,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 +96,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.0
   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.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -109,9 +110,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: