simplecov 0.16.1 → 0.18.0

data/lib/simplecov.rb

@@ -2,9 +2,6 @@
 
 require "English"
 
-#
-# Code coverage for ruby 1.9. Please check out README for a full introduction.
-#
 # Coverage may be inaccurate under JRUBY.
 if defined?(JRUBY_VERSION) && defined?(JRuby)
 
@@ -20,6 +17,10 @@ if defined?(JRUBY_VERSION) && defined?(JRuby)
       ' or set the "debug.fullTrace=true" option in your .jrubyrc'
   end
 end
+
+#
+# Code coverage for ruby. Please check out README for a full introduction.
+#
 module SimpleCov
   class << self
     attr_accessor :running
@@ -44,35 +45,49 @@ 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
-        self.pid = Process.pid
-        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
+      require "coverage"
+      initial_setup(profile, &block)
+      @result = nil
+      self.pid = Process.pid
+
+      start_coverage_measurement
     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).
+    # Collate a series of SimpleCov result files into a single SimpleCov output.
+    # You can optionally specify configuration with a block:
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do
+    #     add_filter 'test'
+    #   end
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
+    #     add_filter 'test'
+    #   end
     #
-    def add_not_loaded_files(result)
-      if tracked_files
-        result = result.dup
-        Dir[tracked_files].each do |file|
-          absolute = File.expand_path(file)
+    # Please check out the RDoc for SimpleCov::Configuration to find about
+    # available config options, or checkout the README for more in-depth
+    # information about coverage collation
+    #
+    def collate(result_filenames, profile = nil, &block)
+      raise "There's no reports to be merged" if result_filenames.empty?
 
-          result[absolute] ||= LinesClassifier.new.classify(File.foreach(absolute))
+      initial_setup(profile, &block)
+
+      results = result_filenames.flat_map do |filename|
+        # Re-create each included instance of SimpleCov::Result from the stored run data.
+        (JSON.parse(File.read(filename)) || {}).map do |command_name, coverage|
+          SimpleCov::Result.from_hash(command_name => coverage)
         end
       end
 
-      result
+      # Use the ResultMerger to produce a single, merged result, ready to use.
+      @result = SimpleCov::ResultMerger.merge_and_store(*results)
+
+      run_exit_tasks!
     end
 
     #
@@ -83,13 +98,13 @@ module SimpleCov
       return @result if result?
 
       # Collect our coverage result
-      if running
-        @result = SimpleCov::Result.new add_not_loaded_files(Coverage.result)
-      end
+
+      process_coverage_result if running
 
       # If we're using merging of results, store the current result
       # first (if there is one), then merge the results and return those
       if use_merging
+        wait_for_other_processes
         SimpleCov::ResultMerger.store_result(@result) if result?
         @result = SimpleCov::ResultMerger.merged_result
       end
@@ -146,22 +161,6 @@ module SimpleCov
       load_profile(name)
     end
 
-    #
-    # Checks whether we're on a proper version of Ruby (likely 1.9+) which
-    # provides coverage support
-    #
-    def usable?
-      return @usable if defined?(@usable) && !@usable.nil?
-
-      @usable = begin
-        require "coverage"
-        require "simplecov/jruby_fix"
-        true
-      rescue LoadError
-        false
-      end
-    end
-
     #
     # Clear out the previously cached .result. Primarily useful in testing
     #
@@ -195,15 +194,22 @@ module SimpleCov
     # Called from at_exit block
     #
     def run_exit_tasks!
+      set_exit_exception
+
       exit_status = SimpleCov.exit_status_from_exception
 
       SimpleCov.at_exit.call
 
-      exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
+      # 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)
-      Kernel.exit exit_status if exit_status && exit_status > 0
+      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
@@ -212,32 +218,38 @@ module SimpleCov
     #   exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
     #
     def process_result(result, exit_status)
-      return exit_status unless SimpleCov.result? # Result has been computed
       return exit_status if exit_status != SimpleCov::ExitCodes::SUCCESS # Existing errors
 
-      covered_percent = result.covered_percent.round(2)
+      covered_percent = result.covered_percent.floor(2)
       result_exit_status = result_exit_status(result, covered_percent)
