learn-xcpretty 0.1.11

data/lib/xcpretty/formatters/formatter.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+require 'xcpretty/ansi'
+require 'xcpretty/parser'
+
+module XCPretty
+
+  # Making a new formatter is easy.
+  # Just make a subclass of Formatter, and override any of these methods.
+  module FormatMethods
+    EMPTY = ''.freeze
+
+    def format_analyze(file_name, file_path);                 EMPTY; end
+    def format_build_target(target, project, configuration);  EMPTY; end
+    def format_check_dependencies;                            EMPTY; end
+    def format_clean(project, target, configuration);         EMPTY; end
+    def format_clean_target(target, project, configuration);  EMPTY; end
+    def format_clean_remove;                                  EMPTY; end
+    def format_compile(file_name, file_path);                 EMPTY; end
+    def format_compile_command(compiler_command);             EMPTY; end
+    def format_compile_xib(file_name, file_path);             EMPTY; end
+    def format_copy_strings_file(file_name);                  EMPTY; end
+    def format_cpresource(file);                              EMPTY; end
+    def format_generate_dsym(dsym);                           EMPTY; end
+    def format_linking(file, build_variant, arch);            EMPTY; end
+    def format_libtool(library);                              EMPTY; end
+    def format_passing_test(suite, test, time);               EMPTY; end
+    def format_pending_test(suite, test);                     EMPTY; end
+    def format_failing_test(suite, test, time, file_path);    EMPTY; end
+    def format_process_pch(file);                             EMPTY; end
+    def format_phase_script_execution(script_name);           EMPTY; end
+    def format_process_info_plist(file_name, file_path);      EMPTY; end
+    def format_codesign(file);                                EMPTY; end
+    def format_preprocess(file);                              EMPTY; end
+    def format_pbxcp(file);                                   EMPTY; end
+    def format_test_run_started(name);                        EMPTY; end
+    def format_test_run_finished(name, time);                 EMPTY; end
+    def format_test_suite_started(name);                      EMPTY; end
+    def format_test_summary(message, failures_per_suite);     EMPTY; end
+    def format_touch(file_path, file_name);                   EMPTY; end
+    def format_tiffutil(file);                                EMPTY; end
+
+    # COMPILER / LINKER ERRORS
+    def format_compile_error(file_name, file_path, reason,
+                             line, cursor);                   EMPTY; end
+    def format_error(message);                                EMPTY; end
+    def format_undefined_symbols(message, symbol, reference); EMPTY; end
+    def format_duplicate_symbols(message, file_paths);        EMPTY; end
+  end
+
+  class Formatter
+
+    include ANSI
+    include FormatMethods
+
+    attr_reader :parser
+
+    def initialize(use_unicode, colorize)
+      @use_unicode = use_unicode
+      @colorize = colorize
+      @parser = Parser.new(self)
+    end
+
+    # Override if you want to catch something specific with your regex
+    def pretty_format(text)
+      parser.parse(text)
+    end
+
+    # If you want to print inline, override #optional_newline with ''
+    def optional_newline
+      "\n"
+    end
+
+    def use_unicode?
+      !!@use_unicode
+    end
+
+    # Will be printed by default. Override with '' if you don't want summary
+    def format_test_summary(executed_message, failures_per_suite)
+      failures = format_failures(failures_per_suite)
+      final_message = failures.empty? ? green(executed_message) : red(executed_message)
+
+      text = [failures, final_message].join("\n\n\n").strip
+      "\n\n#{text}"
+    end
+
+    ERROR = "⌦"
+    ASCII_ERROR = "[!]"
+
+    def format_error(message)
+      "\n#{red(error_symbol + " " + message)}\n\n"
+    end
+
+    def format_compile_error(file, file_path, reason, line, cursor)
+      "\n#{red(error_symbol + " ")}#{file_path}: #{red(reason)}\n\n" +
+      "#{line}\n#{cyan(cursor)}\n\n"
+    end
+
+    def format_undefined_symbols(message, symbol, reference)
+      "\n#{red(error_symbol + " " + message)}\n" +
+      "> Symbol: #{symbol}\n" +
+      "> Referenced from: #{reference}\n\n"
+    end
+
+    def format_duplicate_symbols(message, file_paths)
+      "\n#{red(error_symbol + " " + message)}\n" +
+      "> #{file_paths.map { |path| path.split('/').last }.join("\n> ")}\n"
+    end
+
+
+    private
+
+    def format_failures(failures_per_suite)
+      failures_per_suite.map do |suite, failures|
+        formatted_failures = failures.map do |failure|
+          format_failure(failure)
+        end.join("\n\n")
+
+        "\n#{suite}\n#{formatted_failures}"
+      end.join("\n")
+    end
+
+    def format_failure(f)
+      "  #{f[:test_case]}, #{red(f[:reason])}\n  #{cyan(f[:file_path])}\n" +
+      "  ```\n" +
+      Syntax.highlight(Snippet.from_filepath(f[:file_path])) +
+      "  ```"
+    end
+
+    def error_symbol
+      use_unicode? ? ERROR : ASCII_ERROR
+    end
+
+  end
+end

