xcpretty-bb 0.1.12.bb1

data/features/steps/json_steps.rb

@@ -0,0 +1,37 @@
+Given(/^some big input$/) do
+  add_run_input File.open('features/fixtures/xcodebuild.log', 'r').read
+end
+
+Then(/^I should have a JSON compilation database in a custom path$/) do
+  step("I should have a JSON compilation database at \"#{custom_report_path}\"")
+end
+
+Then(/^I should have a JSON compilation database at "(.*?)"$/) do |path|
+  json = JSON.parse(File.open(path, 'r').read)
+  json.should_not be_nil
+end
+
+Then(/^I should have JSON compilation databases in two custom paths$/) do
+  step("I should have a JSON compilation database at \"#{custom_report_path}\"")
+  step("I should have a JSON compilation database at \"#{other_custom_report_path}\"")
+end
+
+Then(/^the JSON compilation database should contain an entry with a command$/) do
+  json_db.length.should == 1
+  json_db[0]['command'].should start_with('/Applications/Xcode.app/Contents/Developer')
+  json_db[0]['command'].should end_with('.o')
+end
+
+Then(/^the JSON compilation database should contain an entry with a file$/) do
+  json_db[0]['file'].should == '/Users/musalj/code/OSS/ObjectiveSugar/Classes/NSMutableArray+ObjectiveSugar.m'
+end
+
+Then(/^the JSON compilation database should contain an entry with a directory$/) do
+  json_db[0]['directory'].should == '/'
+end
+
+Then(/^the JSON compilation database should be complete$/) do
+  entries = json_db.select { |entry| entry['command'] && entry['file'] && entry['directory'] }
+  entries.length.should == JSON_DB_FIXTURE_COMMAND_COUNT
+end
+

data/features/steps/junit_steps.rb

@@ -0,0 +1,39 @@
+Then(/^I should see a failed test node in my report$/) do
+  junit_report_root.elements.to_a.detect do |node|
+    element = node.elements.to_a.first
+    element && element.name == "failure"
+  end.should_not be_nil
+end
+
+Then(/^I should see a passing test node in my report$/) do
+  junit_report_root.elements.to_a.detect do |node|
+    node.attributes["time"] != nil
+  end.should_not be_nil
+end
+
+Then(/^I should see a pending test node in my report$/) do
+  junit_report_root.elements.to_a.detect do |node|
+    node.elements.to_a.detect { |child| child.name == 'skipped' }
+  end.should_not be_nil
+end
+
+Then(/^I should see a test suite node$/) do
+  junit_report_root.elements.to_a.first.should_not be_nil
+end
+
+Then(/^I should see (\d+) tests in my report$/) do |test_count|
+  junit_report_root.attributes["tests"].should == test_count
+  junit_report_root.elements.to_a.size.should == test_count.to_i
+end
+
+Then(/^I should see (\d+) test suites$/) do |count|
+  suites = junit_report.root.elements.to_a
+  suites.size.should == count.to_i
+  suites.count { |s| s.name == 'testsuite' }.should == count.to_i
+end
+
+Then(/^I should have a test report at "(.*?)"$/) do |path|
+  doc = REXML::Document.new(File.open(path, 'r').read)
+  doc.root.should_not be_nil
+end
+

data/features/steps/report_steps.rb

@@ -0,0 +1,22 @@
+Given(/^I have tests in my suite from 2 classes$/) do
+  add_run_input SAMPLE_OCUNIT_TEST
+  add_run_input SAMPLE_KIWI_TEST
+end
+
+When(/^I pipe to xcpretty with "(.*?)" and specify a custom path$/) do |args|
+  step("I pipe to xcpretty with \"#{args} --output #{custom_report_path}\"")
+end
+
+When(/^I pipe to xcpretty with two custom "(.*?)" report paths$/) do |type|
+  step("I pipe to xcpretty with \"--report #{type} --output #{custom_report_path} --report #{type} --output #{other_custom_report_path}\"")
+end
+
+Then(/^I should have test reports in two custom paths$/) do
+  step("I should have a test report at \"#{custom_report_path}\"")
+  step("I should have a test report at \"#{other_custom_report_path}\"")
+end
+
+Then(/^I should have a test report in a custom path$/) do
+  step("I should have a test report at \"#{custom_report_path}\"")
+end
+

data/features/steps/xcpretty_steps.rb

