Module: SimpleCov

# File 'lib/simplecov/exit_handling.rb', line 40

def defer_to_existing_report?
  return false unless existing_report_newer_than_us?

  res = result
  empty = res.nil? || res.files.empty?
  warn_about_deferred_report if empty
  empty
end

# File 'lib/simplecov/exit_handling.rb', line 49

def existing_report_newer_than_us?
  return false unless process_start_time

  last_run_path = File.join(coverage_path, ".last_run.json")
  File.exist?(last_run_path) && File.mtime(last_run_path) > process_start_time
end

# File 'lib/simplecov.rb', line 57

attr_accessor :external_at_exit

# File 'lib/simplecov.rb', line 68

def external_at_exit?
  !!@external_at_exit
end

# File 'lib/simplecov/parallel_coordination.rb', line 12

def final_result_process?
  adapter = SimpleCov::ParallelAdapters.current
  # No recognized parallel-test adapter. A subprocess forked while
  # coverage was running is never the final reporter — the process that
  # spawned it merges every slice and produces the report. Without this,
  # fork-based runners that don't set TEST_ENV_NUMBER (e.g. Minitest's
  # `parallelize`) have every worker produce the final report and its
  # warnings. See issue #1171.
  return !forked_subprocess? unless adapter

  adapter.first_worker?
end

# File 'lib/simplecov.rb', line 47

def forked_subprocess?
  !!(defined?(@forked_subprocess) && @forked_subprocess)
end

# File 'lib/simplecov.rb', line 186

def minitest_autorun_pending?
  return false unless defined?(Minitest) && Minitest.respond_to?(:after_run)
  return false unless Minitest.class_variable_defined?(:@@installed_at_exit)

  Minitest.class_variable_get(:@@installed_at_exit)
end

# File 'lib/simplecov/parallel_coordination.rb', line 48

def parallel_results_complete?
  defined?(@parallel_results_complete) ? @parallel_results_complete : true
end

# File 'lib/simplecov.rb', line 19

attr_accessor :pid

# File 'lib/simplecov.rb', line 23

attr_accessor :process_start_time

# File 'lib/simplecov/exit_handling.rb', line 115

def ready_to_process_results?
  merge_finalization_owner? && final_result_process? && result? &&
    (collating_result? || parallel_results_complete?)
end

# File 'lib/simplecov/result_processing.rb', line 34

def result
  return @result if result?

  use_merging = merging

  # Collect our coverage result. When merging is off there is no merge
  # step, so this per-process result is the final one and reports any
  # dropped source files; otherwise the merged result does the reporting.
  process_coverage_result(report: !use_merging) if defined?(Coverage) && Coverage.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
    SimpleCov::ResultMerger.store_result(@result) if result?
    return @result unless finalize_merge?

    wait_for_other_processes
    @result = SimpleCov::ResultMerger.merged_result
  end

  @result
end

# File 'lib/simplecov/result_processing.rb', line 58

def result?
  defined?(@result) && @result
end

# File 'lib/simplecov/exit_handling.rb', line 20

def at_exit_behavior
  # If we are in a different process than called start, don't interfere.
  return if SimpleCov.pid != Process.pid

  # If Coverage is no longer running (e.g. someone manually stopped it
  # or a test consumed the result) then don't run exit tasks.
  return unless Coverage.running?

  # Stand down when we'd only clobber a fresher report. See
  # `defer_to_existing_report?` and issue #581.
  return if defer_to_existing_report?

  SimpleCov.run_exit_tasks!
end

# File 'lib/simplecov/exit_handling.rb', line 147

def build_coverage_limits
  CoverageLimits.new(
    minimum_coverage: minimum_coverage,
    minimum_coverage_by_file: minimum_coverage_by_file,
    minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
    minimum_coverage_by_group: minimum_coverage_by_group,
    maximum_coverage: maximum_coverage,
    maximum_coverage_drop: maximum_coverage_drop
  )
end

# File 'lib/simplecov/result_processing.rb', line 101

def clear_result
  @result = nil
end

# File 'lib/simplecov/result_processing.rb', line 16

def collate(result_filenames, profile = nil, ignore_timeout: true, &)
  raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?

  initial_setup(profile, &)

  # Use the ResultMerger to produce a single, merged result, ready to use.
  @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)

  @collating_result = true
  run_exit_tasks!
ensure
  @collating_result = false
end

# File 'lib/simplecov.rb', line 62

def coverage_statistics_key(criterion)
  criterion == :oneshot_line ? :line : criterion
end

# File 'lib/simplecov.rb', line 193

def defer_to_minitest_after_run
  self.external_at_exit = true
  Minitest.after_run { SimpleCov.at_exit_behavior }
end

# File 'lib/simplecov/result_processing.rb', line 152

def discover_unloaded_paths(globs)
  globs.flat_map { |glob| Dir.glob(glob, base: root) }.uniq
