simplecov 0.18.0 → 0.19.0

data/lib/simplecov/combine.rb

@@ -9,8 +9,8 @@ module SimpleCov
     #
     # Combine two coverage based on the given combiner_module.
     #
-    # Combiners should always be called throught his interface,
-    # as it takes care of short circuting of one of the coverages is nil.
+    # 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)

data/lib/simplecov/combine/branches_combiner.rb

@@ -10,9 +10,9 @@ module SimpleCov
     module_function
 
       #
-      # Return merged branches or the existed branche if other is missing.
+      # Return merged branches or the existed brach if other is missing.
       #
-      # Branches inside files are always same if they exists, the difference only in coverage count.
+      # 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...}

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

@@ -19,7 +19,7 @@ module SimpleCov
           [
             covered + file_coverage_statistics.covered,
             missed + file_coverage_statistics.missed,
-            # gotta remultiply with loc because files have different strenght and loc
+            # 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)
           ]
@@ -35,14 +35,14 @@ module SimpleCov
       @covered  = covered
       @missed   = missed
       @total    = covered + missed
-      @percent  = compute_percent(covered, total)
-      @strength = compute_strength(total_strength, @total)
+      @percent  = compute_percent(covered, missed, total)
+      @strength = compute_strength(total_strength, total)
     end
 
   private
 
-    def compute_percent(covered, total)
-      return 100.0 if total.zero?
+    def compute_percent(covered, missed, total)
+      return 100.0 if missed.zero?
 
       covered * 100.0 / total
     end

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
@@ -22,17 +22,13 @@ end
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
+  next if SimpleCov.external_at_exit?
 
-  # If SimpleCov is no longer running then don't run exit tasks
-  next unless SimpleCov.running
-
-  SimpleCov.run_exit_tasks!
+  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,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"