data/lib/xcpretty/formatters/knock.rb

@@ -0,0 +1,34 @@
+module XCPretty
+
+  class Knock < Formatter
+
+    FAIL = 'not ok'
+    PASS = 'ok'
+
+    def format_passing_test(suite, test_case, time)
+      "#{PASS} - #{test_case}"
+    end
+
+    def format_failing_test(test_suite, test_case, reason, file)
+      "#{FAIL} - #{test_case}: FAILED" +
+      format_failure_diagnostics(test_suite, test_case, reason, file)
+    end
+
+    def format_test_summary(executed_message, failures_per_suite)
+      ''
+    end
+
+    def format_failure_diagnostics(test_suite, test_case, reason, file)
+      format_diagnostics(reason) +
+      format_diagnostics("  #{file}: #{test_suite} - #{test_case}")
+    end
+
+    private
+
+    def format_diagnostics(text)
+      "\n# #{text}"
+    end
+
+  end
+
+end

data/lib/xcpretty/formatters/rspec.rb

@@ -0,0 +1,27 @@
+module XCPretty
+
+  class RSpec < Formatter
+
+    FAIL = "F"
+    PASS = "."
+    PENDING = "P"
+
+    def optional_newline
+      ''
+    end
+
+    def format_passing_test(suite, test_case, time)
+      green(PASS)
+    end
+
+    def format_failing_test(test_suite, test_case, reason, file)
+      red(FAIL)
+    end
+
+    def format_pending_test(suite, test_case)
+      yellow(PENDING)
+    end
+
+  end
+
+end

