simplecov 0.15.1 → 0.18.0.beta2

data/lib/simplecov/combine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Functionally for combining coverage results
+  #
+  module Combine
+  module_function
+
+    #
+    # 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.
+    #
+    # @return [Hash]
+    def combine(combiner_module, coverage_a, coverage_b)
+      return existing_coverage(coverage_a, coverage_b) if empty_coverage?(coverage_a, coverage_b)
+
+      combiner_module.combine(coverage_a, coverage_b)
+    end
+
+    def empty_coverage?(coverage_a, coverage_b)
+      !(coverage_a && coverage_b)
+    end
+
+    def existing_coverage(coverage_a, coverage_b)
+      coverage_a || coverage_b
+    end
+  end
+end

data/lib/simplecov/combine/branches_combiner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Combine
+    #
+    # Combine different branch coverage results on single file.
+    #
+    # Should be called through `SimpleCov.combine`.
+    module BranchesCombiner
+    module_function
+
+      #
+      # Return merged branches or the existed branche if other is missing.
+      #
+      # Branches inside files are always same if they exists, 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...}
+      # We create copy of result and update it values depending on the combined branches coverage values.
+      #
+      # @return [Hash]
+      #
+      def combine(coverage_a, coverage_b)
+        coverage_a.merge(coverage_b) do |_condition, branches_inside_a, branches_inside_b|
+          branches_inside_a.merge(branches_inside_b) do |_branch, a_count, b_count|
+            a_count + b_count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/combine/files_combiner.rb

@@ -0,0 +1,24 @@
+# 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)
+        combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
+        combination["branches"] = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"]) if SimpleCov.branch_coverage?
+        combination
+      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,100 @@
+# 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 |combined_results, next_result|
+          combine_result_sets(combined_results, next_result)
+        end
+      end
+
+      #
+      # Manage combining results on files level
+      #
+      # @param [Hash] combined_results
+      # @param [Hash] result
+      #
+      # @return [Hash]
+      #
+      def combine_result_sets(combined_results, result)
+        unless correct_format?(result)
+          warn_wrong_format
+          return combined_results
+        end
+
+        results_files = combined_results.keys | result.keys
+
+        results_files.each_with_object({}) do |file_name, file_combination|
+          file_combination[file_name] = combine_file_coverage(
+            combined_results[file_name],
+            result[file_name]
+          )
+        end
+      end
+
+      # We might start a run of a new simplecov version with a new format stored while
+      # there is still a recent file like this lying around. If it's recent enough (
+      # see merge_timeout) it will end up here. In order not to crash against this
+      # we need to do some basic checking of the format of data we expect and
+      # otherwise ignore it. See #820
+      #
+      # Currently correct format is:
+      # { file_path_string => {coverage_criterion => coverage_date}}
+      #
+      # Internal use/reliance only.
+      def correct_format?(result)
+        result.empty? || matches_current_format?(result)
+      end
+
+      def matches_current_format?(result)
+        # I so wish I could already use pattern matching
+        key, data = result.first
+
+        key.is_a?(String) && second_level_choice_of_criterion?(data)
+      end
+
+      SECOND_LEVEL_KEYS = %w[lines branches].freeze
+      def second_level_choice_of_criterion?(data)
+        second_level_key, = data.first
+
+        SECOND_LEVEL_KEYS.member?(second_level_key)
+      end
+
+      def warn_wrong_format
+        warn "Merging results, encountered an incorrectly formatted value. "\
+          "This value was ignored.\nIf you just upgraded simplecov this is "\
+          "likely due to a changed file format. If this happens again please "\
+          "file a bug. https://github.com/colszowka/simplecov/issues"
+      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,76 @@ 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 `: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 coverage_criterion_enabled?(criterion)
+      coverage_criteria.member?(criterion)
+    end
+
+    def clear_coverage_criteria
+      @coverage_criteria = nil
+    end
+
+    def branch_coverage?
+      branch_coverage_supported? && coverage_criterion_enabled?(:branch)
+    end
+
+    def coverage_start_arguments_supported?
+      # safe to cache as within one process this value should never
+      # change
+      return @coverage_start_arguments_supported if defined?(@coverage_start_arguments_supported)
+
+      @coverage_start_arguments_supported = begin
+        require "coverage"
+        !Coverage.method(:start).arity.zero?
+      end
+    end
+
+    alias branch_coverage_supported? coverage_start_arguments_supported?
+
   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
     #