simplecov 0.17.1 → 0.22.0

data/lib/simplecov/defaults.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 # Load default formatter gem
-require "simplecov-html"
 require "pathname"
-require "simplecov/profiles/root_filter"
-require "simplecov/profiles/test_frameworks"
-require "simplecov/profiles/bundler_filter"
-require "simplecov/profiles/hidden_filter"
-require "simplecov/profiles/rails"
+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
@@ -22,15 +25,13 @@ end
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
+  next if SimpleCov.external_at_exit?
 
-  SimpleCov.set_exit_exception
-  SimpleCov.run_exit_tasks!
+  SimpleCov.at_exit_behavior
 end
 
 # Autoload config from ~/.simplecov if present
-require "simplecov/load_global_config"
+require_relative "load_global_config"
 
 # Autoload config from .simplecov if present
 # Recurse upwards until we find .simplecov or reach the root directory
@@ -42,7 +43,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

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

@@ -8,3 +8,8 @@ module SimpleCov
     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,30 +1,57 @@
 # frozen_string_literal: true
 
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
 module SimpleCov
-  class FileList < Array
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList
+    include Enumerable
+    extend Forwardable
+
+    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
+
+    def initialize(files)
+      @files = files
+    end
+
+    def coverage_statistics
+      @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
-      return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(:+)
+      coverage_statistics[:line]&.covered
     end
 
     # Returns the count of lines that have been missed
     def missed_lines
-      return 0.0 if empty?
-      map { |f| f.missed_lines.count }.inject(:+)
+      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
 
@@ -36,26 +63,58 @@ module SimpleCov
 
     # Finds the least covered file and returns that file's name
     def least_covered_file
-      sort_by(&:covered_percent).first.filename
+      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
-      covered_lines + missed_lines
+      coverage_statistics[:line]&.total
     end
 
     # Computes the coverage based upon lines covered and lines missed
     # @return [Float]
     def covered_percent
-      return 100.0 if empty? || lines_of_code.zero?
-      Float(covered_lines * 100.0 / lines_of_code)
+      coverage_statistics[:line]&.percent
     end
 
     # Computes the strength (hits / line) based upon lines covered and lines missed
     # @return [Float]
     def covered_strength
-      return 0.0 if empty? || lines_of_code.zero?
-      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
+      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
+
+    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

@@ -14,11 +14,12 @@ module SimpleCov
   #
   class Filter
     attr_reader :filter_argument
+
     def initialize(filter_argument)
       @filter_argument = filter_argument
     end
 
-    def matches?(_)
+    def matches?(_source_file)
       raise "The base filter class is not intended for direct use"
     end
 
@@ -29,17 +30,19 @@ module SimpleCov
 
     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)
-      if filter_argument.is_a?(String)
+      case filter_argument
+      when String
         SimpleCov::StringFilter
-      elsif filter_argument.is_a?(Regexp)
+      when Regexp
         SimpleCov::RegexFilter
-      elsif filter_argument.is_a?(Array)
+      when Array
         SimpleCov::ArrayFilter
-      elsif filter_argument.is_a?(Proc)
+      when Proc
         SimpleCov::BlockFilter
       else
         raise ArgumentError, "You have provided an unrecognized filter type"
@@ -49,7 +52,7 @@ module SimpleCov
 
   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

data/lib/simplecov/formatter/multi_formatter.rb