data/lib/xcpretty/formatters/simple.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+require 'shellwords'
+
+module XCPretty
+
+  class Simple < Formatter
+
+    PASS = "✓"
+    FAIL = "✗"
+    PENDING = "⧖"
+
+    ASCII_PASS = "."
+    ASCII_FAIL = "x"
+    COMPLETION = "▸"
+    ASCII_PENDING = "P"
+    ASCII_COMPLETION = ">"
+
+    INDENT = "    "
+
+    def format_analyze(file_name, file_path)
+      format("Analyzing", file_name)
+    end
+
+    def format_build_target(target, project, configuration)
+      format("Building", "#{project}/#{target} [#{configuration}]")
+    end
+
+    def format_clean_target(target, project, configuration)
+      format("Cleaning", "#{project}/#{target} [#{configuration}]")
+    end
+
+    def format_compile(file_name, file_path)
+      format("Compiling", file_name)
+    end
+
+    def format_compile_xib(file_name, file_path)
+      format("Compiling", file_name)
+    end
+
+    def format_copy_strings_file(file)
+      format("Copying", file)
+    end
+
+    def format_cpresource(resource)
+      format("Copying", resource)
+    end
+
+    def format_generate_dsym(dsym)
+      format("Generating '#{dsym}'")
+    end
+
+    def format_libtool(library)
+      format("Building library", library)
+    end
+
+    def format_linking(target, build_variants, arch)
+      format("Linking", target)
+    end
+
+    def format_failing_test(suite, test_case, reason, file)
+      INDENT + format_test("#{test_case}, #{reason}", :fail)
+    end
+
+    def format_passing_test(suite, test_case, time)
+      INDENT + format_test("#{test_case} (#{colored_time(time)} seconds)", :pass)
+    end
+
+    def format_pending_test(suite, test_case)
+      INDENT + format_test("#{test_case} [PENDING]", :pending)
+    end
+
+    def format_phase_script_execution(script_name)
+      format("Running script", "'#{script_name}'")
+    end
+
+    def format_process_info_plist(file_name, file_path)
+      format("Processing", file_name)
+    end
+
+    def format_process_pch(file)
+      format("Precompiling", file)
+    end
+
+    def format_codesign(file)
+      format("Signing", file)
+    end
+
+    def format_preprocess(file)
+      format("Preprocessing", file)
+    end
+
+    def format_pbxcp(file)
+      format("Copying", file)
+    end
+
+    def format_test_run_started(name)
+      heading("Test Suite", name, "started")
+    end
+
+    def format_test_suite_started(name)
+      heading("", name, "")
+    end
+
+    def format_touch(file_path, file_name)
+      format("Touching", file_name)
+    end
+
+    def format_tiffutil(file_name)
+      format("Validating", file_name)
+    end
+
+    private
+
+    def heading(prefix, text, description)
+      [prefix, white(text), description].join(" ").strip
+    end
+
+    def format(command, argument_text="", success=true)
+      [status_symbol(success ? :completion : :fail), white(command), argument_text].join(" ").strip
+    end
+
+    def format_test(test_case, status)
+      [status_symbol(status), test_case].join(" ").strip
+    end
+
+    def status_symbol(status)
+      case status
+      when :pass
+        green(use_unicode? ? PASS : ASCII_PASS)
+      when :fail
+        red(use_unicode? ? FAIL : ASCII_FAIL)
+      when :pending
+        yellow(use_unicode? ? PENDING : ASCII_PENDING)
+      when :error
+        red(use_unicode? ? ERROR : ASCII_ERROR)
+      when :completion
+        yellow(use_unicode? ? COMPLETION : ASCII_COMPLETION)
+      else
+        ""
+      end
+    end
+
+    def colored_time(time)
+      case time.to_f
+      when 0..0.025
+        time
+      when 0.026..0.100
+        yellow(time)
+      else
+        red(time)
+      end
+    end
+
+  end
+end

data/lib/xcpretty/formatters/tap.rb

@@ -0,0 +1,39 @@
+module XCPretty
+
+  class TestAnything < Knock
+
+    attr_reader :counter
+
+    def initialize unicode, color
+      super
+      @counter = 0
+    end
+
+    def format_passing_test(suite, test_case, time)
+      increment_counter
+      "#{PASS} #{counter} - #{test_case}"
+    end
+
+    def format_failing_test(test_suite, test_case, reason, file)
+      increment_counter
+      "#{FAIL} #{counter} - #{test_case}" +
+      format_failure_diagnostics(test_suite, test_case, reason, file)
+    end
+
+    def format_pending_test(test_suite, test_case)
+      increment_counter
+      "#{FAIL} #{counter} - #{test_case} # TODO Not written yet"
+    end
+
+    def format_test_summary(executed_message, failures_per_suite)
+      counter > 0 ? "1..#{counter}" : ''
+    end
+
+    private
+
+    def increment_counter
+      @counter += 1
+    end
+  end
+
+end

data/lib/xcpretty/parser.rb