end

# File 'lib/simplecov/exit_handling.rb', line 98

def exit_and_report_previous_error(exit_status)
  if print_errors
    warn SimpleCov::Color.colorize(
      "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
      :yellow
    )
  end
  Kernel.exit(exit_status)
end

# File 'lib/simplecov/exit_handling.rb', line 79

def exit_status_from_exception
  @exit_exception = $ERROR_INFO
  return nil unless @exit_exception

  if @exit_exception.is_a?(SystemExit)
    @exit_exception.status
  else
    SimpleCov::ExitCodes::EXCEPTION
  end
end

# File 'lib/simplecov/result_processing.rb', line 68

def filtered(files)
  result = files.clone
  filters.each do |filter|
    result = result.reject { |source_file| filter.matches?(source_file) }
  end
  SimpleCov::FileList.new result
end

# File 'lib/simplecov/result_processing.rb', line 81

def grouped(files, groups: SimpleCov.groups)
  return {} if groups.empty?

  grouped = groups.transform_values do |filter|
    SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
  end

  in_group  = grouped_file_set(grouped)
  ungrouped = files.reject { |source_file| in_group.include?(source_file) }
  grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?

  grouped
end

# File 'lib/simplecov/result_processing.rb', line 125

def grouped_file_set(grouped)
  grouped.values.each_with_object(Set.new) { |file_list, set| set.merge(file_list) }
end

# File 'lib/simplecov/result_processing.rb', line 120

def initial_setup(profile, &block)
  load_profile(profile) if profile
  configure(&block) if block
end

# File 'lib/simplecov/result_processing.rb', line 156

def inject_unloaded_files(result, candidate_paths)
  not_loaded_files = candidate_paths.each_with_object(Set.new) do |file, set|
    absolute_path = File.expand_path(file, root)
    next if result.key?(absolute_path)

    result[absolute_path] = SimulateCoverage.call(absolute_path)
    set << absolute_path
  end

  [result, not_loaded_files]
end

# File 'lib/simplecov.rb', line 122

def install_at_exit_hook
  return if @at_exit_hook_installed

  @at_exit_hook_installed = true
  defer_to_minitest_after_run if minitest_autorun_pending?
  Kernel.at_exit do
    next if SimpleCov.external_at_exit?

    SimpleCov.at_exit_behavior
  end
end

# File 'lib/simplecov/result_processing.rb', line 96

def load_profile(name)
  profiles.load(name)
end

# File 'lib/simplecov.rb', line 52

def mark_forked_subprocess!
  @forked_subprocess = true
end

# File 'lib/simplecov.rb', line 37

def next_subprocess_serial!
  @subprocess_serial = subprocess_serial + 1
end

# File 'lib/simplecov/parallel_coordination.rb', line 72

def parallel_wait_timed_out?(deadline, expected, seen)
  return false unless Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline

  warn_about_incomplete_parallel_results(expected, seen)
  true
end

# File 'lib/simplecov/exit_handling.rb', line 93

def previous_error?(error_exit_status)
  !!(error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS)
end

# File 'lib/simplecov/result_processing.rb', line 172

def process_coverage_result(report:)
  @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
  @result = SimpleCov::ResultAdapter.call(@result)
  result, not_loaded_files = add_not_loaded_files(@result)
  @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files, report: report)
end

# File 'lib/simplecov/exit_handling.rb', line 135

def process_result(result)
  result_exit_status = result_exit_status(result)
  write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
  result_exit_status
end

# File 'lib/simplecov/exit_handling.rb', line 120

def process_results_and_report_error
  exit_status = process_result(result)

  # Force exit with stored status (see github issue #5)
  return unless exit_status.positive?

  if print_errors
    warn SimpleCov::Color.colorize(
      "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
    )
  end
  Kernel.exit exit_status
end

# File 'lib/simplecov/exit_handling.rb', line 141

def result_exit_status(result)
  ExitCodes::ExitCodeHandling.call(result, coverage_limits: build_coverage_limits)
end

# File 'lib/simplecov/result_processing.rb', line 114

def round_coverage(coverage)
  coverage.floor(2)
end

# File 'lib/simplecov/exit_handling.rb', line 69

def run_exit_tasks!
  error_exit_status = exit_status_from_exception

  at_exit.call

  exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
  process_results_and_report_error if ready_to_process_results?
end

# File 'lib/simplecov.rb', line 80

def start(profile = nil, &)
  warn_about_start_in_dot_simplecov if @autoloading_dot_simplecov

  initial_setup(profile, &)
  start_tracking
  install_at_exit_hook
end

# File 'lib/simplecov.rb', line 169

