module SimpleCov

def add_not_loaded_files(result)
  if tracked_files
    result = result.dup
    Dir[tracked_files].each do |file|
      absolute = File.expand_path(file)
      result[absolute] ||= LinesClassifier.new.classify(File.foreach(absolute))
    end
  end
  result
end

def clear_result
  @result = nil
end

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

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

def grouped(files)
  grouped = {}
  grouped_files = []
  groups.each do |name, filter|
    grouped[name] = SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
    grouped_files += grouped[name]
  end
  if !groups.empty? && !(other_files = files.reject { |source_file| grouped_files.include?(source_file) }).empty?
    grouped["Ungrouped"] = SimpleCov::FileList.new(other_files)
  end
  grouped
end

def load_adapter(name)
  warn "#{Kernel.caller.first}: [DEPRECATION] #load_adapter is deprecated. Use #load_profile instead."
  load_profile(name)
end

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

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)
  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
end

def result
  return @result if result?
  # Collect our coverage result
  if running
    @result = SimpleCov::Result.new add_not_loaded_files(Coverage.result)
  end
  # 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?
    @result = SimpleCov::ResultMerger.merged_result
  end
  @result
ensure
  self.running = false
end

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

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)
    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)
    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 %.2f%% since the last time (maximum allowed: %.2f%%).\n", coverage_diff, SimpleCov.maximum_coverage_drop)
      SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
    else
      SimpleCov::ExitCodes::SUCCESS
    end
  else
    SimpleCov::ExitCodes::SUCCESS
  end
end

def run_exit_tasks!
  exit_status = SimpleCov.exit_status_from_exception
  SimpleCov.at_exit.call
  exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
  # 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
end

def set_exit_exception
  @exit_exception = $ERROR_INFO
end

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
end

def usable?
  return @usable if defined?(@usable) && !@usable.nil?
  @usable = begin
    require "coverage"
    require "simplecov/jruby_fix"
    true
  rescue LoadError
    false
  end
end

def write_last_run(covered_percent)
  SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
end