simplecov 0.16.1 → 0.22.0

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!
 
@@ -10,6 +10,16 @@ If you have built or found one that is missing here, please send a Pull Request
 
 A formatter that generates a coverage badge for use in your project's readme using ImageMagick.
 
+#### [simplecov-small-badge](https://github.com/marcgrimme/simplecov-small-badge)
+*by Marc Grimme*
+
+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*
 
@@ -49,3 +59,13 @@ A formatter that prints the coverage of the file under test when you run a singl
 *by [Yosuke Kabuto](https://github.com/ysksn)*
 
 t_wada AA formatter for SimpleCov
+
+#### [simplecov-tailwindcss](https://github.com/chiefpansancolt/simplecov-tailwindcss)
+*by [Chiefpansancolt](https://github.com/chiefpansancolt)*
+
+A TailwindCSS & TailwindUI Designed HTML formatter with clean and easy search of files with a tabular left Navigation.
+
+#### [simplecov-material](https://github.com/chiefpansancolt/simplecov-material)
+*by [Chiefpansancolt](https://github.com/chiefpansancolt)*
+
+A Material Designed HTML formatter with clean and easy search of files with a tabular left Navigation.

data/doc/commercial-services.md

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

data/lib/minitest/simplecov_plugin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# 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)
+    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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Combine different branch coverage results on single file.
+    #
+    # Should be called through `SimpleCov.combine`.
+    module BranchesCombiner
+    module_function
+
+      #
+      # Return merged branches or the existed brach if other is missing.
+      #
+      # 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...}
+      # We create copy of result and update it values depending on the combined branches coverage values.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        coverage_a.merge(coverage_b) do |_condition, branches_inside_a, branches_inside_b|
+          branches_inside_a.merge(branches_inside_b) do |_branch, a_count, b_count|
+            a_count + b_count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/combine/files_combiner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Handle combining two coverage results for same file
+    #
+    # Should be called through `SimpleCov.combine`.
+    module FilesCombiner
+    module_function
+
+      #
+      # Combines the results for 2 coverages of a file.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        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
+end

data/lib/simplecov/combine/lines_combiner.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Combine two different lines coverage results on same file
+    #
+    # Should be called through `SimpleCov.combine`.
+    module LinesCombiner
+    module_function
+
+      def combine(coverage_a, coverage_b)
+        coverage_a
+          .zip(coverage_b)
+          .map do |coverage_a_val, coverage_b_val|
+            merge_line_coverage(coverage_a_val, coverage_b_val)
+          end
+      end
+
+      # Return depends on coverage in a specific line
+      #
+      # @param [Integer || nil] first_val
+      # @param [Integer || nil] second_val
+      #
+      # Logic:
+      #
+      # => nil + 0 = nil
+      # => nil + nil = nil
+      # => int + int = int
+      #
+      # @return [Integer || nil]
+      def merge_line_coverage(first_val, second_val)
+        sum = first_val.to_i + second_val.to_i
+
+        if sum.zero? && (first_val.nil? || second_val.nil?)
+          nil
+        else
+          sum
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/combine/results_combiner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    # There might be reports from different kinds of tests,
+    # e.g. RSpec and Cucumber. We need to combine their results
+    # into unified one. This class does that.
+    # To unite the results on file basis, it leverages
+    # the combine of lines and branches inside each file within given results.
+    module ResultsCombiner
+    module_function
+
+      #
+      # Combine process explanation
+      # => ResultCombiner: define all present files between results and start combine on file level.
+      # ==> FileCombiner: collect result of next combine levels lines and branches.
+      # ===> LinesCombiner: combine lines results.
+      # ===> BranchesCombiner: combine branches results.
+      #
+      # @return [Hash]
+      #
+      def combine(*results)
+        results.reduce({}) do |combined_results, next_result|
+          combine_result_sets(combined_results, next_result)
+        end
+      end
+
+      #
+      # Manage combining results on files level
+      #
+      # @param [Hash] combined_results
+      # @param [Hash] result
+      #
+      # @return [Hash]
+      #
+      def combine_result_sets(combined_results, result)
+        results_files = combined_results.keys | result.keys
+
+        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
+
+      #
+      # Combine two files coverage results
+      #
+      # @param [Hash] coverage_a
+      # @param [Hash] coverage_b
+      #
+      # @return [Hash]
+      #
+      def combine_file_coverage(coverage_a, coverage_b)
+        Combine.combine(Combine::FilesCombiner, coverage_a, coverage_b)
+      end
+    end
+  end
+end

data/lib/simplecov/combine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Functionally for combining coverage results
+  #
+  module Combine
+  module_function
+
+    #
+    # Combine two coverage based on the given combiner_module.
+    #
+    # 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)
+      return existing_coverage(coverage_a, coverage_b) if empty_coverage?(coverage_a, coverage_b)
+
+      combiner_module.combine(coverage_a, coverage_b)
+    end
+
+    def empty_coverage?(coverage_a, coverage_b)
+      !(coverage_a && coverage_b)
+    end
+
+    def existing_coverage(coverage_a, coverage_b)
+      coverage_a || coverage_b
+    end
+  end
+end

data/lib/simplecov/command_guesser.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-#
-# Helper that tries to find out what test suite is running (for SimpleCov.command_name)
-#
 module SimpleCov
+  #
+  # Helper that tries to find out what test suite is running (for SimpleCov.command_name)
+  #
   module CommandGuesser
     class << self
       # Storage for the original command line call that invoked the test suite.
@@ -22,6 +22,7 @@ module SimpleCov
       def from_env
         # If being run from inside parallel_tests set the command name according to the process number
         return unless ENV["PARALLEL_TEST_GROUPS"] && ENV["TEST_ENV_NUMBER"]
+
         number = ENV["TEST_ENV_NUMBER"]
         number = "1" if number.empty?
         "(#{number}/#{ENV['PARALLEL_TEST_GROUPS']})"
@@ -48,6 +49,8 @@ module SimpleCov
           "RSpec"
         elsif defined?(Test::Unit)
           "Unit Tests"
+        elsif defined?(Minitest)
+          "Minitest"
         elsif defined?(MiniTest)
           "MiniTest"
         else

data/lib/simplecov/configuration.rb

@@ -2,15 +2,16 @@
 
 require "fileutils"
 require "docile"
-require "simplecov/formatter/multi_formatter"
-#
-# Bundles the configuration options used for SimpleCov. All methods
-# defined here are usable from SimpleCov directly. Please check out
-# SimpleCov documentation for further info.
-#
+require_relative "formatter/multi_formatter"
+
 module SimpleCov
-  module Configuration # rubocop:disable ModuleLength
-    attr_writer :filters, :groups, :formatter
+  #
+  # Bundles the configuration options used for SimpleCov. All methods
+  # defined here are usable from SimpleCov directly. Please check out
+  # SimpleCov documentation for further info.
+  #
+  module Configuration
+    attr_writer :filters, :groups, :formatter, :print_error_status
 
     #
     # The root for the project. This defaults to the
@@ -20,6 +21,8 @@ module SimpleCov
     #
     def root(root = nil)
       return @root if defined?(@root) && root.nil?
+
+      @coverage_path = nil # invalidate cache
       @root = File.expand_path(root || Dir.getwd)
     end
 
@@ -30,6 +33,7 @@ module SimpleCov
     #
     def coverage_dir(dir = nil)
       return @coverage_dir if defined?(@coverage_dir) && dir.nil?
+
       @coverage_path = nil # invalidate cache
       @coverage_dir = (dir || "coverage")
     end
@@ -93,8 +97,10 @@ module SimpleCov
     #
     def formatter(formatter = nil)
       return @formatter if defined?(@formatter) && formatter.nil?
+
       @formatter = formatter
       raise "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
+
       @formatter
     end
 
@@ -116,6 +122,14 @@ module SimpleCov
       end
     end
 
+    #
+    # Whether we should print non-success status codes. This can be
+    # configured with the #print_error_status= method.
+    #
+    def print_error_status
+      defined?(@print_error_status) ? @print_error_status : true
+    end
+
     #
     # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from
     # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token
@@ -125,6 +139,7 @@ module SimpleCov
     #
     def nocov_token(nocov_token = nil)
       return @nocov_token if defined?(@nocov_token) && nocov_token.nil?
+
       @nocov_token = (nocov_token || "nocov")
     end
     alias skip_token nocov_token
@@ -160,7 +175,6 @@ module SimpleCov
     # options at once.
     #
     def configure(&block)
-      return false unless SimpleCov.usable?
       Docile.dsl_eval(self, &block)
     end
 
@@ -177,17 +191,66 @@ module SimpleCov
     #     end
     #
     def at_exit(&block)
-      return proc {} unless running || block_given?
+      return Proc.new unless running || block_given?
+
       @at_exit = block if block_given?
       @at_exit ||= proc { SimpleCov.result.format! }
     end
 
+    # gets or sets the enabled_for_subprocess configuration
+    # when true, this will inject SimpleCov code into Process.fork
+    def enable_for_subprocesses(value = nil)
+      return @enable_for_subprocesses if defined?(@enable_for_subprocesses) && value.nil?
+
+      @enable_for_subprocesses = value || false
+    end
+
+    # gets the enabled_for_subprocess configuration
+    def enabled_for_subprocesses?
+      enable_for_subprocesses
+    end
+
+    #
+    # Gets or sets the behavior to start a new forked Process.
+    #
+    # By default, it will add " (Process #{pid})" to the command_name, and start SimpleCov in quiet mode
+    #
+    # Configure with:
+    #
+    #     SimpleCov.at_fork do |pid|
+    #       SimpleCov.start do
+    #         # 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 using the regular formatter and checking coverage totals
+    #         SimpleCov.print_error_status = false
+    #         SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+    #         SimpleCov.minimum_coverage 0
+    #         # start
+    #         SimpleCov.start
+    #       end
+    #     end
+    #
+    def at_fork(&block)
+      @at_fork = block if block_given?
+      @at_fork ||= lambda { |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 using the regular formatter and checking coverage totals
+        SimpleCov.print_error_status = false
+        SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+        SimpleCov.minimum_coverage 0
+        # start
+        SimpleCov.start
+      }
+    end
+
     #
     # Returns the project name - currently assuming the last dirname in
     # the SimpleCov.root is this.
     #
     def project_name(new_name = nil)
       return @project_name if defined?(@project_name) && @project_name && new_name.nil?
+
       @project_name = new_name if new_name.is_a?(String)
       @project_name ||= File.basename(root.split("/").last).capitalize.tr("_", " ")
     end
@@ -225,7 +288,20 @@ module SimpleCov
     # Default is 0% (disabled)
     #
     def minimum_coverage(coverage = nil)
-      @minimum_coverage ||= (coverage || 0).to_f.round(2)
+      return @minimum_coverage ||= {} unless coverage
+
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+
+      raise_on_invalid_coverage(coverage, "minimum_coverage")
+
+      @minimum_coverage = coverage
+    end
+
+    def raise_on_invalid_coverage(coverage, coverage_setting)
+      coverage.each_key { |criterion| raise_if_criterion_disabled(criterion) }
+      coverage.each_value do |percent|
+        minimum_possible_coverage_exceeded(coverage_setting) if percent && percent > 100
+      end
     end
 
     #
@@ -235,7 +311,13 @@ module SimpleCov
     # Default is 100% (disabled)
     #
     def maximum_coverage_drop(coverage_drop = nil)
-      @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
+      return @maximum_coverage_drop ||= {} unless coverage_drop
+
+      coverage_drop = {primary_coverage => coverage_drop} if coverage_drop.is_a?(Numeric)
+
+      raise_on_invalid_coverage(coverage_drop, "maximum_coverage_drop")
+
+      @maximum_coverage_drop = coverage_drop
     end
 
     #
@@ -246,15 +328,23 @@ module SimpleCov
     # Default is 0% (disabled)
     #
     def minimum_coverage_by_file(coverage = nil)
-      @minimum_coverage_by_file ||= (coverage || 0).to_f.round(2)
+      return @minimum_coverage_by_file ||= {} unless coverage
+
+      coverage = {primary_coverage => coverage} if coverage.is_a?(Numeric)
+
+      raise_on_invalid_coverage(coverage, "minimum_coverage_by_file")
+
+      @minimum_coverage_by_file = coverage
     end
 
     #
     # Refuses any coverage drop. That is, coverage is only allowed to increase.
     # SimpleCov will return non-zero if the coverage decreases.
     #
-    def refuse_coverage_drop
-      maximum_coverage_drop 0
+    def refuse_coverage_drop(*criteria)
+      criteria = coverage_criteria if criteria.empty?
+
+      maximum_coverage_drop(criteria.map { |c| [c, 0] }.to_h)
     end
 
     #
@@ -287,8 +377,113 @@ module SimpleCov
       groups[group_name] = parse_filter(filter_argument, &filter_proc)
     end
 
+    SUPPORTED_COVERAGE_CRITERIA = %i[line branch].freeze
+    DEFAULT_COVERAGE_CRITERION = :line
+    #
+    # Define which coverage criterion should be evaluated.
+    #
+    # Possible coverage criteria:
+    # * :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 `:line`
+    #
+    # @param [Symbol] criterion
+    #
+    def coverage_criterion(criterion = nil)
+      return @coverage_criterion ||= primary_coverage unless criterion
+
+      raise_if_criterion_unsupported(criterion)
+
+      @coverage_criterion = criterion
+    end
+
+    def enable_coverage(criterion)
+      raise_if_criterion_unsupported(criterion)
+
+      coverage_criteria << criterion
+    end
+
+    def primary_coverage(criterion = nil)
+      if criterion.nil?
+        @primary_coverage ||= DEFAULT_COVERAGE_CRITERION
+      else
+        raise_if_criterion_disabled(criterion)
+        @primary_coverage = criterion
+      end
+    end
+
+    def coverage_criteria
+      @coverage_criteria ||= Set[primary_coverage]
+    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_criterion_enabled?(:branch)
+    end
+
+    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
+
+    def branch_coverage_supported?
+      coverage_start_arguments_supported? && RUBY_ENGINE != "jruby"
+    end
+
+    def coverage_for_eval_supported?
+      require "coverage"
+      defined?(Coverage.supported?) && Coverage.supported?(:eval)
+    end
+
+    def coverage_for_eval_enabled?
+      @coverage_for_eval_enabled ||= false
+    end
+
+    def enable_coverage_for_eval
+      if coverage_for_eval_supported?
+        @coverage_for_eval_enabled = true
+      else
+        warn "Coverage for eval is not available; Use Ruby 3.2.0 or later"
+      end
+    end
+
   private
 
+    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_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)
+      warn "The coverage you set for #{coverage_option} is greater than 100%"
+    end
+
     #
     # The actual filter processor. Not meant for direct use
     #

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "simplecov-html"
+module SimpleCov
+  module Formatter
+    class << self
+      def from_env(env)
+        formatters = [SimpleCov::Formatter::HTMLFormatter]
+
+        # When running under a CI that uses CodeClimate, JSON output is expected
+        if env.fetch("CC_TEST_REPORTER_ID", nil)
+          require "simplecov_json_formatter"
+          formatters.push(SimpleCov::Formatter::JSONFormatter)
+        end
+
+        formatters
+      end
+    end
+  end
+end