simplecov 0.8.0.pre2 → 0.18.0.beta1

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,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,33 +1,36 @@
-#
-# Helper that tries to find out what test suite is running (for SimpleCov.command_name)
-#
-module SimpleCov::CommandGuesser
-  class << self
-    # Storage for the original command line call that invoked the test suite.
-    # This has got to be stored as early as possible because i.e. rake and test/unit 2
-    # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
-    # between rails unit/functional/integration tests impossible without this cached
-    # item.
-    attr_accessor :original_run_command
-    
-    def guess
-      from_env || from_command_line_options || from_defined_constants
-    end
-    
+# 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.
+      # This has got to be stored as early as possible because i.e. rake and test/unit 2
+      # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
+      # between rails unit/functional/integration tests impossible without this cached
+      # item.
+      attr_accessor :original_run_command
+
+      def guess
+        from_env || from_command_line_options || from_defined_constants
+      end
+
     private
 
-    def from_env
-      # If being run from inside parallel_tests set the command name according to the process number
-      if ENV['PARALLEL_TEST_GROUPS'] && ENV['TEST_ENV_NUMBER']
-        number = ENV['TEST_ENV_NUMBER']
-        number = '1' if number == ''
+      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']})"
       end
-    end
-    
-    def from_command_line_options
-      case original_run_command
-        when /test\/functional\//, /test\/{.*?functional.*?}\//
+
+      def from_command_line_options
+        case original_run_command
+        when /test\/functional\//, /test\/\{.*functional.*\}\//
           "Functional Tests"
         when /test\/integration\//
           "Integration Tests"
@@ -37,21 +40,24 @@ module SimpleCov::CommandGuesser
           "RSpec"
         when /cucumber/, /features/
           "Cucumber Features"
-        else
-          nil
+        end
       end
-    end
-  
-    def from_defined_constants
-      # If the command regexps fail, let's try checking defined constants.
-      if defined?(RSpec)
-        "RSpec"
-      elsif defined?(Test::Unit)
-        "Unit Tests"
-      else
-        # TODO: Provide link to docs/wiki article
-        warn "SimpleCov failed to recognize the test framework and/or suite used. Please specify manually using SimpleCov.command_name 'Unit Tests'."
-        'Unknown Test Framework'
+
+      def from_defined_constants
+        # If the command regexps fail, let's try checking defined constants.
+        if defined?(RSpec)
+          "RSpec"
+        elsif defined?(Test::Unit)
+          "Unit Tests"
+        elsif defined?(Minitest)
+          "Minitest"
+        elsif defined?(MiniTest)
+          "MiniTest"
+        else
+          # TODO: Provide link to docs/wiki article
+          warn "SimpleCov failed to recognize the test framework and/or suite used. Please specify manually using SimpleCov.command_name 'Unit Tests'."
+          "Unknown Test Framework"
+        end
       end
     end
   end

data/lib/simplecov/configuration.rb

@@ -1,249 +1,374 @@
-require 'fileutils'
-require 'docile'
-#
-# 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::Configuration
-  attr_writer :filters, :groups, :formatter
+# frozen_string_literal: true
 
-  #
-  # The root for the project. This defaults to the
-  # current working directory.
-  #
-  # Configure with SimpleCov.root('/my/project/path')
-  #
-  def root(root=nil)
-    return @root if defined? @root and root.nil?
-    @root = File.expand_path(root || Dir.getwd)
-  end
+require "fileutils"
+require "docile"
+require "simplecov/formatter/multi_formatter"
 
+module SimpleCov
   #
-  # The name of the output and cache directory. Defaults to 'coverage'
-  #
-  # Configure with SimpleCov.coverage_dir('cov')
+  # Bundles the configuration options used for SimpleCov. All methods
+  # defined here are usable from SimpleCov directly. Please check out
+  # SimpleCov documentation for further info.
   #
-  def coverage_dir(dir=nil)
-    return @coverage_dir if defined? @coverage_dir and dir.nil?
-    @coverage_dir = (dir || 'coverage')
-  end
+  module Configuration # rubocop:disable Metrics/ModuleLength
+    attr_writer :filters, :groups, :formatter, :print_error_status
 
-  #
-  # Returns the full path to the output directory using SimpleCov.root
-  # and SimpleCov.coverage_dir, so you can adjust this by configuring those
-  # values. Will create the directory if it's missing
-  #
-  def coverage_path
-    coverage_path = File.expand_path(coverage_dir, root)
-    FileUtils.mkdir_p coverage_path
-    coverage_path
-  end
+    #
+    # The root for the project. This defaults to the
+    # current working directory.
+    #
+    # Configure with SimpleCov.root('/my/project/path')
+    #
+    def root(root = nil)
+      return @root if defined?(@root) && root.nil?
 
