class RSpec::Core::Formatters::BaseFormatter

def add_example_group(example_group)
  RSpec.deprecate("add_example_group", "example_group_started")
  example_group_started(example_group)
end

def backtrace_line(line)
  return nil if configuration.cleaned_from_backtrace?(line)
  line.sub!(File.expand_path("."), ".")
  line.sub!(/\A([^:]+:\d+)$/, '\\1')
  return nil if line == '-e:1'
  line
end

def close
end

def color_enabled?
  configuration.color_enabled?
end

def configuration
  RSpec.configuration
end

def dump_failures
end

def dump_pending
end

def dump_summary(duration, example_count, failure_count, pending_count)
end

def example_failed(example)
end

def example_group_started(example_group)
  @example_group = example_group
end

def example_passed(example)
end

def example_pending(example)
end

def example_started(example)
  examples << example
end

def failed_examples
  @failed_examples ||= ::RSpec.world.find(examples, :execution_result => { :status => 'failed' })
end

def failure_count
  failed_examples.size
end

def format_backtrace(backtrace, example)
  return "" unless backtrace
  return backtrace if example.metadata[:full_backtrace] == true
  cleansed = backtrace.select { |line| backtrace_line(line) }
  # Kick the describe stack info off the list, just keep the line the problem happened on from that file
  # cleansed = [cleansed.detect { |line| line.split(':').first == example.metadata[:caller].split(':').first }] if cleansed.size > 1
  cleansed.empty? ? backtrace : cleansed
end

def initialize(output)
  @output = output
  @example_count = 0
  @examples = []
  @example_group = nil
end

def message(message)
end

def output_supports_sync
  output.respond_to?(:sync=)
end

def pending_count
  pending_examples.size
end

def pending_examples
  @pending_examples ||= ::RSpec.world.find(examples, :execution_result => { :status => 'pending' })
end

def profile_examples?
  configuration.profile_examples
end

def read_failed_line(exception, example)
  original_file = example.file_path.to_s.downcase
  matching_line = exception.backtrace.detect { |line| line.split(':').first.downcase == original_file.downcase }
  return "Unable to find matching line from backtrace" if matching_line.nil?
  file_path, line_number = matching_line.split(':')
  if File.exist?(file_path)
    open(file_path, 'r') { |f| f.readlines[line_number.to_i - 1] }
  else
    "Unable to find #{file_path} to read failed line"
  end
end

def report(count)
  sync_output do
    start(count)
    begin
      yield self
      stop
      start_dump
      dump_summary(duration, example_count, failure_count, pending_count)
      dump_pending
      dump_failures
    ensure
      close
    end
  end
end

def start(example_count)
  @example_count = example_count
  @start = Time.now
end

def start_dump
end

def stop
  @duration = Time.now - @start
end

def sync_output
  begin
    old_sync, output.sync = output.sync, true if output_supports_sync
    yield
  ensure
    output.sync = old_sync if output_supports_sync and !output.closed?
  end
end