Module: SimpleCov

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

def final_result_process?
  return true unless defined?(ParallelTests) && ENV["TEST_ENV_NUMBER"]

  # parallel_tests sets the first process's TEST_ENV_NUMBER to "" and
  # `ParallelTests.last_process?` does `"" == "1"`, which is false —
  # so with PARALLEL_TEST_GROUPS=1 the only process in the run never
  # runs the final-result work. Treat any single-group run as final.
  ENV["PARALLEL_TEST_GROUPS"].to_i <= 1 || ParallelTests.last_process?
end

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

attr_accessor :pid

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

def probably_running_parallel_tests?
  ENV.fetch("TEST_ENV_NUMBER", nil) && ENV.fetch("PARALLEL_TEST_GROUPS", nil)
end

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

attr_accessor :process_start_time

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

def ready_to_process_results?
  final_result_process? && result?
end

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

def result
  return @result if result?

  # Collect our coverage result
  process_coverage_result 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
    wait_for_other_processes
    SimpleCov::ResultMerger.store_result(@result) if result?
    @result = SimpleCov::ResultMerger.merged_result
  end

  @result
end

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

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

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

def add_not_loaded_files(result)
  return [result, Set.new] unless tracked_files

  result = result.dup
  # Glob and expand relative to SimpleCov.root, not Dir.pwd — test runners
  # that chdir (or CI scripts that invoke the suite from a subdir) would
  # otherwise silently miss the unloaded-file injection and produce a
  # different file set per environment. See issue #1106.
  not_loaded_files = Dir.glob(tracked_files, base: root).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 207

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.
  SimpleCov.run_exit_tasks! if Coverage.running?
end

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

def clear_result
  @result = nil
end

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

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

  initial_setup(profile, &block)

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

  run_exit_tasks!
end

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

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

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

def exit_and_report_previous_error(exit_status)
  if print_error_status
    warn("Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected")
  end
  Kernel.exit(exit_status)
end

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

def exit_status_from_exception
  # Capture the current exception if it exists
  @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.rb', line 33

attr_accessor :external_at_exit

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

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.rb', line 179

def grouped(files)
  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.values.flat_map(&:to_a)
  ungrouped = files.reject { |source_file| in_group.include?(source_file) }
  grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?

  grouped
end

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

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

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

def install_at_exit_hook
  return if @at_exit_hook_installed

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

    SimpleCov.at_exit_behavior
  end
end

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

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

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

def lookup_corresponding_ruby_coverage_name(criterion)
  CRITERION_TO_RUBY_COVERAGE.fetch(criterion)
end

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

def make_parallel_tests_available
  return if defined?(ParallelTests) # simplecov:disable — only true after a previous load
  return unless probably_running_parallel_tests? # simplecov:disable — false outside parallel_tests

  # simplecov:disable — only fires under a real parallel_tests setup
  require "parallel_tests"
rescue LoadError
  warn(
    "SimpleCov guessed you were running inside parallel tests but couldn't load it. " \
    "Please file a bug report with us!"
  )
  # simplecov:enable
end

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

def previous_error?(error_exit_status)
  # Normally it'd be enough to check for previous error but when running test_unit
  # status is 0
  error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS
end

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

def process_coverage_result
  remove_useless_results
  adapt_coverage_result
  result_with_not_loaded_files
end

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

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.rb', line 269

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?

  warn("SimpleCov failed with exit #{exit_status} due to a coverage related error") if print_error_status
  Kernel.exit exit_status
end

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

def remove_useless_results
  @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
end

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

def result_exit_status(result)
  coverage_limits = CoverageLimits.new(
    minimum_coverage: minimum_coverage, minimum_coverage_by_file: minimum_coverage_by_file,
    minimum_coverage_by_group: minimum_coverage_by_group, maximum_coverage_drop: maximum_coverage_drop
  )

  ExitCodes::ExitCodeHandling.call(result, coverage_limits: coverage_limits)
end

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

def result_with_not_loaded_files
  result, not_loaded_files = add_not_loaded_files(@result)
  @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files)
end

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

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

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

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 53

def start(profile = nil, &)
  initial_setup(profile, &)
  start_tracking
  install_at_exit_hook
end

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

def start_coverage_measurement
  start_coverage_with_criteria
end

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

def start_coverage_with_criteria
  start_arguments = coverage_criteria.to_h do |criterion|
    [lookup_corresponding_ruby_coverage_name(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 84

def start_tracking
  require "coverage"
  warn_if_jruby_full_trace_disabled
  # 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

  make_parallel_tests_available

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

  start_coverage_measurement
end

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

def wait_for_other_processes
  return unless defined?(ParallelTests) && final_result_process?

  ParallelTests.wait_for_other_processes_to_finish

  # ParallelTests signals "done" before at_exit handlers finish, so other
  # processes may still be writing their results. Poll the resultset until
  # all parallel groups have reported or a timeout is reached.
  wait_for_parallel_results
end

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

def wait_for_parallel_results
  expected = ENV["PARALLEL_TEST_GROUPS"]&.to_i
  return unless expected && expected > 1 # simplecov:disable branch — only false in real parallel_tests run

  # simplecov:disable — only fires when ENV is set with >1 group
  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 10
  loop do
    resultset = SimpleCov::ResultMerger.read_resultset
    break if resultset.size >= expected
    break if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline

    sleep 0.1
  end
  # simplecov:enable
end

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

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 361

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