def start_coverage_measurement
  start_arguments = coverage_criteria.to_h do |criterion|
    [CRITERION_TO_RUBY_COVERAGE.fetch(criterion), true]
  end

  start_arguments[:eval] = true if coverage_for_eval_enabled?

  Coverage.start(start_arguments) unless Coverage.running?
end

# File 'lib/simplecov.rb', line 141

def start_tracking
  require "coverage"
  warn_if_jruby_full_trace_disabled
  validate_coverage_criteria!
  # simplecov:disable — fork-hook is enabled via SimpleCov.enable_for_subprocesses, off by default
  require_relative "simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
                                          ::Process.respond_to?(:_fork)
  # simplecov:enable

  # Trigger adapter selection now so the (possibly lazy) parallel_tests
  # gem load happens at start_tracking time rather than mid-suite.
  # `current` is memoized; subsequent calls are cheap.
  SimpleCov::ParallelAdapters.current

  @result = nil
  self.pid = Process.pid
  self.process_start_time = Time.now

  start_coverage_measurement
end

# File 'lib/simplecov.rb', line 31

def subprocess_serial
  @subprocess_serial ||= 0
end

# File 'lib/simplecov/result_processing.rb', line 143

def unloaded_file_discovery_globs
  [tracked_files, *cover_globs].compact
end

# File 'lib/simplecov/parallel_coordination.rb', line 26

def wait_for_other_processes
  adapter = SimpleCov::ParallelAdapters.current
  return unless adapter && final_result_process?

  # Native synchronization first (adapters that wrap a runner with a
  # real "wait" primitive — parallel_tests'
  # `wait_for_other_processes_to_finish` — implement this; adapters
  # without a native API no-op and rely on the polling fallback below).
  adapter.wait_for_siblings

  # The native wait can return before sibling at_exit handlers finish
  # writing resultsets, and adapters without a native wait have
  # nothing else. Either way, poll the resultset cache until all
  # expected workers have reported or a timeout is reached. Capture
  # the outcome so `ready_to_process_results?` can suppress min/max
  # threshold checks against a partial total.
  @parallel_results_complete = wait_for_parallel_results(adapter.expected_worker_count)
end

# File 'lib/simplecov/parallel_coordination.rb', line 57

def wait_for_parallel_results(expected)
  return true unless expected > 1 # simplecov:disable branch — only false in real parallel runs

  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + parallel_wait_timeout
  loop do
    seen = SimpleCov::ResultMerger.read_resultset.size
    return true if seen >= expected
    return false if parallel_wait_timed_out?(deadline, expected, seen)

    sleep 0.1
  end
end

# File 'lib/simplecov/exit_handling.rb', line 56

def warn_about_deferred_report
  return unless print_errors

  warn SimpleCov::Color.colorize(
    "Skipping SimpleCov report — this process tracked no application code and a newer " \
    "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
    "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
    "runner. See https://github.com/simplecov-ruby/simplecov/issues/581.",
    :yellow
  )
end

# File 'lib/simplecov/parallel_coordination.rb', line 80

def warn_about_incomplete_parallel_results(expected, seen)
  return unless print_errors

  warn SimpleCov::Color.colorize(
    "Only #{seen} of #{expected} parallel-test workers reported within " \
    "#{parallel_wait_timeout}s, so coverage totals are partial and minimum / " \
    "maximum coverage checks are skipped for this run. Increase " \
    "SimpleCov.parallel_wait_timeout if a worker routinely needs longer.",
    :yellow
  )
end

# File 'lib/simplecov.rb', line 103

def warn_about_start_in_dot_simplecov
  return if @dot_simplecov_start_warned

  @dot_simplecov_start_warned = true
  warn "[DEPRECATION] Calling `SimpleCov.start` from `.simplecov` is deprecated and will " \
       "be removed in a future release. `.simplecov` should contain configuration only; " \
       "move the `SimpleCov.start` call into your `spec_helper.rb` / `test_helper.rb`. " \
       "Coverage tracking still begins for backward compatibility, but a future release " \
       "will require the explicit `SimpleCov.start` from a test helper. " \
       "See https://github.com/simplecov-ruby/simplecov/issues/581."
end

# File 'lib/simplecov.rb', line 202

def warn_if_jruby_full_trace_disabled
  return unless defined?(JRUBY_VERSION) && defined?(JRuby) # simplecov:disable — JRuby-only branch

  # simplecov:disable — JRuby-only branches; unreachable from CRuby
  return if 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'
  # simplecov:enable
end

# File 'lib/simplecov.rb', line 95

def with_dot_simplecov_autoload
  previous = @autoloading_dot_simplecov
  @autoloading_dot_simplecov = true
  yield
ensure
  @autoloading_dot_simplecov = previous
end

# File 'lib/simplecov/result_processing.rb', line 107

def write_last_run(result)
  SimpleCov::LastRun.write(
    result: result.coverage_statistics.transform_values { |stats| round_coverage(stats.percent) }
  )
end