simplecov 0.18.3 → 0.20.0

data/lib/simplecov/configuration.rb

@@ -2,7 +2,7 @@
 
 require "fileutils"
 require "docile"
-require "simplecov/formatter/multi_formatter"
+require_relative "formatter/multi_formatter"
 
 module SimpleCov
   #
@@ -22,6 +22,7 @@ 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
 
@@ -196,6 +197,53 @@ module SimpleCov
       @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.
@@ -239,17 +287,20 @@ module SimpleCov
     #
     # Default is 0% (disabled)
     #
+
+    # rubocop:disable Metrics/CyclomaticComplexity
     def minimum_coverage(coverage = nil)
       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|
+      coverage.each_key { |criterion| raise_if_criterion_disabled(criterion) }
+      coverage.each_value do |percent|
         minimum_possible_coverage_exceeded("minimum_coverage") if percent && percent > 100
       end
 
       @minimum_coverage = coverage
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     #
     # Defines the maximum coverage drop at once allowed for the testsuite to pass.

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

data/lib/simplecov/defaults.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 # Load default formatter gem
-require "simplecov-html"
 require "pathname"
-require "simplecov/profiles/root_filter"
-require "simplecov/profiles/test_frameworks"
-require "simplecov/profiles/bundler_filter"
-require "simplecov/profiles/hidden_filter"
-require "simplecov/profiles/rails"
+require_relative "default_formatter"
+require_relative "profiles/root_filter"
+require_relative "profiles/test_frameworks"
+require_relative "profiles/bundler_filter"
+require_relative "profiles/hidden_filter"
+require_relative "profiles/rails"
 
 # Default configuration
 SimpleCov.configure do
-  formatter SimpleCov::Formatter::HTMLFormatter
+  formatter SimpleCov::Formatter::MultiFormatter.new(
+    SimpleCov::Formatter.from_env(ENV)
+  )
+
   load_profile "bundler_filter"
   load_profile "hidden_filter"
   # Exclude files outside of SimpleCov.root
@@ -22,14 +25,13 @@ end
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # Exit hook for Minitest defined in Minitest plugin
-  next if defined?(Minitest)
+  next if SimpleCov.external_at_exit?
 
   SimpleCov.at_exit_behavior
 end
 
 # Autoload config from ~/.simplecov if present
-require "simplecov/load_global_config"
+require_relative "load_global_config"
 
 # Autoload config from .simplecov if present
 # Recurse upwards until we find .simplecov or reach the root directory

data/lib/simplecov/exit_codes.rb

@@ -8,3 +8,8 @@ module SimpleCov
     MAXIMUM_COVERAGE_DROP = 3
   end
 end
+
+require_relative "exit_codes/exit_code_handling"
+require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/minimum_coverage_by_file_check"
+require_relative "exit_codes/minimum_overall_coverage_check"

data/lib/simplecov/exit_codes/exit_code_handling.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    module ExitCodeHandling
+    module_function
+
+      def call(result, coverage_limits:)
+        checks = coverage_checks(result, coverage_limits)
+
+        failing_check = checks.find(&:failing?)
+        if failing_check
+          failing_check.report
+          failing_check.exit_code
+        else
+          SimpleCov::ExitCodes::SUCCESS
+        end
+      end
+
+      def coverage_checks(result, coverage_limits)
+        [
+          MinimumOverallCoverageCheck.new(result, coverage_limits.minimum_coverage),
+          MinimumCoverageByFileCheck.new(result, coverage_limits.minimum_coverage_by_file),
+          MaximumCoverageDropCheck.new(result, coverage_limits.maximum_coverage_drop)
+        ]
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MaximumCoverageDropCheck
+      def initialize(result, maximum_coverage_drop)
+        @result = result
+        @maximum_coverage_drop = maximum_coverage_drop
+      end
+
+      def failing?
+        return false unless maximum_coverage_drop && last_run
+
+        coverage_diff > maximum_coverage_drop
+      end
+
+      def report
+        $stderr.printf(
+          "Coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
+          drop_percent: coverage_diff,
+          max_drop: maximum_coverage_drop
+        )
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
+      end
+
+    private
+
+      attr_reader :result, :maximum_coverage_drop
+
+      def last_run
+        return @last_run if defined?(@last_run)
+
+        @last_run = SimpleCov::LastRun.read
+      end
+
+      def coverage_diff
+        raise "Trying to access coverage_diff although there is no last run" unless last_run
+
+        @coverage_diff ||= last_run[:result][:covered_percent] - covered_percent
+      end
+
+      def covered_percent
+        SimpleCov.round_coverage(result.covered_percent)
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MinimumCoverageByFileCheck
+      def initialize(result, minimum_coverage_by_file)
+        @result = result
+        @minimum_coverage_by_file = minimum_coverage_by_file
+      end
+
+      def failing?
+        covered_percentages.any? { |p| p < minimum_coverage_by_file }
+      end
+
+      def report
+        $stderr.printf(
+          "File (%<file>s) is only (%<least_covered_percentage>.2f%%) covered. This is below the expected minimum coverage per file of (%<min_coverage>.2f%%).\n",
+          file: result.least_covered_file,
+          least_covered_percentage: covered_percentages.min,
+          min_coverage: minimum_coverage_by_file
+        )
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      attr_reader :result, :minimum_coverage_by_file
+
+      def covered_percentages
+        @covered_percentages ||=
+          result.covered_percentages.map { |percentage| SimpleCov.round_coverage(percentage) }
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MinimumOverallCoverageCheck
+      def initialize(result, minimum_coverage)
+        @result = result
+        @minimum_coverage = minimum_coverage
+      end
+
+      def failing?
+        minimum_violations.any?
+      end
+
+      def report
+        minimum_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
+            minimum_coverage: violation.fetch(:minimum_expected),
+            criterion: violation.fetch(:criterion).capitalize
+          )
+        end
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      attr_reader :result, :minimum_coverage
+
+      def minimum_violations
+        @minimum_violations ||= calculate_minimum_violations
+      end
+
+      def calculate_minimum_violations
+        coverage_achieved = minimum_coverage.map do |criterion, percent|
+          {
+            criterion: criterion,
+            minimum_expected: percent,
+            actual: result.coverage_statistics.fetch(criterion).percent
+          }
+        end
+
+        coverage_achieved.select do |achieved|
+          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/filter.rb

