simplecov 0.6.0 → 0.22.0

data/lib/simplecov/coverage_statistics.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Holds the individual data of a coverage result.
+  #
+  # This is uniform across coverage criteria as they all have:
+  #
+  # * total - how many things to cover there are (total relevant loc/branches)
+  # * covered - how many of the coverables are hit
+  # * missed - how many of the coverables are missed
+  # * percent - percentage as covered/missed
+  # * strength - average hits per/coverable (will not exist for one shot lines format)
+  class CoverageStatistics
+    attr_reader :total, :covered, :missed, :strength, :percent
+
+    def self.from(coverage_statistics)
+      sum_covered, sum_missed, sum_total_strength =
+        coverage_statistics.reduce([0, 0, 0.0]) do |(covered, missed, total_strength), file_coverage_statistics|
+          [
+            covered + file_coverage_statistics.covered,
+            missed + file_coverage_statistics.missed,
+            # 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)
+          ]
+        end
+
+      new(covered: sum_covered, missed: sum_missed, total_strength: sum_total_strength)
+    end
+
+    # Requires only covered, missed and strength to be initialized.
+    #
+    # Other values are computed by this class.
+    def initialize(covered:, missed:, total_strength: 0.0)
+      @covered  = covered
+      @missed   = missed
+      @total    = covered + missed
+      @percent  = compute_percent(covered, missed, total)
+      @strength = compute_strength(total_strength, total)
+    end
+
+  private
+
+    def compute_percent(covered, missed, total)
+      return 100.0 if missed.zero?
+
+      covered * 100.0 / total
+    end
+
+    def compute_strength(total_strength, total)
+      return 0.0 if total.zero?
+
+      total_strength.to_f / total
+    end
+  end
+end

data/lib/simplecov/default_formatter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "simplecov-html"
+module SimpleCov
+  module Formatter
+    class << self
+      def from_env(env)
+        formatters = [SimpleCov::Formatter::HTMLFormatter]
+
+        # When running under a CI that uses CodeClimate, JSON output is expected
+        if env.fetch("CC_TEST_REPORTER_ID", nil)
+          require "simplecov_json_formatter"
+          formatters.push(SimpleCov::Formatter::JSONFormatter)
+        end
+
+        formatters
+      end
+    end
+  end
+end

data/lib/simplecov/defaults.rb

@@ -1,57 +1,53 @@
-# Load default formatter gem
-require 'simplecov-html'
-
-SimpleCov.adapters.define 'root_filter' do
-  # Exclude all files outside of simplecov root
-  add_filter do |src|
-    !(src.filename =~ /^#{SimpleCov.root}/)
-  end
-end
-
-SimpleCov.adapters.define 'test_frameworks' do
-  add_filter '/test/'
-  add_filter '/features/'
-  add_filter '/spec/'
-  add_filter '/autotest/'
-end
-
-SimpleCov.adapters.define 'rails' do
-  load_adapter 'test_frameworks'
-
-  add_filter '/config/'
-  add_filter '/db/'
-  add_filter '/vendor/bundle/'
+# frozen_string_literal: true
 
-  add_group 'Controllers', 'app/controllers'
-  add_group 'Models', 'app/models'
-  add_group 'Mailers', 'app/mailers'
-  add_group 'Helpers', 'app/helpers'
-  add_group 'Libraries', 'lib'
-  add_group 'Plugins', 'vendor/plugins'
-end
+# Load default formatter gem
+require "pathname"
+require_relative "default_formatter"
+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
-  formatter SimpleCov::Formatter::HTMLFormatter
+  formatter SimpleCov::Formatter::MultiFormatter.new(
+    SimpleCov::Formatter.from_env(ENV)
+  )
+
+  load_profile "bundler_filter"
+  load_profile "hidden_filter"
   # Exclude files outside of SimpleCov.root
-  load_adapter 'root_filter'
+  load_profile "root_filter"
 end
 
 # Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
-SimpleCov::CommandGuesser.original_run_command = "#{$0} #{ARGV.join(" ")}"
+SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # Store the exit status of the test run since it goes away after calling the at_exit proc...
-  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)
-    @exit_status = $!.is_a?(SystemExit) ? $!.status : 1
-  end
-  SimpleCov.at_exit.call
-  exit @exit_status if @exit_status # Force exit with stored status (see github issue #5)
+  next if SimpleCov.external_at_exit?
+
+  SimpleCov.at_exit_behavior
 end
 