-  #
-  # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
-  #
-  def filters
-    @filters ||= []
-  end
+      @root = File.expand_path(root || Dir.getwd)
+    end
 
-  # The name of the command (a.k.a. Test Suite) currently running. Used for result
-  # merging and caching. It first tries to make a guess based upon the command line
-  # arguments the current test suite is running on and should automatically detect
-  # unit tests, functional tests, integration tests, rpsec and cucumber and label
-  # them properly. If it fails to recognize the current command, the command name
-  # is set to the shell command that the current suite is running on.
-  #
-  # You can specify it manually with SimpleCov.command_name("test:units") - please
-  # also check out the corresponding section in README.rdoc
-  def command_name(name=nil)
-    @name = name unless name.nil?
-    @name ||= SimpleCov::CommandGuesser.guess
-    @name
-  end
+    #
+    # The name of the output and cache directory. Defaults to 'coverage'
+    #
+    # Configure with SimpleCov.coverage_dir('cov')
+    #
+    def coverage_dir(dir = nil)
+      return @coverage_dir if defined?(@coverage_dir) && dir.nil?
 
-  #
-  # Gets or sets the configured formatter.
-  #
-  # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
-  #
-  def formatter(formatter=nil)
-    return @formatter if defined? @formatter and formatter.nil?
-    @formatter = formatter
-    raise "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
-    @formatter
-  end
+      @coverage_path = nil # invalidate cache
+      @coverage_dir = (dir || "coverage")
+    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
-  # can be configured to be any other string using this.
-  #
-  # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
-  #
-  def nocov_token(nocov_token=nil)
-    return @nocov_token if defined? @nocov_token and nocov_token.nil?
-    @nocov_token = (nocov_token || 'nocov')
-  end
-  alias_method :skip_token, :nocov_token
+    #
+    # Returns the full path to the output directory using SimpleCov.root
+    # and SimpleCov.coverage_dir, so you can adjust this by configuring those
+    # values. Will create the directory if it's missing
+    #
+    def coverage_path
+      @coverage_path ||= begin
+        coverage_path = File.expand_path(coverage_dir, root)
+        FileUtils.mkdir_p coverage_path
+        coverage_path
+      end
+    end
 
-  #
-  # Returns the configured groups. Add groups using SimpleCov.add_group
-  #
-  def groups
-    @groups ||= {}
-  end
+    #
+    # Coverage results will always include files matched by this glob, whether
+    # or not they were explicitly required. Without this, un-required files
+    # will not be present in the final report.
+    #
+    def track_files(glob)
+      @tracked_files = glob
+    end
 
-  #
-  # Returns the hash of available profiles
-  #
-  def profiles
-    @profiles ||= SimpleCov::Profiles.new
-  end
+    #
+    # Returns the glob that will be used to include files that were not
+    # explicitly required.
+    #
+    def tracked_files
+      @tracked_files if defined?(@tracked_files)
+    end
 
-  def adapters
-    warn "method adapters is deprecated. use profiles instead"
-    profiles
-  end
+    #
+    # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
+    #
+    def filters
+      @filters ||= []
+    end
 
-  #
-  # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
-  # you're calling.
-  #
-  # SimpleCov.configure do
-  #   add_filter 'foobar'
-  # end
-  #
-  # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
-  # options at once.
-  #
-  def configure(&block)
-    return false unless SimpleCov.usable?
-    Docile.dsl_eval(self, &block)
-  end
+    # The name of the command (a.k.a. Test Suite) currently running. Used for result
+    # merging and caching. It first tries to make a guess based upon the command line
+    # arguments the current test suite is running on and should automatically detect
+    # unit tests, functional tests, integration tests, rpsec and cucumber and label
+    # them properly. If it fails to recognize the current command, the command name
+    # is set to the shell command that the current suite is running on.
+    #
+    # You can specify it manually with SimpleCov.command_name("test:units") - please
+    # also check out the corresponding section in README.rdoc
+    def command_name(name = nil)
+      @name = name unless name.nil?
+      @name ||= SimpleCov::CommandGuesser.guess
+      @name
+    end
 