@@ -14,6 +14,7 @@ module SimpleCov
   #
   class Filter
     attr_reader :filter_argument
+
     def initialize(filter_argument)
       @filter_argument = filter_argument
     end
@@ -34,13 +35,14 @@ module SimpleCov
     end
 
     def self.class_for_argument(filter_argument)
-      if filter_argument.is_a?(String)
+      case filter_argument
+      when String
         SimpleCov::StringFilter
-      elsif filter_argument.is_a?(Regexp)
+      when Regexp
         SimpleCov::RegexFilter
-      elsif filter_argument.is_a?(Array)
+      when Array
         SimpleCov::ArrayFilter
-      elsif filter_argument.is_a?(Proc)
+      when Proc
         SimpleCov::BlockFilter
       else
         raise ArgumentError, "You have provided an unrecognized filter type"
@@ -50,7 +52,7 @@ module SimpleCov
 
   class StringFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # string configured when initializing this Filter with StringFilter.new('somestring)
+    # string configured when initializing this Filter with StringFilter.new('somestring')
     def matches?(source_file)
       source_file.project_filename.include?(filter_argument)
     end

data/lib/simplecov/formatter.rb

@@ -6,5 +6,5 @@ module SimpleCov
   end
 end
 
-require "simplecov/formatter/simple_formatter"
-require "simplecov/formatter/multi_formatter"
+require_relative "formatter/simple_formatter"
+require_relative "formatter/multi_formatter"

data/lib/simplecov/formatter/multi_formatter.rb

@@ -6,12 +6,10 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            begin
-              formatter.new.format(result)
-            rescue StandardError => e
-              warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
-              nil
-            end
+            formatter.new.format(result)
+          rescue StandardError => e
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            nil
           end
         end
       end
@@ -27,7 +25,7 @@ module SimpleCov
 
       def self.[](*args)
         warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
-        new(Array([*args]))
+        new(Array(args))
       end
     end
   end

data/lib/simplecov/lines_classifier.rb

@@ -13,18 +13,18 @@ module SimpleCov
     WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
 
     def self.no_cov_line
-      /^(\s*)#(\s*)(\:#{SimpleCov.nocov_token}\:)/o
+      /^(\s*)#(\s*)(:#{SimpleCov.nocov_token}:)/o
     end
 
     def self.no_cov_line?(line)
-      line =~ no_cov_line
+      no_cov_line.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false
     end
 
     def self.whitespace_line?(line)
-      line =~ WHITESPACE_OR_COMMENT_LINE
+      WHITESPACE_OR_COMMENT_LINE.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false

data/lib/simplecov/no_defaults.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
-require "simplecov"
+require_relative "../simplecov"

data/lib/simplecov/process.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Process
+  class << self
+    def fork_with_simplecov(&block)
+      if defined?(SimpleCov) && SimpleCov.running
+        fork_without_simplecov do
+          SimpleCov.at_fork.call(Process.pid)
+          block.call if block_given?
+        end
+      else
+        fork_without_simplecov(&block)
+      end
+    end
+
+    alias fork_without_simplecov fork
+    alias fork fork_with_simplecov
+  end
+end