-      if result_exit_status == SimpleCov::ExitCodes::SUCCESS # No result errors
-        write_last_run(covered_percent)
-      end
-      result_exit_status
+      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.round(2) }
-      if covered_percent < SimpleCov.minimum_coverage
-        $stderr.printf("Coverage (%.2f%%) is below the expected minimum coverage (%.2f%%).\n", covered_percent, SimpleCov.minimum_coverage)
+      covered_percentages = result.covered_percentages.map { |percentage| percentage.floor(2) }
+      if (minimum_violations = minimum_coverage_violated(result)).any?
+        report_minimum_violated(minimum_violations)
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file }
-        $stderr.printf("File (%s) is only (%.2f%%) covered. This is below the expected minimum coverage per file of (%.2f%%).\n", result.least_covered_file, covered_percentages.min, 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
+        coverage_diff = last_run[:result][:covered_percent] - covered_percent
         if coverage_diff > SimpleCov.maximum_coverage_drop
-          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", 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
@@ -248,20 +260,189 @@ module SimpleCov
     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})
+      SimpleCov::LastRun.write(result: {covered_percent: covered_percent})
+    end
+
+  private
+
+    def initial_setup(profile, &block)
+      load_profile(profile) if profile
+      configure(&block) if block_given?
+      self.running = true
+    end
+
+    #
+    # 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_measurement
+      # 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 coverage_start_arguments_supported?
+        start_coverage_with_criteria
+      else
+        Coverage.start
+      end
+    end
+
+    def start_coverage_with_criteria
+      start_arguments = coverage_criteria.map do |criterion|
+        [lookup_corresponding_ruby_coverage_name(criterion), true]
+      end.to_h
+
+      Coverage.start(start_arguments)
+    end
+
+    CRITERION_TO_RUBY_COVERAGE = {
+      branch: :branches,
+      line: :lines
+    }.freeze
+    def lookup_corresponding_ruby_coverage_name(criterion)
+      CRITERION_TO_RUBY_COVERAGE.fetch(criterion)
+    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
+
+    def minimum_coverage_violated(result)
+      coverage_achieved = minimum_coverage.map do |criterion, percent|
+        {
+          criterion: criterion,
+          minimum_expected: percent,
+          actual: result.coverage_statistics[criterion].percent
+        }
+      end
+
+      coverage_achieved.select do |achieved|
+        achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+      end
+    end
+
+    def report_minimum_violated(violations)
+      violations.each do |violation|
+        $stderr.printf(
+          "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+          covered: violation.fetch(:actual).floor(2),
+          minimum_coverage: violation.fetch(:minimum_expected),
+          criterion: violation.fetch(:criterion).capitalize
+        )
+      end
     end
   end
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
+require "set"
+require "forwardable"
 require "simplecov/configuration"
-SimpleCov.send :extend, SimpleCov::Configuration
+SimpleCov.extend SimpleCov::Configuration
+require "simplecov/coverage_statistics"
 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"
@@ -269,13 +450,17 @@ require "simplecov/filter"
 require "simplecov/formatter"
 require "simplecov/last_run"
 require "simplecov/lines_classifier"
-require "simplecov/raw_coverage"
 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

metadata

@@ -1,49 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.18.0
 platform: ruby
 authors:
 - Christoph Olszowka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-16 00:00:00.000000000 Z
+date: 2020-01-28 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
-- !ruby/object:Gem::Dependency
-  name: simplecov-html
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: docile
   requirement: !ruby/object:Gem::Requirement
@@ -59,21 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: simplecov-html
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
-  type: :development
+        version: 0.11.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
-description: Code coverage for Ruby 1.9+ with a powerful configuration library and
-  automatic merging of coverage across test suites
+        version: 0.11.0
+description: Code coverage for Ruby with a powerful configuration library and automatic
+  merging of coverage across test suites
 email:
 - christoph at olszowka de
 executables: []
@@ -81,6 +47,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - ISSUE_TEMPLATE.md
 - LICENSE
@@ -89,8 +56,14 @@ files:
 - doc/commercial-services.md
 - doc/editor-integration.md
 - lib/simplecov.rb
+- lib/simplecov/combine.rb
+- lib/simplecov/combine/branches_combiner.rb
+- lib/simplecov/combine/files_combiner.rb
+- lib/simplecov/combine/lines_combiner.rb
+- lib/simplecov/combine/results_combiner.rb
 - lib/simplecov/command_guesser.rb
 - lib/simplecov/configuration.rb
+- lib/simplecov/coverage_statistics.rb
 - lib/simplecov/defaults.rb
 - lib/simplecov/exit_codes.rb
 - lib/simplecov/file_list.rb
@@ -98,27 +71,34 @@ files:
 - lib/simplecov/formatter.rb
 - lib/simplecov/formatter/multi_formatter.rb
 - lib/simplecov/formatter/simple_formatter.rb
