simplecov 0.8.0.pre2 → 0.18.0.beta1

data/doc/alternate-formatters.md

@@ -0,0 +1,61 @@
+## Alternate coverage report formatters
+
+The community around simplecov provides a whole bunch of alternate formatters beyond the official
+[simplecov-html](https://github.com/colszowka/simplecov-html) gem.
+
+If you have built or found one that is missing here, please send a Pull Request for this document!
+
+#### [simplecov-badge](https://github.com/matthew342/simplecov-badge)
+*by Matt Hale*
+
+A formatter that generates a coverage badge for use in your project's readme using ImageMagick.
+
+#### [simplecov-small-badge](https://github.com/marcgrimme/simplecov-small-badge)
+*by Marc Grimme*
+
+A formatter that generates a small coverage badge for use in your project's readme using the SVG.
+
+#### [simplecov-cobertura](https://github.com/dashingrocket/simplecov-cobertura)
+*by Jesse Bowes*
+
+A formatter that generates Cobertura XML.
+
+#### [simplecov-csv](https://github.com/fguillen/simplecov-csv)
+*by Fernando Guillen*
+
+CSV formatter for SimpleCov
+
+#### [simplecov-erb](https://github.com/kpaulisse/simplecov-erb)
+*by [Kevin Paulisse](https://github.com/kpaulisse)*
+
+Flexible formatter that generates the output from an ERB template.
+
+#### [simplecov-json](https://github.com/vicentllongo/simplecov-json)
+*by Vicent Llongo*
+
+JSON formatter for SimpleCov
+
+#### [simplecov-lcov](https://github.com/fortissimo1997/simplecov-lcov)
+*by fortissimo1997*
+
+lcov formatter for SimpleCov
+
+#### [simplecov-rcov](https://github.com/fguillen/simplecov-rcov)
+*by Fernando Guillen*
+
+"The target of this formatter is to cheat on Hudson so I can use the Ruby metrics plugin with SimpleCov."
+
+#### [simplecov-single_file_reporter](https://github.com/grosser/simplecov-single_file_reporter)
+*by [Michael Grosser](http://grosser.it)*
+
+A formatter that prints the coverage of the file under test when you run a single test file.
+
+#### [simplecov-t_wada](https://github.com/ysksn/simplecov-t_wada)
+*by [Yosuke Kabuto](https://github.com/ysksn)*
+
+t_wada AA formatter for SimpleCov
+
+#### [simplecov-material(https://github.com/chiefpansancolt/simplecov-material)
+*by [Chiefpansancolt](https://github.com/chiefpansancolt)*
+
+A Material Designed HTML formatter with clean and easy search of files with a tabular left Navigation.

data/doc/commercial-services.md

@@ -0,0 +1,20 @@
+## Commercial Services with SimpleCov integration
+
+There is a bunch of services that offer integration with your existing CI pipeline and SimpleCov coverage
+reports. Please note these are not associated with the SimpleCov project itself, so please report problems with
+these integrations with their respective owners.
+
+#### [codeclimate](https://github.com/codeclimate/ruby-test-reporter)
+*by [Code Climate](https://codeclimate.com/)*
+
+Upload coverage reports to [codeclimate.com](https://codeclimate.com/), a hosted software quality analysis and that also includes coverage reporting.
+
+#### [codecov](https://github.com/codecov/codecov-ruby)
+*by [Codecov](https://codecov.io/)*
+
+Upload coverage reports to [codecov.io](https://codecov.io/), a hosted coverage reporting solution.
+
+#### [coveralls](https://github.com/lemurheavy/coveralls-ruby)
+*by [Coveralls](https://coveralls.io/)*
+
+Upload coverage reports to [coveralls.io](https://coveralls.io/), a hosted coverage reporting solution.

data/doc/editor-integration.md

@@ -0,0 +1,18 @@
+## Editor integration
+
+Some editors have a graphical integration for the simplecov gem.
+
+#### [Atom Editor: coverage](https://atom.io/packages/coverage)
+*by Philip Giuliani*
+
+Adds an overview of your current test coverage to Atom.
+
+#### [Sublime Editor: Simple​Cov](https://packagecontrol.io/packages/SimpleCov)
+*by sentience*
+
+Adds in editor live coverage highlighting, status bar coverage information, and summary coverage information.
+
+#### [cadre](https://github.com/nyarly/cadre)
+*by Judson Lester*
+
+Includes a formatter for Simplecov that emits a Vim script to mark up code files with coverage information.

data/lib/simplecov.rb

@@ -1,11 +1,31 @@
+# frozen_string_literal: true
+
+require "English"
+
+# Coverage may be inaccurate under JRUBY.
+if defined?(JRUBY_VERSION) && defined?(JRuby)
+
+  # @see https://github.com/jruby/jruby/issues/1196
+  # @see https://github.com/metricfu/metric_fu/pull/226
+  # @see https://github.com/colszowka/simplecov/issues/420
+  # @see https://github.com/colszowka/simplecov/issues/86
+  # @see https://jira.codehaus.org/browse/JRUBY-6106
+
+  unless org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
+    warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
+      ' or do JRUBY_OPTS="--debug"' \
+      ' or set the "debug.fullTrace=true" option in your .jrubyrc'
+  end
+end
+
 #
-# Code coverage for ruby 1.9. Please check out README for a full introduction.
+# Code coverage for ruby. Please check out README for a full introduction.
 #
-require 'lockfile'
-
 module SimpleCov
   class << self
     attr_accessor :running
+    attr_accessor :pid
+    attr_reader :exit_exception
 
     #
     # Sets up SimpleCov to run against your project.
@@ -24,18 +44,15 @@ module SimpleCov
     #
     # Please check out the RDoc for SimpleCov::Configuration to find about available config options
     #
-    def start(profile=nil, &block)
-      if SimpleCov.usable?
-        load_profile(profile) if profile
-        configure(&block) if block_given?
-        @result = nil
-        self.running = true
-        Coverage.start
-      else
-        warn "WARNING: SimpleCov is activated, but you're not running Ruby 1.9+ - no coverage analysis will happen"
-        warn "Starting with SimpleCov 1.0.0, even no-op compatibility with Ruby <= 1.8 will be entirely dropped."
-        false
-      end
+    def start(profile = nil, &block)
+      require "coverage"
+      load_profile(profile) if profile
+      configure(&block) if block_given?
+      @result = nil
+      self.running = true
+      self.pid = Process.pid
+
+      start_coverage_measurment
     end
 
     #
@@ -43,19 +60,21 @@ module SimpleCov
     # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
     #
     def result
-      @result ||= SimpleCov::Result.new(Coverage.result) if running
+      return @result if result?
+
+      # Collect our coverage result
+
+      process_coverage_result if running
+
       # If we're using merging of results, store the current result
-      # first, then merge the results and return those
+      # first (if there is one), then merge the results and return those
       if use_merging
-        lockfile = ::Lockfile.new ResultMerger.resultset_path + '.lockfile'
-
-        lockfile.lock do
-          SimpleCov::ResultMerger.store_result(@result) if @result
-          return SimpleCov::ResultMerger.merged_result
-        end
-      else
-        return @result if defined? @result
+        wait_for_other_processes
+        SimpleCov::ResultMerger.store_result(@result) if result?
+        @result = SimpleCov::ResultMerger.merged_result
       end
+
+      @result
     ensure
       self.running = false
     end
@@ -65,7 +84,7 @@ module SimpleCov
     # Otherwise, returns the result
     #
     def result?
-      defined? @result and @result
+      defined?(@result) && @result
     end
 
     #
@@ -74,7 +93,7 @@ module SimpleCov
     def filtered(files)
       result = files.clone
       filters.each do |filter|
-        result = result.reject {|source_file| filter.matches?(source_file) }
+        result = result.reject { |source_file| filter.matches?(source_file) }
       end
       SimpleCov::FileList.new result
     end
@@ -86,10 +105,10 @@ module SimpleCov
       grouped = {}
       grouped_files = []
       groups.each do |name, filter|
-        grouped[name] = SimpleCov::FileList.new(files.select {|source_file| filter.matches?(source_file)})
+        grouped[name] = SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
         grouped_files += grouped[name]
       end
-      if groups.length > 0 and (other_files = files.reject {|source_file| grouped_files.include?(source_file)}).length > 0
+      if !groups.empty? && !(other_files = files.reject { |source_file| grouped_files.include?(source_file) }).empty?
         grouped["Ungrouped"] = SimpleCov::FileList.new(other_files)
       end
       grouped
@@ -103,47 +122,263 @@ module SimpleCov
     end
 
     def load_adapter(name)
-      warn "method load_adapter is deprecated. use load_profile instead"
+      warn "#{Kernel.caller.first}: [DEPRECATION] #load_adapter is deprecated. Use #load_profile instead."
       load_profile(name)
     end
 
     #
-    # Checks whether we're on a proper version of Ruby (likely 1.9+) which
-    # provides coverage support
+    # Clear out the previously cached .result. Primarily useful in testing
     #
-    def usable?
-      return @usable if defined? @usable and !@usable.nil?
+    def clear_result
+      @result = nil
+    end
+
+    #
+    # Capture the current exception if it exists
+    # This will get called inside the at_exit block
+    #
+    def set_exit_exception
+      @exit_exception = $ERROR_INFO
+    end
 
-      @usable = begin
-        require 'coverage'
-        require 'simplecov/jruby16_fix'
-        true
-      rescue LoadError
-        false
+    #
+    # Returns the exit status from the exit exception
+    #
+    def exit_status_from_exception
+      return SimpleCov::ExitCodes::SUCCESS unless exit_exception
+
+      if exit_exception.is_a?(SystemExit)
+        exit_exception.status
+      else
+        SimpleCov::ExitCodes::EXCEPTION
+      end
+    end
+
+    # @api private
+    #
+    # Called from at_exit block
+    #
+    def run_exit_tasks!
+      exit_status = SimpleCov.exit_status_from_exception
+
+      SimpleCov.at_exit.call
+
+      # Don't modify the exit status unless the result has already been
+      # computed
+      exit_status = SimpleCov.process_result(SimpleCov.result, exit_status) if SimpleCov.result?
+
+      # Force exit with stored status (see github issue #5)
+      # unless it's nil or 0 (see github issue #281)
+      if exit_status&.positive?
+        $stderr.printf("SimpleCov failed with exit %<exit_status>d\n", :exit_status => exit_status) if print_error_status
+        Kernel.exit exit_status
+      end
+    end
+
+    # @api private
+    #
+    # Usage:
+    #   exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
+    #
+    def process_result(result, exit_status)
+      return exit_status if exit_status != SimpleCov::ExitCodes::SUCCESS # Existing errors
+
+      covered_percent = result.covered_percent.floor(2)
+      result_exit_status = result_exit_status(result, covered_percent)
+      write_last_run(covered_percent) if result_exit_status == SimpleCov::ExitCodes::SUCCESS # No result errors
+      final_result_process? ? result_exit_status : SimpleCov::ExitCodes::SUCCESS
+    end
+
+    # @api private
+    #
+    # rubocop:disable Metrics/MethodLength
+    def result_exit_status(result, covered_percent)
+      covered_percentages = result.covered_percentages.map { |percentage| percentage.floor(2) }
+      if covered_percent < SimpleCov.minimum_coverage
+        $stderr.printf(
+          "Coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+          :covered => covered_percent,
+          :minimum_coverage => SimpleCov.minimum_coverage
+        )
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file }
+        $stderr.printf(
+          "File (%<file>s) is only (%<least_covered_percentage>.2f%%) covered. This is below the expected minimum coverage per file of (%<min_coverage>.2f%%).\n",
+          :file => result.least_covered_file,
+          :least_covered_percentage => covered_percentages.min,
+          :min_coverage => SimpleCov.minimum_coverage_by_file
+        )
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      elsif (last_run = SimpleCov::LastRun.read)
+        coverage_diff = last_run["result"]["covered_percent"] - covered_percent
+        if coverage_diff > SimpleCov.maximum_coverage_drop
+          $stderr.printf(
+            "Coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
+            :drop_percent => coverage_diff,
+            :max_drop => SimpleCov.maximum_coverage_drop
+          )
+          SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
+        else
+          SimpleCov::ExitCodes::SUCCESS
+        end
+      else
+        SimpleCov::ExitCodes::SUCCESS
       end
     end
+    # rubocop:enable Metrics/MethodLength
+
+    #
+    # @api private
+    #
+    def final_result_process?
+      # checking for ENV["TEST_ENV_NUMBER"] to determine if the tess are being run in parallel
+      !defined?(ParallelTests) || !ENV["TEST_ENV_NUMBER"] || ParallelTests.number_of_running_processes <= 1
+    end
+
+    #
+    # @api private
+    #
+    def wait_for_other_processes
+      return unless defined?(ParallelTests) && final_result_process?
+
+      ParallelTests.wait_for_other_processes_to_finish
+    end
+
+    #
+    # @api private
+    #
+    def write_last_run(covered_percent)
+      SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
+    end
+
+  private
+
+    #
+    # Trigger Coverage.start depends on given config coverage_criterion
+    #
+    # With Positive branch it supports all coverage measurement types
+    # With Negative branch it supports only line coverage measurement type
+    #
+    def start_coverage_measurment
+      # This blog post gives a good run down of the coverage criterias introduced
+      # in Ruby 2.5: https://blog.bigbinary.com/2018/04/11/ruby-2-5-supports-measuring-branch-and-method-coverages.html
+      # There is also a nice writeup of the different coverage criteria made in this
+      # comment  https://github.com/colszowka/simplecov/pull/692#discussion_r281836176 :
+      # Ruby < 2.5:
+      # https://github.com/ruby/ruby/blob/v1_9_3_374/ext/coverage/coverage.c
+      # traditional mode (Array)
+      #
+      # Ruby 2.5:
+      # https://bugs.ruby-lang.org/issues/13901
+      # https://github.com/ruby/ruby/blob/v2_5_3/ext/coverage/coverage.c
+      # default: traditional/compatible mode (Array)
+      # :lines - like traditional mode but using Hash
+      # :branches
+      # :methods
+      # :all - same as lines + branches + methods
+      #
+      # Ruby >= 2.6:
+      # https://bugs.ruby-lang.org/issues/15022
+      # https://github.com/ruby/ruby/blob/v2_6_3/ext/coverage/coverage.c
+      # default: traditional/compatible mode (Array)
+      # :lines - like traditional mode but using Hash
+      # :branches
+      # :methods
+      # :oneshot_lines - can not be combined with lines
+      # :all - same as lines + branches + methods
+      #
+      if branch_coverage?
+        Coverage.start(:all)
+      else
+        Coverage.start
+      end
+    end
+
+    #
+    # Finds files that were to be tracked but were not loaded and initializes
+    # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
+    #
+    def add_not_loaded_files(result)
+      if tracked_files
+        result = result.dup
+        Dir[tracked_files].each do |file|
+          absolute_path = File.expand_path(file)
+          result[absolute_path] ||= SimulateCoverage.call(absolute_path)
+        end
+      end
+
+      result
+    end
+
+    #
+    # Call steps that handle process coverage result
+    #
+    # @return [Hash]
+    #
+    def process_coverage_result
+      adapt_coverage_result
+      remove_useless_results
+      result_with_not_loaded_files
+    end
+
+    #
+    # Unite the result so it wouldn't matter what coverage type was called
+    #
+    # @return [Hash]
+    #
+    def adapt_coverage_result
+      @result = SimpleCov::ResultAdapter.call(Coverage.result)
+    end
+
+    #
+    # Filter coverage result
+    # The result before filter also has result of coverage for files
+    # are not related to the project like loaded gems coverage.
+    #
+    # @return [Hash]
+    #
+    def remove_useless_results
+      @result = SimpleCov::UselessResultsRemover.call(@result)
+    end
+
+    #
+    # Initialize result with files that are not included by coverage
+    # and added inside the config block
+    #
+    # @return [Hash]
+    #
+    def result_with_not_loaded_files
+      @result = SimpleCov::Result.new(add_not_loaded_files(@result))
+    end
   end
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
-require 'simplecov/configuration'
-SimpleCov.send :extend, SimpleCov::Configuration
-require 'simplecov/exit_codes'
-require 'simplecov/json'
-require 'simplecov/profiles'
-require 'simplecov/source_file'
-require 'simplecov/file_list'
-require 'simplecov/result'
-require 'simplecov/filter'
-require 'simplecov/formatter'
-require 'simplecov/last_run'
-require 'simplecov/merge_helpers'
-require 'simplecov/result_merger'
-require 'simplecov/command_guesser'
-require 'simplecov/version'
+require "set"
+require "simplecov/configuration"
+SimpleCov.extend SimpleCov::Configuration
+require "simplecov/exit_codes"
+require "simplecov/profiles"
+require "simplecov/source_file/line"
+require "simplecov/source_file/branch"
+require "simplecov/source_file"
+require "simplecov/file_list"
+require "simplecov/result"
+require "simplecov/filter"
+require "simplecov/formatter"
+require "simplecov/last_run"
+require "simplecov/lines_classifier"
+require "simplecov/result_merger"
+require "simplecov/command_guesser"
+require "simplecov/version"
+require "simplecov/result_adapter"
+require "simplecov/combine"
+require "simplecov/combine/branches_combiner"
+require "simplecov/combine/files_combiner"
+require "simplecov/combine/lines_combiner"
+require "simplecov/combine/results_combiner"
+require "simplecov/useless_results_remover"
+require "simplecov/simulate_coverage"
 
 # Load default config
-require 'simplecov/defaults' unless ENV['SIMPLECOV_NO_DEFAULTS']
-
-# Load Rails integration (only for Rails 3, see #113)
-require 'simplecov/railtie' if defined? Rails::Railtie
+require "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]