@@ -0,0 +1,421 @@
+module XCPretty
+
+  module Matchers
+
+    # @regex Captured groups
+    # $1 file_path
+    # $2 file_name
+    ANALYZE_MATCHER = /^Analyze(?:Shallow)?\s(.*\/(.*\.m))*/
+
+    # @regex Captured groups
+    # $1 target
+    # $2 project
+    # $3 configuration
+    BUILD_TARGET_MATCHER = /^=== BUILD TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH.*CONFIGURATION\s(.*)\s===/
+
+    # @regex Nothing returned here for now
+    CHECK_DEPENDENCIES_MATCHER = /^Check dependencies/
+
+    # @regex Nothing returned here for now
+    CLEAN_REMOVE_MATCHER = /^Clean.Remove/
+
+    # @regex Captured groups
+    # $1 target
+    # $2 project
+    # $3 configuration
+    CLEAN_TARGET_MATCHER = /^=== CLEAN TARGET\s(.*)\sOF PROJECT\s(.*)\sWITH CONFIGURATION\s(.*)\s===/
+
+    # @regex Captured groups
+    # $1 = file
+    CODESIGN_MATCHER = /^CodeSign\s((?:\\ |[^ ])*)$/
+
+    # @regex Captured groups
+    # $1 = file
+    CODESIGN_FRAMEWORK_MATCHER = /^CodeSign\s((?:\\ |[^ ])*.framework)\/Versions/
+
+    # @regex Captured groups
+    # $1 file_path
+    # $2 file_name (e.g. KWNull.m)
+    COMPILE_MATCHER = /^CompileC\s.*\s(.*\/(.*\.(?:m|mm|c|cc|cpp|cxx)))\s.*/
+
+    # @regex Captured groups
+    # $1 compiler_command
+    COMPILE_COMMAND_MATCHER = /^\s*(.*\/usr\/bin\/clang\s.*\.o)$/
+
+    # @regex Captured groups
+    # $1 file_path
+    # $2 file_name (e.g. MainMenu.xib)
+    COMPILE_XIB_MATCHER = /^CompileXIB\s(.*\/(.*\.xib))/
+
+    # @regex Captured groups
+    # $1 file
+    COPY_STRINGS_MATCHER = /^CopyStringsFile.*\/(.*.strings)/
+
+    # @regex Captured groups
+    # $1 resource
+    CPRESOURCE_MATCHER = /^CpResource\s(.*)\s\//
+
+    # @regex Captured groups
+    #
+    EXECUTED_MATCHER = /^\s*Executed/
+
+    # @regex Captured groups
+    # $1 = file
+    # $2 = test_suite
+    # $3 = test_case
+    # $4 = reason
+    FAILING_TEST_MATCHER = /^\s*(.+:\d+):\serror:\s[\+\-]\[(.*)\s(.*)\]\s:(?:\s'.*'\s\[FAILED\],)?\s(.*)/
+
+    # @regex Captured groups
+    # $1 = dsym
+    GENERATE_DSYM_MATCHER = /^GenerateDSYMFile \/.*\/(.*\.dSYM)/
+
+    # @regex Captured groups
+    # $1 = library
+    LIBTOOL_MATCHER = /^Libtool.*\/(.*\.a)/
+
+    # @regex Captured groups
+    # $1 = target
+    # $2 = build_variants (normal, profile, debug)
+    # $3 = architecture
+    LINKING_MATCHER = /^Ld \/.*\/(.*) (.*) (.*)$/
+
+    # @regex Captured groups
+    # $1 = suite
+    # $2 = test_case
+    # $3 = time
+    PASSING_TEST_MATCHER = /^\s*Test Case\s'-\[(.*)\s(.*)\]'\spassed\s\((\d*\.\d{3})\sseconds\)/
+
+    # @regex Captured groups
+    # $1 = suite
+    # $2 = test_case
+    PENDING_TEST_MATCHER = /^Test Case\s'-\[(.*)\s(.*)PENDING\]'\spassed/
+
+    # @regex Captured groups
+    # $1 = script_name
+    PHASE_SCRIPT_EXECUTION_MATCHER = /^PhaseScriptExecution\s(.*)\s\//
+
+    # @regex Captured groups
+    # $1 = file
+    PROCESS_PCH_MATCHER = /^ProcessPCH\s.*\s(.*.pch)/
+
+    # @regex Captured groups
+    # $1 = file
+    PREPROCESS_MATCHER = /^Preprocess\s(?:(?:\\ |[^ ])*)\s((?:\\ |[^ ])*)$/
+
+    # @regex Captured groups
+    # $1 = file
+    PBXCP_MATCHER = /^PBXCp\s((?:\\ |[^ ])*)/
+
+    # @regex Captured groups
+    # $1 = file
+    PROCESS_INFO_PLIST_MATCHER = /^ProcessInfoPlistFile\s.*\.plist\s(.*\/+(.*\.plist))/
+
+    # @regex Captured groups
+    # $1 = suite
+    # $2 = time
+    TESTS_RUN_COMPLETION_MATCHER = /^\s*Test Suite '(?:.*\/)?(.*[ox]ctest.*)' finished at (.*)/
+
+    # @regex Captured groups
+    # $1 = suite
+    # $2 = time
+    TESTS_RUN_START_MATCHER = /^\s*Test Suite '(?:.*\/)?(.*[ox]ctest.*)' started at(.*)/
+
+    # @regex Captured groups
+    # $1 test suite name
+    TEST_SUITE_START_MATCHER = /^\s*Test Suite '(.*)' started at/
+
+    # @regex Captured groups
+    # $1 file_name
+    TIFFUTIL_MATCHER = /^TiffUtil\s(.*)/
+
+    # @regex Captured groups
+    # $1 file_path
+    # $2 file_name
+    TOUCH_MATCHER = /^Touch\s(.*\/([\w+\.]+))/
+
+    module Errors
+      # @regex Captured groups
+      # $1 = whole error
+      CLANG_ERROR_MATCHER = /^(clang: error:.*)$/
+
+      # @regex Captured groups
+      # $1 = whole error
+      CODESIGN_ERROR_MATCHER = /^(Code\s?Sign error:.*)$/
+
+      # @regex Captured groups
+      # $1 = file_path
+      # $2 = file_name
+      # $3 = reason
+      COMPILE_ERROR_MATCHER = /^(\/.+\/(.*):.*:.*):(?:\sfatal)?\serror:\s(.*)$/
+
+      # @regex Captured groups
+      # $1 cursor (with whitespaces and tildes)
+      CURSOR_MATCHER = /^([\s~]*\^[\s~]*)$/
+
+      # @regex Captured groups
+      # $1 = whole error.
+      #      it varies a lot, not sure if it makes sense to catch everything separately
+      FATAL_ERROR_MATCHER = /^(fatal error:.*)$/
+
+      # @regex Captured groups
+      # $1 = whole error
+      LD_ERROR_MATCHER = /^(ld:.*not found for.*)/
+
+      # @regex Captured groups
+      # $1 file path
+      LINKER_DUPLICATE_SYMBOLS_LOCATION_MATCHER = /^\s+(\/.*\.o[\)]?)$/
+
+      # @regex Captured groups
+      # $1 reason
+      LINKER_DUPLICATE_SYMBOLS_MATCHER = /^(duplicate symbol .*):$/
+
+      # @regex Captured groups
+      # $1 symbol location
+      LINKER_UNDEFINED_SYMBOL_LOCATION_MATCHER = /^(.* in .*\.o)$/
+
+      # @regex Captured groups
+      # $1 reason
+      LINKER_UNDEFINED_SYMBOLS_MATCHER = /^(Undefined symbols for architecture .*):$/
+
+      # @regex Captured groups
+      PODS_ERROR_MATCHER = /^error:\s(.*)/
+
+      # @regex Captured groups
+      # $1 = reference
+      SYMBOL_REFERENCED_FROM_MATCHER = /\s+"(.*)", referenced from:$/
+    end
+  end
+
+  class Parser
+
+    include Matchers
+    include Matchers::Errors
+
+    attr_reader :formatter
+
+    def initialize(formatter)
+      @formatter = formatter
+    end
+
+    def parse(text)
+      update_test_state(text)
+      update_error_state(text)
+      update_linker_failure_state(text)
+
+      return format_compile_error if should_format_error?
+      return format_undefined_symbols if should_format_undefined_symbols?
+      return format_duplicate_symbols if should_format_duplicate_symbols?
+
+      case text
+      when ANALYZE_MATCHER
+        formatter.format_analyze($2, $1)
+      when BUILD_TARGET_MATCHER
+        formatter.format_build_target($1, $2, $3)
+      when CLEAN_REMOVE_MATCHER
+        formatter.format_clean_remove
+      when CLEAN_TARGET_MATCHER
+        formatter.format_clean_target($1, $2, $3)
+      when COPY_STRINGS_MATCHER
+        formatter.format_copy_strings_file($1)
+      when CHECK_DEPENDENCIES_MATCHER
+        formatter.format_check_dependencies
+      when CLANG_ERROR_MATCHER
+        formatter.format_error($1)
+      when CODESIGN_FRAMEWORK_MATCHER
+        formatter.format_codesign($1)
+      when CODESIGN_MATCHER
+        formatter.format_codesign($1)
+      when CODESIGN_ERROR_MATCHER
+        formatter.format_error($1)
+      when COMPILE_MATCHER
+        formatter.format_compile($2, $1)
+      when COMPILE_COMMAND_MATCHER
+        formatter.format_compile_command($1)
+      when COMPILE_XIB_MATCHER
+        formatter.format_compile_xib($2, $1)
+      when CPRESOURCE_MATCHER
+        formatter.format_cpresource($1)
+      when EXECUTED_MATCHER
+        format_summary_if_needed(text)
+      when FAILING_TEST_MATCHER
+        formatter.format_failing_test($2, $3, $4, $1)
+      when FATAL_ERROR_MATCHER
+        formatter.format_error($1)
+      when GENERATE_DSYM_MATCHER
+        formatter.format_generate_dsym($1)
+      when LD_ERROR_MATCHER
+        formatter.format_error($1)
+      when LIBTOOL_MATCHER
+        formatter.format_libtool($1)
+      when LINKING_MATCHER
+        formatter.format_linking($1, $2, $3)
+      when PENDING_TEST_MATCHER
+        formatter.format_pending_test($1, $2)
+      when PASSING_TEST_MATCHER
+        formatter.format_passing_test($1, $2, $3)
+      when PODS_ERROR_MATCHER
+        formatter.format_error($1)
+      when PROCESS_INFO_PLIST_MATCHER
+        formatter.format_process_info_plist(*unescaped($2, $1))
+      when PHASE_SCRIPT_EXECUTION_MATCHER
+        formatter.format_phase_script_execution(*unescaped($1))
+      when PROCESS_PCH_MATCHER
+        formatter.format_process_pch($1)
+      when PREPROCESS_MATCHER
+        formatter.format_preprocess($1)
+      when PBXCP_MATCHER
+        formatter.format_pbxcp($1)
+      when TESTS_RUN_COMPLETION_MATCHER
+        formatter.format_test_run_finished($1, $2)
+      when TESTS_RUN_START_MATCHER
+        formatter.format_test_run_started($1)
+      when TEST_SUITE_START_MATCHER
+        formatter.format_test_suite_started($1)
+      when TIFFUTIL_MATCHER
+        formatter.format_tiffutil($1)
+      when TOUCH_MATCHER
+        formatter.format_touch($1, $2)
+      else
+        ""
+      end
+    end
+
+    private
+
+    def update_test_state(text)
+      case text
+      when TESTS_RUN_START_MATCHER
+        @tests_done = false
+        @formatted_summary = false
+        @failures = {}
+      when TESTS_RUN_COMPLETION_MATCHER
+        @tests_done = true
+      when FAILING_TEST_MATCHER
+        store_failure($1, $2, $3, $4)
+      end
+    end
+
+    # @ return Hash { :file_name, :file_path, :reason, :line }
+    def update_error_state(text)
+      if text =~ COMPILE_ERROR_MATCHER
+        @formatting_error = true
+        current_error[:reason]    = $3
+        current_error[:file_path] = $1
+        current_error[:file_name] = $2
+      elsif text =~ CURSOR_MATCHER
+        @formatting_error = false
+        current_error[:cursor]    = $1.chomp
+      elsif @formatting_error
+        current_error[:line]      = text.chomp
+      end
+    end
+
+    def update_linker_failure_state(text)
+      if text =~ LINKER_UNDEFINED_SYMBOLS_MATCHER ||
+         text =~ LINKER_DUPLICATE_SYMBOLS_MATCHER
+
+        current_linker_failure[:message] = $1
+        @formatting_linker_failure = true
+      end
+      return unless @formatting_linker_failure
+
+      case text
+      when SYMBOL_REFERENCED_FROM_MATCHER
+        current_linker_failure[:symbol] = $1
+      when LINKER_UNDEFINED_SYMBOL_LOCATION_MATCHER
+        current_linker_failure[:reference] = text.strip
+      when LINKER_DUPLICATE_SYMBOLS_LOCATION_MATCHER
+        current_linker_failure[:files] << $1
+      end
+    end
+
+    # TODO: clean up the mess around all this
+    def should_format_error?
+      current_error[:reason] && current_error[:cursor] && current_error[:line]
+    end
+
+    def should_format_undefined_symbols?
+      current_linker_failure[:message]     &&
+      current_linker_failure[:symbol]      &&
+      current_linker_failure[:reference]
+    end
+
+    def should_format_duplicate_symbols?
+      current_linker_failure[:message]     &&
+      current_linker_failure[:files].count > 1
+    end
+
+    def current_error
+      @current_error ||= {}
+    end
+
+    def current_linker_failure
+      @linker_failure ||= { :files => [] }
+    end
+
+    def format_compile_error
+      error = current_error.dup
+      @current_error = {}
+      formatter.format_compile_error(error[:file_name],
+                                     error[:file_path],
+                                     error[:reason],
+                                     error[:line],
+                                     error[:cursor])
+    end
+
+    def format_undefined_symbols
+      result = formatter.format_undefined_symbols(
+        current_linker_failure[:message],
+        current_linker_failure[:symbol],
+        current_linker_failure[:reference]
+      )
+      reset_linker_format_state
+      result
+    end
+
+    def format_duplicate_symbols
+      result = formatter.format_duplicate_symbols(
+        current_linker_failure[:message],
+        current_linker_failure[:files]
+      )
+      reset_linker_format_state
+      result
+    end
+
+    def reset_linker_format_state
+      @linker_failure = nil
+      @formatting_linker_failure = false
+    end
+
+    def store_failure(file, test_suite, test_case, reason)
+      failures_per_suite[test_suite] ||= []
+      failures_per_suite[test_suite] << {
+        :file_path => file,
+        :reason => reason,
+        :test_case => test_case
+      }
+    end
+
+    def failures_per_suite
+      @failures ||= {}
+    end
+
+    def format_summary_if_needed(executed_message)
+      return "" unless should_format_summary?
+
+      @formatted_summary = true
+      formatter.format_test_summary(executed_message, failures_per_suite)
+    end
+
+    def should_format_summary?
+      @tests_done && !@formatted_summary
+    end
+
+    def unescaped(*escaped_values)
+      escaped_values.map { |v| v.gsub('\\', '') }
+    end
+
+  end
+end
+