module Covet

# File lib/covet.rb, line 145
def self.cmdline_for_run_list(run_list)
  Covet::TestRunners.const_get(
    @test_runner.to_s.capitalize
  ).cmdline_for_run_list(run_list)
end

# File lib/covet.rb, line 154
def self.coverage_before_and_after # yields
  before = CovetCoverage.peek_result
  yield
  after = CovetCoverage.peek_result
  before = normalize_coverage_info(before)
  if Covet::BASE_COVERAGE.any?
    before = diff_coverages(Covet::BASE_COVERAGE, before)
  end
  after = normalize_coverage_info(after)
  after = diff_coverages(before, after)
  [before, after]
end

# File lib/covet.rb, line 139
def self.coverage_collection_registered?
  @coverage_collection_registered
end

# File lib/covet.rb, line 197
def self.diff_coverages(before, after)
  ret = after.each_with_object({}) do |(file_name, after_line_cov), res|
    before_line_cov = before[file_name] || {}
    next if before_line_cov == after_line_cov

    cov = {}

    after_line_cov.each do |lineno, exec_times|
      # no change
      if (before_exec_times = before_line_cov[lineno]) == exec_times
        next
      end

      # execution of previous line number
      if before_exec_times && exec_times
        cov[lineno] = exec_times - before_exec_times
      elsif exec_times
        cov[lineno] = exec_times
      else
        raise "shouldn't get here"
      end
    end

    # add the "diffed" coverage to the hash
    res[file_name] = cov
  end
  ret
end

# File lib/covet.rb, line 178
def self.generate_run_list_for_method(before, after, options = {})
  cov_map = Hash.new { |h, file| h[file] = Hash.new { |i, line| i[line] = [] } }
  after.each do |file, lines_hash|
    file_map = cov_map[file]

    lines_hash.each do |lineno, exec_times|
      # add the test name to the map. Multiple tests can execute the same
      # line, so we need to use an array.
      file_map[lineno] << (options[:method_name] || '???').to_s
    end
  end
  cov_map
end

# File lib/covet.rb, line 44
def self.log_collection
  @log_collection
end

# File lib/covet.rb, line 169
def self.normalize_coverage_info(coverage_info)
  filtered = CollectionFilter.filter(coverage_info)
  CollectionCompressor.compress(filtered)
end

# File lib/covet.rb, line 39
def self.options
  CLI.options || Options::DEFAULTS
end

# File lib/covet.rb, line 122
def self.register_coverage_collection!
  # stdlib Coverage can't run at the same time as CovetCoverage or
  # bad things will happen
  if defined?(Coverage) && !Coverage.respond_to?(:peek_result)
    warn "The 'coverage' library is already loaded. It could cause issues with this library."
    # There's no way to tell if coverage is enabled or not, and
    # if we try stopping the coverage and it's not enabled, it raises
    # a RuntimeError.
    Coverage.stop rescue nil
  end
  CovetCoverage.start # needs to be called before any application code gets required
  Covet::TestRunners.const_get(
    @test_runner.to_s.capitalize
  ).hook_into_test_methods!
  @coverage_collection_registered = true
end

# File lib/covet.rb, line 108
def self.test_directories; @test_directories.dup; end

# File lib/covet.rb, line 98
def self.test_directories=(*dirs)
  dirs = dirs.flatten
  dirs.each do |dir|
    unless Dir.exist?(dir)
      raise Errno::ENOENT, %Q(invalid directory given: "#{dir}" ) +
        %Q{("#{File.join(Dir.pwd, dir)}")}
    end
  end
  @test_directories = dirs
end

# File lib/covet.rb, line 94
def self.test_order; @test_order; end

# File lib/covet.rb, line 87
def self.test_order=(order)
  unless VALID_TEST_ORDERS.include?(order.intern)
    raise ArgumentError, "Invalid test order given. Expected one of " \
      "#{VALID_TEST_ORDERS.map(&:inspect).join(", ")} - #{order.intern.inspect} given"
  end
  @test_order = order
end

# File lib/covet.rb, line 76
def self.test_runner; @test_runner; end

# File lib/covet.rb, line 69
def self.test_runner=(runner)
  @test_runner = runner.intern
  require_relative "covet/test_runners/#{runner}"
rescue LoadError
  raise ArgumentError, "invalid test runner given: '#{runner}'. " \
    "Expected 'rspec' or 'minitest'"
end

# File lib/covet.rb, line 63
def self.vcs; @vcs; end

# File lib/covet.rb, line 57
def self.vcs=(vcs)
  @vcs = vcs.intern
  if @vcs != :git
    raise NotImplementedError, "Can only use git as the VCS for now."
  end
end