@@ -0,0 +1,31 @@
+When(/^I run xcpretty$/) do
+  @output = `bin/xcpretty 2>&1`
+end
+
+When(/^I run xcpretty with (.*)$/) do |flags|
+  @output = `bin/xcpretty #{flags}`
+end
+
+When(/^I run xcpretty over a big file$/) do
+  start_time = Time.now
+  @output = `cat features/fixtures/xcodebuild.log | bin/xcpretty -c`
+  @xcpretty_run_time = Time.now - start_time
+end
+
+Then(/^I should see the help banner$/) do
+  run_output.should include("Usage: xcodebuild [options] | xcpretty")
+end
+
+Then(/^I should see the xcpretty version$/) do
+  run_output.should include(XCPretty::VERSION)
+end
+
+Then(/^the exit status code should be (\d)$/) do |numbah|
+  $?.exitstatus.should == numbah.to_i
+end
+
+Then(/^the performance should be way faster than running cat$/) do
+  puts "XCPretty run time: #{@xcpretty_run_time}"
+  @xcpretty_run_time.should < 2
+end
+

data/features/support/env.rb

@@ -0,0 +1,117 @@
+$LOAD_PATH.unshift File.expand_path('../../..', __FILE__)
+
+require 'tempfile'
+require 'spec/fixtures/constants'
+require 'spec/support/matchers/colors'
+require 'lib/xcpretty/ansi'
+require 'lib/xcpretty/version'
+require 'lib/xcpretty/syntax'
+require 'rexml/document'
+require 'lib/xcpretty/formatters/formatter'
+require 'lib/xcpretty/reporters/junit'
+require 'lib/xcpretty/reporters/html'
+require 'lib/xcpretty/reporters/json_compilation_database'
+
+begin
+  require 'json'
+rescue LoadError
+  require 'vendor/json_pure/parser'
+end
+
+include XCPretty::ANSI
+
+TEST_RUN_START_MATCHER = /Test Suite .+ started/
+TEST_SUITE_COMPLETION_MATCHER = /Executed \d+ tests, with \d+ failures \(\d+ unexpected\) in \d+\.\d+ \(\d+\.\d+\) seconds/
+TEST_SUITE_START_MATCHER = /[\w]*(Spec|Tests)$/
+TEST_PATH_MATCHER = %r{[\w/\-\s]+:\d+}
+PASSING_TEST_NAME_MATCHER = %r{\w+\s\(\d+\.\d+\sseconds\)}
+PENDING_TEST_NAME_MATCHER = %r{\w+\s\[PENDING\]}
+FAILING_TEST_NAME_MATCHER = %r{\w+, expected:}
+MEASURING_TEST_NAME_MATCHER = %r{\w+\smeasured\s\(\d+\.\d+\sseconds\)}
+
+JSON_DB_FIXTURE_COMMAND_COUNT = 557
+
+def run_xcpretty(flags)
+  input_file = Tempfile.new('xcpretty_input')
+  File.open(input_file.path, 'w') do |file|
+    file.print run_input
+  end
+  @output = %x(cat '#{input_file.path}' | bin/xcpretty #{flags})
+  input_file.unlink
+end
+
+def add_run_input(text)
+  run_input << "\n#{text}"
+end
+
+def run_input
+  @input ||= ''
+end
+
+def run_output
+  @output ||= ''
+end
+
+def html_report
+  @html_report ||= REXML::Document.new(File.open(XCPretty::HTML::FILEPATH, 'r').read.sub("<!DOCTYPE html>", ""))
+end
+
+def html_report_body
+  html_report.root.get_elements('//body').first
+end
+
+def html_test_suites
+  parent = html_report_body.get_elements("//*[@id='test-suites']/").first
+  parent.elements.to_a.select do |e|
+    e.attributes['class'] && e.attributes['class'].include?('test-suite')
+  end
+end
+
+def json_db
+  @json ||= JSON.parse(File.open(custom_report_path, 'r').read)
+end
+
+def junit_report
+  REXML::Document.new(File.open(XCPretty::JUnit::FILEPATH, 'r').read)
+end
+
+def junit_report_root
+  junit_report.root.elements.to_a.first
+end
+
+def custom_report_path
+  @custom_report_path ||= begin
+    @custom_report_file1 = Tempfile.new('custom_report_path')
+    @custom_report_file1.path
+  end
+end
+
+def other_custom_report_path
+  @custom_report_path2 ||= begin
+    @custom_report_file2 = Tempfile.new('custom_report_path')
+    @custom_report_file2.path
+  end
+end
+
+def copy_file_to_screenshot_dir(screenshot_file)
+  @screenshot_file_path = "#{XCPretty::HTML::SCREENSHOT_DIR}/#{screenshot_file}"
+  FileUtils.cp("features/assets/#{screenshot_file}", @screenshot_file_path)
+end
+
+Before do
+  self.colorize = true
+end
+
+After do
+  @input  = ""
+  @output = ""
+  @custom_report_file1.unlink if @custom_report_file1
+  @custom_report_file2.unlink if @custom_report_file2
+  @html_report = nil
+  @json = nil
+  FileUtils.rm_rf(XCPretty::JUnit::FILEPATH)
+  FileUtils.rm_rf(XCPretty::HTML::FILEPATH)
+  FileUtils.rm_rf(XCPretty::JSONCompilationDatabase::FILE_PATH)
+  File.delete(@screenshot_file_path) if @screenshot_file_path
+end
+

data/features/tap_format.feature

@@ -0,0 +1,31 @@
+Feature: Showing Test Anything Protocol-compatible test output
+
+    Scenario: Showing failed tests
+        Given I have a failing test in my suite
+        When I pipe to xcpretty with "--tap"
+        Then I should see text beginning with "not ok 1"
+
+    Scenario: Showing passing tests
+        Given I have a passing test in my suite
+        When I pipe to xcpretty with "--tap"
+        Then I should see text beginning with "ok 1"
+
+    Scenario: Showing pending tests
+        Given I have a pending test in my suite
+        When I pipe to xcpretty with "--tap"
+        Then I should see text containing " # TODO" and beginning with "not ok 1"
+
+    Scenario: Showing how many tests completed
+        Given I have a pending test in my suite
+        And I have a passing test in my suite
+        And I have a failing test in my suite
+        And the test suite has finished
+        When I pipe to xcpretty with "--tap"
+        Then I should see text matching "1..3"
+
+    Scenario: Showing a running test counter
+        Given I have a passing test in my suite
+        And I have a failing test in my suite
+        When I pipe to xcpretty with "--tap"
+        Then I should see text beginning with "ok 1"
+        And I should see text beginning with "not ok 2"

data/features/test_format.feature

@@ -0,0 +1,49 @@
+Feature: Showing RSpec-style test output
+
+    Scenario: Showing failed tests
+        Given I have a failing test in my suite
+        When I pipe to xcpretty with "--test --no-color"
+        Then I should see a failed test icon
+
+    Scenario: Showing passing tests
+        Given I have a passing test in my suite
+        When I pipe to xcpretty with "--test --no-color"
+        Then I should see a passing test icon in ASCII
+
+    Scenario: Showing pending tests
+        Given I have a pending test in my suite
+        When I pipe to xcpretty with "--test --no-color"
+        Then I should see a pending test icon in ASCII
+
+    Scenario: Showing measuring tests
+        Given I have a measuring test in my suite
+        When I pipe to xcpretty with "--test --no-color"
+        Then I should see a measuring test icon in ASCII
+
+    Scenario: Showing some tests failed with color
+        Given I have a failing test in my suite
+        And the test suite has finished
+        When I pipe to xcpretty with "--test --color"
+        Then I should see a red failed test icon
+        And I should see the path of a failed test
+        And the final execution message should be red
+
+    Scenario: Showing passing tests with color
+        Given I have a passing test in my suite
+        When I pipe to xcpretty with "--test --color"
+        Then I should see a green passing test icon
+
+    Scenario: Showing pending tests with color
+        Given I have a pending test in my suite
+        When I pipe to xcpretty with "--test --color"
+        Then I should see a yellow pending test icon
+
+    Scenario: Showing measuring tests with color
+        Given I have a measuring test in my suite
+        When I pipe to xcpretty with "--test --color"
+        Then I should see a yellow measuring test icon
+
+    Scenario: Showing that all tests passed with color
+        Given all of my tests will pass in my suite
+        When I pipe to xcpretty with "--test --color"
+        Then the final execution message should be green

data/features/xcpretty.feature

@@ -0,0 +1,14 @@
+Feature: CLI behavior
+
+    Scenario: Starting xcpretty without any flags
+        When I run xcpretty
+        Then I should see the help banner
+
+    Scenario: Starting xcpretty with version
+        When I run xcpretty with -v
+        Then I should see the xcpretty version
+
+    Scenario: Performance
+        When I run xcpretty over a big file
+        Then the performance should be way faster than running cat
+

data/lib/xcpretty/ansi.rb

@@ -0,0 +1,72 @@
+module XCPretty
+  module ANSI
+
+    attr_accessor :colorize
+
+    FORMATTED_MATCHER = %r{\e\[(\d+)[;]?(\d+)?m(.*)\e\[0m}
+
+    EFFECT = {
+      reset: '0',
+      bold: '1',
+      underline: '4'
+    }
+
+    COLORS = {
+      black: '30',
+      red: '31',
+      green: '32',
+      yellow: '33',
+      blue: '34',
+      cyan: '36',
+      white: '37',
+      plain: '39'
+    }
+
+    def colorize?
+      !!@colorize
+    end
+
+    def white(text)
+      ansi_parse(text, :plain, :bold)
+    end
+
+    def red(text)
+      ansi_parse(text, :red)
+    end
+
+    def green(text)
+      ansi_parse(text, :green, :bold)
+    end
+
+    def cyan(text)
+      ansi_parse(text, :cyan)
+    end
+
+    def yellow(text)
+      ansi_parse(text, :yellow)
+    end
+
+    def applied_effects(text)
+      effects = []
+      if text =~ FORMATTED_MATCHER
+        colors = COLORS.invert[$1]
+        effect = EFFECT.invert[$2]
+        effects << colors if colors
+        effects << effect if effect
+      end
+      effects
+    end
+
+    def strip(text)
+      text =~ FORMATTED_MATCHER ? $3 : text
+    end
+
+    def ansi_parse(text, color, effect=nil)
+      return text unless colorize?
+      colors_code = COLORS[color] || ''
+      effect_code = EFFECT[effect] ? ';' + EFFECT[effect] : ''
+      "\e[#{colors_code}#{effect_code}m#{text}\e[#{EFFECT[:reset]}m"
+    end
+  end
+end
+

data/lib/xcpretty/formatters/formatter.rb

@@ -0,0 +1,177 @@
+# 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_analyze_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, file_path);   EMPTY; end
+    def format_compile_storyboard(file_name, file_path);       EMPTY; end
+    def format_compile_xib(file_name, file_path);              EMPTY; end
+    def format_copy_header_file(source, target);               EMPTY; end
+    def format_copy_plist_file(source, target);                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_measuring_test(suite, test, time);              EMPTY; end
+    def format_failing_test(suite, test, time, file_path);     EMPTY; end
+    def format_process_pch(file);                              EMPTY; end
+    def format_process_pch_command(file_path);                 EMPTY; end
+    def format_phase_success(phase_name);                      EMPTY; end
+    def format_phase_script_execution(phase_name);             EMPTY; end
+    def format_phase_script_error(error, text);                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_shell_command(command, arguments);              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
+    def format_write_file(file);                               EMPTY; end
+    def format_write_auxiliary_files;                          EMPTY; end
+
+    # COMPILER / LINKER ERRORS AND WARNINGS
+    def format_compile_error(file_name, file_path, reason,
+                             line, cursor);                    EMPTY; end
+    def format_error(message);                                 EMPTY; end
+    def format_file_missing_error(error, file_path);           EMPTY; end
+    def format_undefined_symbols(message, symbol, reference);  EMPTY; end
+    def format_duplicate_symbols(message, file_paths);         EMPTY; end
+    def format_warning(message);                             message; end
+
+    # TODO: see how we can unify format_error and format_compile_error,
+    #       the same for warnings
+    def format_compile_warning(file_name, file_path, reason,
+                               line, cursor);                  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)
+      if failures.empty?
+        final_message = green(executed_message)
+      else
+        final_message = red(executed_message)
+      end
+
+      text = [failures, final_message].join("\n\n\n").strip
+      "\n\n#{text}"
+    end
+
+    ERROR = '❌ '
+    ASCII_ERROR = '[x]'
+
+    WARNING = '⚠️ '
+    ASCII_WARNING = '[!]'
+
+    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_file_missing_error(reason, file_path)
+      "\n#{red(error_symbol + " " + reason)} #{file_path}\n\n"
+    end
+
+    def format_compile_warning(file, file_path, reason, line, cursor)
+      "\n#{yellow(warning_symbol + ' ')}#{file_path}: #{yellow(reason)}\n\n" \
+        "#{line}\n#{cyan(cursor)}\n\n"
+    end
+
+    def format_ld_warning(reason)
+      "#{yellow(warning_symbol + ' ' + reason)}"
+    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
+
+    def warning_symbol
+      use_unicode? ? WARNING : ASCII_WARNING
+    end
+
+  end
+end
+

data/lib/xcpretty/formatters/knock.rb

@@ -0,0 +1,35 @@
+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,33 @@
+module XCPretty
+
+  class RSpec < Formatter
+
+    FAIL = "F"
+    PASS = "."
+    PENDING = "P"
+    MEASURING = 'T'
+
+    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
+
+    def format_measuring_test(suite, test_case, time)
+      yellow(MEASURING)
+    end
+
+  end
+
+end
+