-- lib/simplecov/jruby_fix.rb
 - lib/simplecov/last_run.rb
 - lib/simplecov/lines_classifier.rb
 - lib/simplecov/load_global_config.rb
 - lib/simplecov/no_defaults.rb
 - lib/simplecov/profiles.rb
 - lib/simplecov/profiles/bundler_filter.rb
+- lib/simplecov/profiles/hidden_filter.rb
 - lib/simplecov/profiles/rails.rb
 - lib/simplecov/profiles/root_filter.rb
 - lib/simplecov/profiles/test_frameworks.rb
-- lib/simplecov/railtie.rb
-- lib/simplecov/railties/tasks.rake
-- lib/simplecov/raw_coverage.rb
 - lib/simplecov/result.rb
+- lib/simplecov/result_adapter.rb
 - lib/simplecov/result_merger.rb
+- lib/simplecov/simulate_coverage.rb
 - lib/simplecov/source_file.rb
+- lib/simplecov/source_file/branch.rb
+- lib/simplecov/source_file/line.rb
+- lib/simplecov/useless_results_remover.rb
 - lib/simplecov/version.rb
-homepage: http://github.com/colszowka/simplecov
+homepage: https://github.com/colszowka/simplecov
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/colszowka/simplecov/issues
+  changelog_uri: https://github.com/colszowka/simplecov/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.18.0
+  mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
+  source_code_uri: https://github.com/colszowka/simplecov/tree/v0.18.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -127,17 +107,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Code coverage for Ruby 1.9+ with a powerful configuration library and automatic
-  merging of coverage across test suites
+summary: Code coverage for Ruby
 test_files: []

data/lib/simplecov/jruby_fix.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-if defined?(JRUBY_VERSION) && JRUBY_VERSION.to_f < 1.7
-  require "jruby"
-  java_import "org.jruby.ast.NodeType"
-
-  # Coverage for JRuby < 1.7.0 does not work correctly
-  #
-  #  - does not distinguish lines that cannot be executed
-  #  - does (partial) coverage for files loaded before `Coverage.start`.
-  #  - does not expand a path like `lib/../spec` to `spec`.
-  #
-  # This monkey patches Coverage to address those issues
-  module Coverage
-    class << self
-      alias __broken_result__ result
-
-      def result # rubocop:disable Metrics/MethodLength
-        fixed = {}
-        __broken_result__.each do |path, executed_lines|
-          next unless File.file? path
-
-          covered_lines = executed_lines.dup
-
-          process = lambda do |node|
-            if node.node_type == NodeType::NEWLINENODE
-              pos = node.position
-              covered_lines[pos.line] ||= 0
-            end
-            node.child_nodes.each(&process)
-          end
-
-          process[JRuby.parse(File.read(path), path)]
-
-          if (first = covered_lines.detect { |x| x }) && first > 0
-            fixed[File.expand_path(path)] = covered_lines
-          end
-        end
-
-        fixed
-      end
-    end
-  end
-end

data/lib/simplecov/railtie.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCov
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load "simplecov/railties/tasks.rake"
-    end
-  end
-end

data/lib/simplecov/railties/tasks.rake

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.name = "simplecov"
-  t.loader = :direct # uses require() which skips PWD in Ruby 1.9
-  t.libs.push "test", "spec", Dir.pwd
-  t.test_files = FileList["{test,spec}/**/*_{test,spec}.rb"]
-  t.ruby_opts.push "-r", "simplecov", "-e", "SimpleCov.start(:rails)".inspect
-end
-
-require "rake/clean"
-CLOBBER.include "coverage"

data/lib/simplecov/raw_coverage.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCov
-  module RawCoverage
-  module_function
-
-    # Merges multiple Coverage.result hashes
-    def merge_results(*results)
-      results.reduce({}) do |result, merged|
-        merge_resultsets(result, merged)
-      end
-    end
-
-    # Merges two Coverage.result hashes
-    def merge_resultsets(result1, result2)
-      (result1.keys | result2.keys).each_with_object({}) do |filename, merged|
-        file1 = result1[filename]
-        file2 = result2[filename]
-        merged[filename] = merge_file_coverage(file1, file2)
-      end
-    end
-
-    def merge_file_coverage(file1, file2)
-      return (file1 || file2).dup unless file1 && file2
-
-      file1.map.with_index do |count1, index|
-        count2 = file2[index]
-        merge_line_coverage(count1, count2)
-      end
-    end
-
-    def merge_line_coverage(count1, count2)
-      sum = count1.to_i + count2.to_i
-      if sum.zero? && (count1.nil? || count2.nil?)
-        nil
-      else
-        sum
-      end
-    end
-  end
-end