-  #
-  # Gets or sets the behavior to process coverage results.
-  #
-  # By default, it will call SimpleCov.result.format!
-  #
-  # Configure with:
-  #   SimpleCov.at_exit do
-  #     puts "Coverage done"
-  #     SimpleCov.result.format!
-  #   end
-  #
-  def at_exit(&block)
-    return Proc.new {} unless running or block_given?
-    @at_exit = block if block_given?
-    @at_exit ||= Proc.new { SimpleCov.result.format! }
-  end
+    #
+    # Gets or sets the configured formatter.
+    #
+    # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
+    #
+    def formatter(formatter = nil)
+      return @formatter if defined?(@formatter) && formatter.nil?
 
-  #
-  # Returns the project name - currently assuming the last dirname in
-  # the SimpleCov.root is this.
-  #
-  def project_name(new_name=nil)
-    return @project_name if defined? @project_name and @project_name and new_name.nil?
-    @project_name = new_name if new_name.kind_of?(String)
-    @project_name ||= File.basename(root.split('/').last).capitalize.gsub('_', ' ')
-  end
+      @formatter = formatter
+      raise "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
 
-  #
-  # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
-  # are joined and combined into a single coverage report
-  #
-  def use_merging(use=nil)
-    @use_merging = use unless use.nil?
-    @use_merging = true unless defined? @use_merging and @use_merging == false
-  end
+      @formatter
+    end
 
-  #
-  # Defines them maximum age (in seconds) of a resultset to still be included in merged results.
-  # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is
-  # more seconds ago than specified here, it won't be taken into account when merging (and is also
-  # purged from the resultset cache)
-  #
-  # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
-  #
-  # Default is 600 seconds (10 minutes)
-  #
-  # Configure with SimpleCov.merge_timeout(3600) # 1hr
-  #
-  def merge_timeout(seconds=nil)
-    @merge_timeout = seconds if seconds.kind_of?(Fixnum)
-    @merge_timeout ||= 600
-  end
+    #
+    # Sets the configured formatters.
+    #
+    def formatters=(formatters)
+      @formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
+    end
 
-  #
-  # Defines the minimum overall coverage required for the testsuite to pass.
-  # SimpleCov will return non-zero if the current coverage is below this threshold.
-  #
-  # Default is 0% (disabled)
-  #
-  def minimum_coverage(coverage=nil)
-    @minimum_coverage ||= (coverage || 0).to_f.round(2)
-  end
+    #
+    # Gets the configured formatters.
+    #
+    def formatters
+      if @formatter.is_a?(SimpleCov::Formatter::MultiFormatter)
+        @formatter.formatters
+      else
+        Array(formatter)
+      end
+    end
 
-  #
-  # Defines the maximum coverage drop at once allowed for the testsuite to pass.
-  # SimpleCov will return non-zero if the coverage decreases by more than this threshold.
-  #
-  # Default is 100% (disabled)
-  #
-  def maximum_coverage_drop(coverage_drop=nil)
-    @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
-  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
 
-  #
-  # 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
-  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
+    # can be configured to be any other string using this.
+    #
+    # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
+    #
+    def nocov_token(nocov_token = nil)
+      return @nocov_token if defined?(@nocov_token) && nocov_token.nil?
 
-  #
-  # Add a filter to the processing chain.
-  # There are three ways to define a filter:
-  #
-  # * as a String that will then be matched against all source files' file paths,
-  #   SimpleCov.add_filter 'app/models' # will reject all your models
-  # * as a block which will be passed the source file in question and should either
-  #   return a true or false value, depending on whether the file should be removed
-  #   SimpleCov.add_filter do |src_file|
-  #     File.basename(src_file.filename) == 'environment.rb'
-  #   end # Will exclude environment.rb files from the results
-  # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
-  #   on how to define your own filter classes
-  #
-  def add_filter(filter_argument=nil, &filter_proc)
-    filters << parse_filter(filter_argument, &filter_proc)
-  end
+      @nocov_token = (nocov_token || "nocov")
+    end
+    alias skip_token nocov_token
 