@@ -6,12 +6,10 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            begin
-              formatter.new.format(result)
-            rescue => e
-              STDERR.puts("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
-              nil
-            end
+            formatter.new.format(result)
+          rescue StandardError => e
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            nil
           end
         end
       end
@@ -27,7 +25,7 @@ module SimpleCov
 
       def self.[](*args)
         warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
-        new(Array([*args]))
+        new(Array(args))
       end
     end
   end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-#
-# A ridiculously simple formatter for SimpleCov results.
-#
 module SimpleCov
   module Formatter
+    #
+    # A ridiculously simple formatter for SimpleCov results.
+    #
     class SimpleFormatter
       # Takes a SimpleCov::Result and generates a string out of it
       def format(result)
-        output = "".dup
+        output = +""
         result.groups.each do |name, files|
           output << "Group: #{name}\n"
           output << "=" * 40

data/lib/simplecov/formatter.rb

@@ -6,5 +6,5 @@ module SimpleCov
   end
 end
 
-require "simplecov/formatter/simple_formatter"
-require "simplecov/formatter/multi_formatter"
+require_relative "formatter/simple_formatter"
+require_relative "formatter/multi_formatter"

data/lib/simplecov/last_run.rb

@@ -11,9 +11,11 @@ module SimpleCov
 
       def read
         return nil unless File.exist?(last_run_path)
+
         json = File.read(last_run_path)
         return nil if json.strip.empty?
-        JSON.parse(json)
+
+        JSON.parse(json, symbolize_names: true)
       end
 
       def write(json)

data/lib/simplecov/lines_classifier.rb

@@ -8,23 +8,23 @@ module SimpleCov
     RELEVANT = 0
     NOT_RELEVANT = nil
 
-    WHITESPACE_LINE = /^\s*$/
-    COMMENT_LINE = /^\s*#/
+    WHITESPACE_LINE = /^\s*$/.freeze
+    COMMENT_LINE = /^\s*#/.freeze
     WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
 
     def self.no_cov_line
-      /^(\s*)#(\s*)(\:#{SimpleCov.nocov_token}\:)/o
+      /^(\s*)#(\s*)(:#{SimpleCov.nocov_token}:)/o
     end
 
     def self.no_cov_line?(line)
-      line =~ no_cov_line
+      no_cov_line.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false
     end
 
     def self.whitespace_line?(line)
-      line =~ WHITESPACE_OR_COMMENT_LINE
+      WHITESPACE_OR_COMMENT_LINE.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false

data/lib/simplecov/no_defaults.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
-require "simplecov"
+require_relative "../simplecov"

data/lib/simplecov/process.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Process
+  class << self
+    def fork_with_simplecov(&block)
+      if defined?(SimpleCov) && SimpleCov.running
+        fork_without_simplecov do
+          SimpleCov.at_fork.call(Process.pid)
+          block.call if block_given?
+        end
+      else
+        fork_without_simplecov(&block)
+      end
+    end
+
+    alias fork_without_simplecov fork
+    alias fork fork_with_simplecov
+  end
+end

data/lib/simplecov/profiles.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-#
-# Profiles are SimpleCov configuration procs that can be easily
-# loaded using SimpleCov.start :rails and defined using
-#   SimpleCov.profiles.define :foo do
-#     # SimpleCov configuration here, same as in  SimpleCov.configure
-#   end
-#
 module SimpleCov
+  #
+  # Profiles are SimpleCov configuration procs that can be easily
+  # loaded using SimpleCov.start :rails and defined using
+  #   SimpleCov.profiles.define :foo do
+  #     # SimpleCov configuration here, same as in  SimpleCov.configure
+  #   end
+  #
   class Profiles < Hash
     #
     # Define a SimpleCov profile:
@@ -18,6 +18,7 @@ module SimpleCov
     def define(name, &blk)
       name = name.to_sym
       raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+
       self[name] = blk
     end
 
@@ -27,6 +28,7 @@ module SimpleCov
     def load(name)
       name = name.to_sym
       raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+
       SimpleCov.configure(&self[name])
     end
   end

data/lib/simplecov/result.rb

@@ -5,7 +5,7 @@ require "forwardable"
 
 module SimpleCov
   #
-  # A simplecov code coverage result, initialized from the Hash Ruby 1.9's built-in coverage
+  # A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
   # library generates (Coverage.result).
   #
   class Result
@@ -20,15 +20,18 @@ 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
+    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)
-      @original_result = original_result.freeze
-      @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)
+    def initialize(original_result, command_name: nil, created_at: nil)
+      result = original_result
+      @original_result = result.freeze
+      @command_name = command_name
+      @created_at = created_at
+      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
+        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
       end.compact.sort_by(&:filename))
       filter!
     end
@@ -61,16 +64,19 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
+      {
+        command_name => {
+          "coverage" => coverage,
+          "timestamp" => created_at.to_i
+        }
+      }
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
-      command_name, data = hash.first
-      result = SimpleCov::Result.new(data["coverage"])
-      result.command_name = command_name
-      result.created_at = Time.at(data["timestamp"])
-      result
+      hash.map do |command_name, data|
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+      end
     end
 
   private