module SimpleCov::Configuration

def adapters
  warn "#{Kernel.caller.first}: [DEPRECATION] #adapters is deprecated. Use #profiles instead."
  profiles
end

def add_filter(filter_argument = nil, &filter_proc)
  filters << parse_filter(filter_argument, &filter_proc)
end

def add_group(group_name, filter_argument = nil, &filter_proc)
  groups[group_name] = parse_filter(filter_argument, &filter_proc)
end

def at_exit(&block)
  return proc {} unless running || block_given?
  @at_exit = block if block_given?
  @at_exit ||= proc { SimpleCov.result.format! }
end

def branch_coverage?
  branch_coverage_supported? && coverage_criterion_enabled?(:branch)
end

def clear_coverage_criteria
  @coverage_criteria = nil
end

def command_name(name = nil)
  @name = name unless name.nil?
  @name ||= SimpleCov::CommandGuesser.guess
  @name
end

def configure(&block)
  Docile.dsl_eval(self, &block)
end

def coverage_criteria
  @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
end

def coverage_criterion(criterion = nil)
  return @coverage_criterion ||= DEFAULT_COVERAGE_CRITERION unless criterion
  raise_if_criterion_unsupported(criterion)
  @coverage_criterion = criterion
end

def coverage_criterion_enabled?(criterion)
  coverage_criteria.member?(criterion)
end

def coverage_dir(dir = nil)
  return @coverage_dir if defined?(@coverage_dir) && dir.nil?
  @coverage_path = nil # invalidate cache
  @coverage_dir = (dir || "coverage")
end

def coverage_path
  @coverage_path ||= begin
    coverage_path = File.expand_path(coverage_dir, root)
    FileUtils.mkdir_p coverage_path
    coverage_path
  end
end

def coverage_start_arguments_supported?
  # safe to cache as within one process this value should never
  # change
  return @coverage_start_arguments_supported if defined?(@coverage_start_arguments_supported)
  @coverage_start_arguments_supported = begin
    require "coverage"
    !Coverage.method(:start).arity.zero?
  end
end

def enable_coverage(criterion)
  raise_if_criterion_unsupported(criterion)
  coverage_criteria << criterion
end

def filters
  @filters ||= []
end

def formatter(formatter = nil)
  return @formatter if defined?(@formatter) && formatter.nil?
  @formatter = formatter
  raise "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
  @formatter
end

def formatters
  if @formatter.is_a?(SimpleCov::Formatter::MultiFormatter)
    @formatter.formatters
  else
    Array(formatter)
  end
end

def formatters=(formatters)
  @formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
end

def groups
  @groups ||= {}
end

def maximum_coverage_drop(coverage_drop = nil)
  @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
end

def merge_timeout(seconds = nil)
  @merge_timeout = seconds if seconds.is_a?(Integer)
  @merge_timeout ||= 600
end

def minimum_coverage(coverage = nil)
  return @minimum_coverage ||= {} unless coverage
  coverage = {DEFAULT_COVERAGE_CRITERION => coverage} if coverage.is_a?(Numeric)
  coverage.keys.each { |criterion| raise_if_criterion_disabled(criterion) }
  coverage.values.each do |percent|
    minimum_possible_coverage_exceeded("minimum_coverage") if percent && percent > 100
  end
  @minimum_coverage = coverage
end

def minimum_coverage_by_file(coverage = nil)
  minimum_possible_coverage_exceeded("minimum_coverage_by_file") if coverage && coverage > 100
  @minimum_coverage_by_file ||= (coverage || 0).to_f.round(2)
end

def minimum_possible_coverage_exceeded(coverage_option)
  warn "The coverage you set for #{coverage_option} is greater than 100%"
end

def nocov_token(nocov_token = nil)
  return @nocov_token if defined?(@nocov_token) && nocov_token.nil?
  @nocov_token = (nocov_token || "nocov")
end

def parse_filter(filter_argument = nil, &filter_proc)
  filter = filter_argument || filter_proc
  if filter
    SimpleCov::Filter.build_filter(filter)
  else
    raise ArgumentError, "Please specify either a filter or a block to filter with"
  end
end

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

def profiles
  @profiles ||= SimpleCov::Profiles.new
end

def project_name(new_name = nil)
  return @project_name if defined?(@project_name) && @project_name && new_name.nil?
  @project_name = new_name if new_name.is_a?(String)
  @project_name ||= File.basename(root.split("/").last).capitalize.tr("_", " ")
end

def raise_if_criterion_disabled(criterion)
  raise_if_criterion_unsupported(criterion)
  # rubocop:disable Style/IfUnlessModifier
  unless coverage_criterion_enabled?(criterion)
    raise "Coverage criterion #{criterion}, is disabled! Please enable it first through enable_coverage #{criterion} (if supported)"
  end
  # rubocop:enable Style/IfUnlessModifier
end

def raise_if_criterion_unsupported(criterion)
  # rubocop:disable Style/IfUnlessModifier
  unless SUPPORTED_COVERAGE_CRITERIA.member?(criterion)
    raise "Unsupported coverage criterion #{criterion}, supported values are #{SUPPORTED_COVERAGE_CRITERIA}"
  end
  # rubocop:enable Style/IfUnlessModifier
end

def refuse_coverage_drop
  maximum_coverage_drop 0
end

def root(root = nil)
  return @root if defined?(@root) && root.nil?
  @root = File.expand_path(root || Dir.getwd)
end

def track_files(glob)
  @tracked_files = glob
end

def tracked_files
  @tracked_files if defined?(@tracked_files)
end

def use_merging(use = nil)
  @use_merging = use unless use.nil?
  @use_merging = true unless defined?(@use_merging) && @use_merging == false
end