simplecov 0.20.0 → 0.21.1

data/README.md

@@ -295,7 +295,6 @@ information to be lost.
 Add branch coverage measurement statistics to your results. Supported in CRuby versions 2.5+.
 
 ```ruby
-# or in configure or just SimpleCov.enable_coverage :branch
 SimpleCov.start do
   enable_coverage :branch
 end
@@ -341,6 +340,22 @@ Hence, we recommend looking at both metrics together. Branch coverage might also
 overall metric to look at - while you might be missing only 10% of your lines that might
 account for 50% of your branches for instance.
 
+## Primary Coverage
+
+By default, the primary coverage type is `line`. To set the primary coverage to something else, use the following:
+
+```ruby
+# or in configure SimpleCov.primary_coverage :branch
+SimpleCov.start do
+  enable_coverage :branch
+  primary_coverage :branch
+end
+```
+
+Primary coverage determines what will come in first all output, and the type of coverage to check if you don't specify the type of coverage when customizing exit behavior (`SimpleCov.minimum_coverage 90`).
+
+Note that coverage must first be enabled for non-default coverage types.
+
 ## Filters
 
 Filters can be used to remove selected files from your coverage data. By default, a filter is applied that removes all
@@ -787,30 +802,36 @@ to help ensure coverage is relatively consistent, rather than being skewed by pa
 
 ```ruby
 SimpleCov.minimum_coverage_by_file 80
+# same as above (the default is to check line coverage by file)
+SimpleCov.minimum_coverage_by_file line: 80
+# check for a minimum line coverage by file of 90% and minimum 80% branch coverage
+SimpleCov.minimum_coverage_by_file line: 90, branch: 80
 ```
 
-(not yet supported for branch coverage)
-
 ### Maximum coverage drop
 
 You can define the maximum coverage drop percentage at once. SimpleCov will return non-zero if exceeded.
 
 ```ruby
 SimpleCov.maximum_coverage_drop 5
+# same as above (the default is to check line drop)
+SimpleCov.maximum_coverage_drop line: 5
+# check for a maximum line drop of 5% and maximum 10% branch drop
+SimpleCov.maximum_coverage_drop line: 5, branch: 10
 ```
 
-(not yet supported for branch coverage)
-
 ### Refuse dropping coverage
 
 You can also entirely refuse dropping coverage between test runs:
 
 ```ruby
 SimpleCov.refuse_coverage_drop
