simplecov 0.15.1 → 0.18.0.beta1

data/lib/simplecov/combine/files_combiner.rb

@@ -0,0 +1,25 @@
+# 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)
+        {
+          :lines => Combine.combine(LinesCombiner, coverage_a[:lines], coverage_b[:lines]),
+          :branches => Combine.combine(BranchesCombiner, coverage_a[:branches], coverage_b[:branches])
+        }
+      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 |result, next_result|
+          combine_result_sets(result, next_result)
+        end
+      end
+
+      #
+      # Manage combining results on files level
+      #
+      # @param [Hash] result_a
+      # @param [Hash] result_b
+      #
+      # @return [Hash]
+      #
+      def combine_result_sets(result_a, result_b)
+        results_files = result_a.keys | result_b.keys
+
+        results_files.each_with_object({}) do |file_name, combined_results|
+          combined_results[file_name] = combine_file_coverage(
+            result_a[file_name],
+            result_b[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/command_guesser.rb

@@ -1,7 +1,9 @@
-#
-# Helper that tries to find out what test suite is running (for SimpleCov.command_name)
-#
+# frozen_string_literal: true
+
 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.
@@ -20,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']})"
@@ -46,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

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 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.
-#
+
 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 # rubocop:disable Metrics/ModuleLength
+    attr_writer :filters, :groups, :formatter, :print_error_status
 
     #
     # The root for the project. This defaults to the
@@ -18,6 +21,7 @@ module SimpleCov
     #
     def root(root = nil)
       return @root if defined?(@root) && root.nil?
+
       @root = File.expand_path(root || Dir.getwd)
     end
 
@@ -28,6 +32,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
@@ -91,8 +96,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
 
@@ -114,6 +121,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
@@ -123,6 +138,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
@@ -158,7 +174,6 @@ module SimpleCov
     # options at once.
     #
     def configure(&block)
-      return false unless SimpleCov.usable?
       Docile.dsl_eval(self, &block)
     end
 
@@ -176,6 +191,7 @@ module SimpleCov
     #
     def at_exit(&block)
       return proc {} unless running || block_given?
+
       @at_exit = block if block_given?
       @at_exit ||= proc { SimpleCov.result.format! }
     end
@@ -186,6 +202,7 @@ module SimpleCov
     #
     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
@@ -223,6 +240,7 @@ module SimpleCov
     # Default is 0% (disabled)
     #
     def minimum_coverage(coverage = nil)
+      minimum_possible_coverage_exceeded("minimum_coverage") if coverage && coverage > 100
       @minimum_coverage ||= (coverage || 0).to_f.round(2)
     end
 
@@ -244,6 +262,7 @@ 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)
     end
 
@@ -285,8 +304,60 @@ 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 is `:line`
+    #
+    # @param [Symbol] criterion
+    #
+    def coverage_criterion(criterion = nil)
+      return @coverage_criterion ||= DEFAULT_COVERAGE_CRITERION 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 coverage_criteria
+      @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
+    end
+
+    def branch_coverage?
+      branch_coverage_supported? && coverage_criteria.member?(:branch)
+    end
+
+    def branch_coverage_supported?
+      require "coverage"
+      !Coverage.method(:start).arity.zero?
+    end
+
   private
 
+    def raise_if_criterion_unsupported(criterion)
+      raise_criterion_unsupported(criterion) unless SUPPORTED_COVERAGE_CRITERIA.member?(criterion)
+    end
+
+    def raise_criterion_unsupported(criterion)
+      raise "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
+    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/defaults.rb

@@ -1,48 +1,19 @@
+# frozen_string_literal: true
+
 # Load default formatter gem
 require "simplecov-html"
 require "pathname"
-
-SimpleCov.profiles.define "root_filter" do
-  # Exclude all files outside of simplecov root
-  root_filter = nil
-  add_filter do |src|
-    root_filter ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io
-    src.filename !~ root_filter
-  end
-end
-
-SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
-end
-
-SimpleCov.profiles.define "bundler_filter" do
-  add_filter "/vendor/bundle/"
-end
-
-SimpleCov.profiles.define "rails" do
-  load_profile "test_frameworks"
-
-  add_filter %r{^/config/}
-  add_filter %r{^/db/}
-
-  add_group "Controllers", "app/controllers"
-  add_group "Channels", "app/channels" if defined?(ActionCable)
-  add_group "Models", "app/models"
-  add_group "Mailers", "app/mailers"
-  add_group "Helpers", "app/helpers"
-  add_group "Jobs", %w[app/jobs app/workers]
-  add_group "Libraries", "lib"
-
-  track_files "{app,lib}/**/*.rb"
-end
+require "simplecov/profiles/root_filter"
+require "simplecov/profiles/test_frameworks"
+require "simplecov/profiles/bundler_filter"
+require "simplecov/profiles/hidden_filter"
+require "simplecov/profiles/rails"
 
 # Default configuration
 SimpleCov.configure do
   formatter SimpleCov::Formatter::HTMLFormatter
   load_profile "bundler_filter"
+  load_profile "hidden_filter"
   # Exclude files outside of SimpleCov.root
   load_profile "root_filter"
 end
@@ -50,52 +21,12 @@ end
 # Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
-at_exit do # rubocop:disable Metrics/BlockLength
+at_exit do
   # If we are in a different process than called start, don't interfere.
   next if SimpleCov.pid != Process.pid
 
-  @exit_status = if $! # was an exception thrown?
-                   # if it was a SystemExit, use the accompanying status
-                   # otherwise set a non-zero status representing termination by
-                   # some other exception (see github issue 41)
-                   $!.is_a?(SystemExit) ? $!.status : SimpleCov::ExitCodes::EXCEPTION
-                 else
-                   # Store the exit status of the test run since it goes away
-                   # after calling the at_exit proc...
-                   SimpleCov::ExitCodes::SUCCESS
-                 end
-
-  SimpleCov.at_exit.call
-
-  if SimpleCov.result? # Result has been computed
-    covered_percent = SimpleCov.result.covered_percent.round(2)
-    covered_percentages = SimpleCov.result.covered_percentages.map { |p| p.round(2) }
-
-    if @exit_status == SimpleCov::ExitCodes::SUCCESS # No other errors
-      if covered_percent < SimpleCov.minimum_coverage # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("Coverage (%.2f%%) is below the expected minimum coverage (%.2f%%).\n", covered_percent, SimpleCov.minimum_coverage)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file } # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("File (%s) is only (%.2f%%) covered. This is below the expected minimum coverage per file of (%.2f%%).\n", SimpleCov.result.least_covered_file, covered_percentages.min, SimpleCov.minimum_coverage_by_file)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif (last_run = SimpleCov::LastRun.read) # rubocop:disable Metrics/BlockNesting
-        coverage_diff = last_run["result"]["covered_percent"] - covered_percent
-        if coverage_diff > SimpleCov.maximum_coverage_drop # rubocop:disable Metrics/BlockNesting
-          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", coverage_diff, SimpleCov.maximum_coverage_drop)
-          @exit_status = SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-        end
-      end
-    end
-
-    # Don't overwrite last_run file if refuse_coverage_drop option is enabled and the coverage has dropped
-    unless @exit_status == SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-      SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
-    end
-  end
-
-  # Force exit with stored status (see github issue #5)
-  # unless it's nil or 0 (see github issue #281)
-  Kernel.exit @exit_status if @exit_status && @exit_status > 0
+  SimpleCov.set_exit_exception
+  SimpleCov.run_exit_tasks!
 end
 
 # Autoload config from ~/.simplecov if present
@@ -111,7 +42,7 @@ loop do
     begin
       load filename
     rescue LoadError, StandardError
-      $stderr.puts "Warning: Error occurred while trying to load #{filename}. " \
+      warn "Warning: Error occurred while trying to load #{filename}. " \
         "Error message: #{$!.message}"
     end
     break