+# Autoload config from ~/.simplecov if present
+require_relative "load_global_config"
+
 # Autoload config from .simplecov if present
-config_path = File.join(SimpleCov.root, '.simplecov')
-load config_path if File.exist?(config_path)
+# Recurse upwards until we find .simplecov or reach the root directory
+
+config_path = Pathname.new(SimpleCov.root)
+loop do
+  filename = config_path.join(".simplecov")
+  if filename.exist?
+    begin
+      load filename
+    rescue LoadError, StandardError
+      warn "Warning: Error occurred while trying to load #{filename}. " \
+        "Error message: #{$!.message}"
+    end
+    break
+  end
+  config_path, = config_path.split
+  break if config_path.root?
+end

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,83 @@
+# 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_drop_violations.any?
+      end
+
+      def report
+        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
+        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_drop_violations
+        @coverage_drop_violations ||=
+          compute_coverage_drop_data.select do |achieved|
+            achieved.fetch(:max_drop) < achieved.fetch(:drop_percent)
+          end
+      end
+
+      def compute_coverage_drop_data
+        maximum_coverage_drop.map do |criterion, percent|
+          {
+            criterion: criterion,
+            max_drop: percent,
+            drop_percent: drop_percent(criterion)
+          }
+        end
+      end
+
+      # if anyone says "max_coverage_drop 0.000000000000000001" I appologize. Please don't.
+      MAX_DROP_ACCURACY = 10
+      def drop_percent(criterion)
+        drop = last_coverage(criterion) -
+               SimpleCov.round_coverage(
+                 result.coverage_statistics.fetch(criterion).percent
+               )
+
+        # floats, I tell ya.
+        # irb(main):001:0* 80.01 - 80.0
+        # => 0.010000000000005116
+        drop.floor(MAX_DROP_ACCURACY)
+      end
+
+      def last_coverage(criterion)
+        last_coverage_percent = last_run[:result][criterion]
+
+        # fallback for old file format
+        last_coverage_percent = last_run[:result][:covered_percent] if !last_coverage_percent && criterion == :line
+
+        last_coverage_percent || 0
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -0,0 +1,54 @@
+# 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?
+        minimum_violations.any?
+      end
+
+      def report
+        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
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      attr_reader :result, :minimum_coverage_by_file
+
+      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
+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/exit_codes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    SUCCESS = 0
+    EXCEPTION = 1
+    MINIMUM_COVERAGE = 2
+    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/file_list.rb

@@ -1,44 +1,120 @@
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
-class SimpleCov::FileList < Array
-  # Returns the count of lines that have coverage
-  def covered_lines
-    return 0.0 if empty?
-    map {|f| f.covered_lines.count }.inject(&:+)
-  end
+# frozen_string_literal: true
 
-  # Returns the count of lines that have been missed
-  def missed_lines
-    return 0.0 if empty?
-    map {|f| f.missed_lines.count }.inject(&:+)
-  end
+module SimpleCov
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList
+    include Enumerable
+    extend Forwardable
 
-  # Returns the count of lines that are not relevant for coverage
-  def never_lines
-    return 0.0 if empty?
-    map {|f| f.never_lines.count }.inject(&:+)
-  end
+    def_delegators :@files,
+                   # For Enumerable
+                   :each,
+                   # also delegating methods implemented in Enumerable as they have
+                   # custom Array implementations which are presumably better/more
+                   # resource efficient
+                   :size, :map, :count,
+                   # surprisingly not in Enumerable
+                   :empty?, :length,
+                   # still act like we're kinda an array
+                   :to_a, :to_ary
 
-  # Returns the count of skipped lines
-  def skipped_lines
-    return 0.0 if empty?
-    map {|f| f.skipped_lines.count }.inject(&:+)
-  end
+    def initialize(files)
+      @files = files
+    end
 
-  # Returns the overall amount of relevant lines of code across all files in this list
-  def lines_of_code
-    covered_lines + missed_lines
-  end
+    def coverage_statistics
+      @coverage_statistics ||= compute_coverage_statistics
+    end
 