+# same as above (the default is to only refuse line drop)
+SimpleCov.refuse_coverage_drop :line
+# refuse drop for line and branch
+SimpleCov.refuse_coverage_drop :line, :branch
 ```
 
-(not yet supported for branch coverage)
-
 ## Using your own formatter
 
 You can use your own formatter with:

data/lib/simplecov.rb

@@ -3,7 +3,7 @@
 require "English"
 
 # Coverage may be inaccurate under JRUBY.
-if defined?(JRUBY_VERSION) && defined?(JRuby)
+if defined?(JRUBY_VERSION) && defined?(JRuby) && !org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
 
   # @see https://github.com/jruby/jruby/issues/1196
   # @see https://github.com/metricfu/metric_fu/pull/226
@@ -11,11 +11,9 @@ if defined?(JRUBY_VERSION) && defined?(JRuby)
   # @see https://github.com/simplecov-ruby/simplecov/issues/86
   # @see https://jira.codehaus.org/browse/JRUBY-6106
 
-  unless org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
-    warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
-      ' or do JRUBY_OPTS="--debug"' \
-      ' or set the "debug.fullTrace=true" option in your .jrubyrc'
-  end
+  warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
+    ' or do JRUBY_OPTS="--debug"' \
+    ' or set the "debug.fullTrace=true" option in your .jrubyrc'
 end
 
 #
@@ -63,6 +61,7 @@ module SimpleCov
 
     #
     # Collate a series of SimpleCov result files into a single SimpleCov output.
+    #
     # You can optionally specify configuration with a block:
     #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
     #    OR
@@ -80,18 +79,17 @@ module SimpleCov
     # available config options, or checkout the README for more in-depth
     # information about coverage collation
     #
-    def collate(result_filenames, profile = nil, &block)
-      raise "There's no reports to be merged" if result_filenames.empty?
+    # By default `collate` ignores the merge_timeout so all results of all files specified will be
+    # merged together. If you want to honor the merge_timeout then provide the keyword argument
+    # `ignore_timeout: false`.
+    #
+    def collate(result_filenames, profile = nil, ignore_timeout: true, &block)
+      raise "There are no reports to be merged" if result_filenames.empty?
 
       initial_setup(profile, &block)
 
-      results = result_filenames.flat_map do |filename|
-        # Re-create each included instance of SimpleCov::Result from the stored run data.
-        Result.from_hash(JSON.parse(File.read(filename)) || {})
-      end
-
       # Use the ResultMerger to produce a single, merged result, ready to use.
-      @result = ResultMerger.merge_and_store(*results)
+      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
 
       run_exit_tasks!
     end
@@ -285,7 +283,10 @@ module SimpleCov
     # @api private
     #
     def write_last_run(result)
-      SimpleCov::LastRun.write(result: {covered_percent: round_coverage(result.covered_percent)})
+      SimpleCov::LastRun.write(result:
+        result.coverage_statistics.transform_values do |stats|
+          round_coverage(stats.percent)
+        end)
     end
 
     #

data/lib/simplecov/configuration.rb

@@ -10,7 +10,7 @@ module SimpleCov
   # defined here are usable from SimpleCov directly. Please check out
   # SimpleCov documentation for further info.
   #
-  module Configuration # rubocop:disable Metrics/ModuleLength
+  module Configuration
     attr_writer :filters, :groups, :formatter, :print_error_status
 
     #
@@ -191,7 +191,7 @@ 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! }
@@ -287,20 +287,22 @@ 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 = {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("minimum_coverage") if percent && percent > 100
+        minimum_possible_coverage_exceeded(coverage_setting) 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.
@@ -309,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
 
     #
@@ -320,16 +328,23 @@ module SimpleCov
     # Default is 0% (disabled)
     #
     def minimum_coverage_by_file(coverage = nil)
-      minimum_possible_coverage_exceeded("minimum_coverage_by_file") if coverage && coverage > 100
-      @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
 
     #
@@ -376,7 +391,7 @@ module SimpleCov
     # @param [Symbol] criterion
     #
     def coverage_criterion(criterion = nil)
-      return @coverage_criterion ||= DEFAULT_COVERAGE_CRITERION unless criterion
+      return @coverage_criterion ||= primary_coverage unless criterion
 
       raise_if_criterion_unsupported(criterion)
 
@@ -389,8 +404,17 @@ module SimpleCov
       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[DEFAULT_COVERAGE_CRITERION]
+      @coverage_criteria ||= Set[primary_coverage]
     end
 
     def coverage_criterion_enabled?(criterion)

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -11,15 +11,18 @@ module SimpleCov
       def failing?
         return false unless maximum_coverage_drop && last_run
 
-        coverage_diff > maximum_coverage_drop
+        coverage_drop_violations.any?
       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
-        )
+        coverage_drop_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
+            criterion: violation[:criterion].capitalize,
+            drop_percent: SimpleCov.round_coverage(violation[:drop_percent]),
+            max_drop: violation[:max_drop]
+          )
+        end
       end
 
       def exit_code
@@ -36,14 +39,34 @@ module SimpleCov
         @last_run = SimpleCov::LastRun.read
       end
 
-      def coverage_diff
-        raise "Trying to access coverage_diff although there is no last run" unless last_run
+      def coverage_drop_violations
+        @coverage_drop_violations ||=
+          compute_coverage_drop_data.select do |achieved|
+            achieved.fetch(:max_drop) < achieved.fetch(:drop_percent)
+          end
+      end
 
-        @coverage_diff ||= last_run[:result][:covered_percent] - covered_percent
+      def compute_coverage_drop_data
+        maximum_coverage_drop.map do |criterion, percent|
+          {
+            criterion: criterion,
+            max_drop: percent,
+            drop_percent: last_coverage(criterion) -
+              SimpleCov.round_coverage(
+                result.coverage_statistics.fetch(criterion).percent
+              )
+          }
+        end
       end
 
-      def covered_percent
-        SimpleCov.round_coverage(result.covered_percent)
+      def last_coverage(criterion)
+        last_coverage_percent = last_run[:result][criterion]
+
+        if !last_coverage_percent && criterion == "line"
+          last_run[:result][:covered_percent]
+        else
+          last_coverage_percent
+        end
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -9,16 +9,18 @@ module SimpleCov
       end
 
       def failing?
-        covered_percentages.any? { |p| p < minimum_coverage_by_file }
+        minimum_violations.any?
       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
-        )
+        minimum_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage by file (%<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
@@ -29,9 +31,23 @@ module SimpleCov
 
       attr_reader :result, :minimum_coverage_by_file
 
-      def covered_percentages
-        @covered_percentages ||=
-          result.covered_percentages.map { |percentage| SimpleCov.round_coverage(percentage) }
+      def minimum_violations
+        @minimum_violations ||=
+          compute_minimum_coverage_data.select do |achieved|
+            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+          end
+      end
+
+      def compute_minimum_coverage_data
+        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
+          result.coverage_statistics_by_file.fetch(criterion).map do |actual_coverage|
+            {
+              criterion: criterion,
+              minimum_expected: expected_percent,
+              actual: SimpleCov.round_coverage(actual_coverage.percent)
+            }
+          end
+        end
       end
     end
   end

data/lib/simplecov/file_list.rb

@@ -27,6 +27,10 @@ module SimpleCov
       @coverage_statistics ||= compute_coverage_statistics
     end
 
+    def coverage_statistics_by_file
+      @coverage_statistics_by_file ||= compute_coverage_statistics_by_file
+    end
+
     # Returns the count of lines that have coverage
     def covered_lines
       coverage_statistics[:line]&.covered
@@ -100,14 +104,16 @@ module SimpleCov
 
   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?
+    def compute_coverage_statistics_by_file
+      @files.each_with_object(line: [], branch: []) do |file, together|
+        together[:line] << file.coverage_statistics.fetch(:line)
+        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
       end
+    end
 
-      coverage_statistics = {line: CoverageStatistics.from(total_coverage_statistics[:line])}
-      coverage_statistics[:branch] = CoverageStatistics.from(total_coverage_statistics[:branch]) if SimpleCov.branch_coverage?
+    def compute_coverage_statistics
+      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
+      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
       coverage_statistics
     end
   end

data/lib/simplecov/result.rb

@@ -20,13 +20,13 @@ 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, :coverage_statistics
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
     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
     # coverage data)
     def initialize(original_result, command_name: nil, created_at: nil)
-      result = adapt_result(original_result)
+      result = original_result
       @original_result = result.freeze
       @command_name = command_name
       @created_at = created_at
@@ -72,10 +72,6 @@ module SimpleCov
       }
     end
 
-    def time_since_creation
-      Time.now - created_at
-    end
-
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       hash.map do |command_name, data|
@@ -85,31 +81,6 @@ module SimpleCov
 
   private
 
-    # 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/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)
-      else
-        result
-      end
-    end
-
-    # pre 0.18 coverage data pointed from file directly to an array of line coverage
-    def pre_simplecov_0_18_result?(result)
-      _key, data = result.first
-
-      data.is_a?(Array)
-    end
-
-    def adapt_pre_simplecov_0_18_result(result)
-      result.transform_values do |line_coverage_data|
-        {"lines" => line_coverage_data}
-      end
-    end
-
     def coverage
       keys = original_result.keys & filenames
       Hash[keys.zip(original_result.values_at(*keys))]