class Rspec::Core::Formatters::BaseFormatter

def add_example_group(example_group)
  @example_group = 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(duration)
  start_dump(duration)
  dump_failures
  dump_summary
  dump_pending
end

def dump_failures
end

def dump_pending
end

def dump_summary
end

def example_finished(example)
  examples << example
end

def failed_examples
  @failed_examples ||= ::Rspec::Core.world.find(examples, :execution_result => { :status => 'failed' })
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
  @example_count = 0
  @examples = []
  @example_group = nil
end

def output
  configuration.output
end

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

def pending_examples
  @pending_examples ||= ::Rspec::Core.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)
    # TODO - spec that we still dump even when there's
    # an exception
    begin
      yield self
    ensure
      stop
      dump(@duration)
      close
    end
  end
end

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

def start_dump(duration)
  @duration = duration
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
  end
end