-  # Computes the coverage based upon lines covered and lines missed
-  def covered_percent
-    return 100.0 if empty? or lines_of_code == 0
-    covered_lines * 100.0 / lines_of_code
-  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
+    end
+
+    # Returns the count of lines that have been missed
+    def missed_lines
+      coverage_statistics[:line]&.missed
+    end
+
+    # Returns the count of lines that are not relevant for coverage
+    def never_lines
+      return 0.0 if empty?
+
+      map { |f| f.never_lines.count }.inject(:+)
+    end
+
+    # Returns the count of skipped lines
+    def skipped_lines
+      return 0.0 if empty?
+
+      map { |f| f.skipped_lines.count }.inject(:+)
+    end
+
+    # Computes the coverage based upon lines covered and lines missed for each file
+    # Returns an array with all coverage percentages
+    def covered_percentages
+      map(&:covered_percent)
+    end
+
+    # Finds the least covered file and returns that file's name
+    def least_covered_file
+      min_by(&:covered_percent).filename
+    end
+
+    # Returns the overall amount of relevant lines of code across all files in this list
+    def lines_of_code
+      coverage_statistics[:line]&.total
+    end
+
+    # Computes the coverage based upon lines covered and lines missed
+    # @return [Float]
+    def covered_percent
+      coverage_statistics[:line]&.percent
+    end
+
+    # Computes the strength (hits / line) based upon lines covered and lines missed
+    # @return [Float]
+    def covered_strength
+      coverage_statistics[:line]&.strength
+    end
+
+    # Return total count of branches in all files
+    def total_branches
+      coverage_statistics[:branch]&.total
+    end
+
+    # Return total count of covered branches
+    def covered_branches
+      coverage_statistics[:branch]&.covered
+    end
+
+    # Return total count of covered branches
+    def missed_branches
+      coverage_statistics[:branch]&.missed
+    end
+
+    def branch_covered_percent
+      coverage_statistics[:branch]&.percent
+    end
+
+  private
+
+    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
 
-  # Computes the strength (hits / line) based upon lines covered and lines missed
-  def covered_strength
-    return 0 if empty? or lines_of_code == 0
-    map {|f| f.covered_strength }.inject(&:+) / size
+    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
 end

data/lib/simplecov/filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   #
   # Base filter class. Inherit from this to create custom filters,
@@ -12,25 +14,55 @@ module SimpleCov
   #
   class Filter
     attr_reader :filter_argument
+
     def initialize(filter_argument)
       @filter_argument = filter_argument
     end
 
-    def matches?(source_file)
+    def matches?(_source_file)
       raise "The base filter class is not intended for direct use"
     end
 
     def passes?(source_file)
-      warn "DEPRECATION: SimpleCov::Filter#passes?(x) has been renamed to #matches?. Please update your custom filters accordingly!"
+      warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
       matches?(source_file)
     end
+
+    def self.build_filter(filter_argument)
+      return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
+
+      class_for_argument(filter_argument).new(filter_argument)
+    end
+
+    def self.class_for_argument(filter_argument)
+      case filter_argument
+      when String
+        SimpleCov::StringFilter
+      when Regexp
+        SimpleCov::RegexFilter
+      when Array
+        SimpleCov::ArrayFilter
+      when Proc
+        SimpleCov::BlockFilter
+      else
+        raise ArgumentError, "You have provided an unrecognized filter type"
+      end
+    end
   end
 
   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
+  end
+
+  class RegexFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
     def matches?(source_file)
-      (source_file.filename =~ /#{filter_argument}/)
+      (source_file.project_filename =~ filter_argument)
     end
   end
 
@@ -41,4 +73,22 @@ module SimpleCov
       filter_argument.call(source_file)
     end
   end
+
+  class ArrayFilter < SimpleCov::Filter
+    def initialize(filter_argument)
+      filter_objects = filter_argument.map do |arg|
+        Filter.build_filter(arg)
+      end
+
+      super(filter_objects)
+    end
+
+    # Returns true if any of the filters in the array match the given source file.
+    # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
+    def matches?(source_files_list)
+      filter_argument.any? do |arg|
+        arg.matches?(source_files_list)
+      end
+    end
+  end
 end

data/lib/simplecov/formatter/multi_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Formatter
+    class MultiFormatter
+      module InstanceMethods
+        def format(result)
+          formatters.map do |formatter|
+            formatter.new.format(result)
+          rescue StandardError => e
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            nil
+          end
+        end
+      end
+
+      def self.new(formatters = nil)
+        Class.new do
+          define_method :formatters do
+            @formatters ||= Array(formatters)
+          end
+          include InstanceMethods
+        end
+      end
+
+      def self.[](*args)
+        warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
+        new(Array(args))
+      end
+    end
+  end
+end