-  #
-  # Define a group for files. Works similar to add_filter, only that the first
-  # argument is the desired group name and files PASSING the filter end up in the group
-  # (while filters exclude when the filter is applicable).
-  #
-  def add_group(group_name, filter_argument=nil, &filter_proc)
-    groups[group_name] = parse_filter(filter_argument, &filter_proc)
-  end
+    #
+    # Returns the configured groups. Add groups using SimpleCov.add_group
+    #
+    def groups
+      @groups ||= {}
+    end
+
+    #
+    # Returns the hash of available profiles
+    #
+    def profiles
+      @profiles ||= SimpleCov::Profiles.new
+    end
+
+    def adapters
+      warn "#{Kernel.caller.first}: [DEPRECATION] #adapters is deprecated. Use #profiles instead."
+      profiles
+    end
+
+    #
+    # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
+    # you're calling.
+    #
+    #     SimpleCov.configure do
+    #       add_filter 'foobar'
+    #     end
+    #
+    # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
+    # options at once.
+    #
+    def configure(&block)
+      Docile.dsl_eval(self, &block)
+    end
+
+    #
+    # Gets or sets the behavior to process coverage results.
+    #
+    # By default, it will call SimpleCov.result.format!
+    #
+    # Configure with:
+    #
+    #     SimpleCov.at_exit do
+    #       puts "Coverage done"
+    #       SimpleCov.result.format!
+    #     end
+    #
+    def at_exit(&block)
+      return proc {} unless running || block_given?
+
+      @at_exit = block if block_given?
+      @at_exit ||= proc { SimpleCov.result.format! }
+    end
+
+    #
+    # Returns the project name - currently assuming the last dirname in
+    # the SimpleCov.root is this.
+    #
+    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
+
+    #
+    # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
+    # are joined and combined into a single coverage report
+    #
+    def use_merging(use = nil)
+      @use_merging = use unless use.nil?
+      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+    end
+
+    #
+    # Defines the maximum age (in seconds) of a resultset to still be included in merged results.
+    # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is
+    # more seconds ago than specified here, it won't be taken into account when merging (and is also
+    # purged from the resultset cache)
+    #
+    # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
+    #
+    # Default is 600 seconds (10 minutes)
+    #
+    # Configure with SimpleCov.merge_timeout(3600) # 1hr
+    #
+    def merge_timeout(seconds = nil)
+      @merge_timeout = seconds if seconds.is_a?(Integer)
+      @merge_timeout ||= 600
+    end
+
+    #
+    # Defines the minimum overall coverage required for the testsuite to pass.
+    # SimpleCov will return non-zero if the current coverage is below this threshold.
+    #
+    # 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
+
+    #
+    # Defines the maximum coverage drop at once allowed for the testsuite to pass.
+    # SimpleCov will return non-zero if the coverage decreases by more than this threshold.
+    #
+    # Default is 100% (disabled)
+    #
+    def maximum_coverage_drop(coverage_drop = nil)
+      @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
+    end
+
+    #
+    # Defines the minimum coverage per file required for the testsuite to pass.
+    # SimpleCov will return non-zero if the current coverage of the least covered file
+    # is below this threshold.
+    #
+    # 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
+
+    #
+    # 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
+    end
+
+    #
+    # Add a filter to the processing chain.
+    # There are four ways to define a filter:
+    #
+    # * as a String that will then be matched against all source files' file paths,
+    #     SimpleCov.add_filter 'app/models' # will reject all your models
+    # * as a block which will be passed the source file in question and should either
+    #   return a true or false value, depending on whether the file should be removed
+    #     SimpleCov.add_filter do |src_file|
+    #       File.basename(src_file.filename) == 'environment.rb'
+    #     end # Will exclude environment.rb files from the results
+    # * as an array of strings that are matched against all sorce files' file
+    #   paths and then ignored (basically string filter multiple times)
+    #     SimpleCov.add_filter ['app/models', 'app/helpers'] # ignores both dirs
+    # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
+    #   on how to define your own filter classes
+    #
+    def add_filter(filter_argument = nil, &filter_proc)
+      filters << parse_filter(filter_argument, &filter_proc)
+    end
+
+    #
+    # Define a group for files. Works similar to add_filter, only that the first
+    # argument is the desired group name and files PASSING the filter end up in the group
+    # (while filters exclude when the filter is applicable).
+    #
+    def add_group(group_name, filter_argument = nil, &filter_proc)
+      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
 
-  #
-  # The actal filter processor. Not meant for direct use
-  #
-  def parse_filter(filter_argument=nil, &filter_proc)
-    if filter_argument.kind_of?(SimpleCov::Filter)
-      filter_argument
-    elsif filter_argument.kind_of?(String)
-      SimpleCov::StringFilter.new(filter_argument)
-    elsif filter_proc
-      SimpleCov::BlockFilter.new(filter_proc)
-    else
-      raise ArgumentError, "Please specify either a string or a block to filter with"
+    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
+    #
+    def parse_filter(filter_argument = nil, &filter_proc)
+      filter = filter_argument || filter_proc
+
+      if filter
+        SimpleCov::Filter.build_filter(filter)
+      else
+        raise ArgumentError, "Please specify either a filter or a block to filter with"
+      end
     end
   end
 end