simplecov 0.18.5 → 0.19.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
   #
@@ -196,6 +196,52 @@ 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)
+      @enable_for_subprocesses = value unless value.nil?
+      @enable_for_subprocesses || 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 +285,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/defaults.rb

@@ -3,11 +3,11 @@
 # 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 "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
@@ -28,7 +28,7 @@ at_exit do
 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,7 +13,7 @@ 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)

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

data/lib/simplecov/result.rb

@@ -25,9 +25,11 @@ module SimpleCov
 
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
     # coverage data)
-    def initialize(original_result)
+    def initialize(original_result, command_name: nil, created_at: nil)
       result = adapt_result(original_result)
       @original_result = result.freeze
+      @command_name = command_name
+      @created_at = created_at
       @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))
@@ -70,15 +72,15 @@ module SimpleCov
       }
     end
 
+    def time_since_creation
+      Time.now - created_at
+    end
+
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
-      command_name, data = hash.first
-
-      result = SimpleCov::Result.new(data["coverage"])
-
-      result.command_name = command_name
-      result.created_at = Time.at(data["timestamp"])
-      result
+      hash.map do |command_name, data|
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+      end
     end
 
   private
@@ -86,7 +88,7 @@ module SimpleCov
     # 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
+    # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
     def adapt_result(result)
       if pre_simplecov_0_18_result?(result)
         adapt_pre_simplecov_0_18_result(result)
@@ -103,9 +105,9 @@ module SimpleCov
     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
+      result.transform_values do |line_coverage_data|
+        {"lines" => line_coverage_data}
+      end
     end
 
     def coverage