mobiusloop 0.1.2

data/lib/cucumber/formatter/pretty.rb

@@ -0,0 +1,247 @@
+require 'fileutils'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'cucumber/gherkin/formatter/escaping'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format pretty</tt> (the default formatter).
+    #
+    # This formatter prints features to plain text - exactly how they were parsed,
+    # just prettier. That means with proper indentation and alignment of table columns.
+    #
+    # If the output is STDOUT (and not a file), there are bright colours to watch too.
+    #
+    class Pretty
+      include FileUtils
+      include Console
+      include Io
+      include Cucumber::Gherkin::Formatter::Escaping
+      attr_writer :indent
+      attr_reader :runtime
+
+      def initialize(runtime, path_or_io, options)
+        @runtime, @io, @options = runtime, ensure_io(path_or_io), options
+        @exceptions = []
+        @indent = 0
+        @prefixes = options[:prefixes] || {}
+        @delayed_messages = []
+        @previous_step_keyword = nil
+        @snippets_input = []
+      end
+
+      def before_features(features)
+        print_profile_information
+      end
+
+      def after_features(features)
+        print_summary(features)
+      end
+
+      def before_feature(feature)
+        @exceptions = []
+        @indent = 0
+      end
+
+      def comment_line(comment_line)
+        @io.puts(comment_line.indent(@indent))
+        @io.flush
+      end
+
+      def after_tags(tags)
+        if @indent == 1
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def tag_name(tag_name)
+        tag = format_string(tag_name, :tag).indent(@indent)
+        @io.print(tag)
+        @io.flush
+        @indent = 1
+      end
+
+      def feature_name(keyword, name)
+        @io.puts("#{keyword}: #{name}")
+        @io.puts
+        @io.flush
+      end
+
+      def before_feature_element(feature_element)
+        @indent = 2
+        @scenario_indent = 2
+      end
+
+      def after_feature_element(feature_element)
+        print_messages
+        @io.puts
+        @io.flush
+      end
+
+      def before_background(background)
+        @indent = 2
+        @scenario_indent = 2
+        @in_background = true
+      end
+
+      def after_background(background)
+        print_messages
+        @in_background = nil
+        @io.puts
+        @io.flush
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_examples_array(examples_array)
+        @indent = 4
+        @io.puts
+        @visiting_first_example_name = true
+      end
+
+      def examples_name(keyword, name)
+        @io.puts unless @visiting_first_example_name
+        @visiting_first_example_name = false
+        @io.puts("    #{keyword}: #{name}")
+        @io.flush
+        @indent = 6
+        @scenario_indent = 6
+      end
+
+      def before_outline_table(outline_table)
+        @table = outline_table
+      end
+
+      def after_outline_table(outline_table)
+        @table = nil
+        @indent = 4
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_step(step)
+        @current_step = step
+        @indent = 6
+        print_messages
+      end
+
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        @hide_this_step = false
+        if exception
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
+          @exceptions << exception
+        end
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
+        end
+        @status = status
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+        return if @hide_this_step
+        source_indent = nil unless @options[:source]
+        name_to_report = format_step(keyword, step_match, status, source_indent)
+        @io.puts(name_to_report.indent(@scenario_indent + 2))
+        print_messages
+      end
+
+      def doc_string(string)
+        return if @options[:no_multiline] || @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, @current_step.status))
+        @io.flush
+      end
+
+      def exception(exception, status)
+        return if @hide_this_step
+        print_messages
+        print_exception(exception, status, @indent)
+        @io.flush
+      end
+
+      def before_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @hide_this_step
+        @table = multiline_arg
+      end
+
+      def after_multiline_arg(multiline_arg)
+        @table = nil
+      end
+
+      def before_table_row(table_row)
+        return if !@table || @hide_this_step
+        @col_index = 0
+        @io.print '  |'.indent(@indent-2)
+      end
+
+      def after_table_row(table_row)
+        return if !@table || @hide_this_step
+        print_table_row_messages
+        @io.puts
+        if table_row.exception && !@exceptions.include?(table_row.exception)
+          print_exception(table_row.exception, table_row.status, @indent)
+        end
+      end
+
+      def after_table_cell(cell)
+        return unless @table
+        @col_index += 1
+      end
+
+      def table_cell_value(value, status)
+        return if !@table || @hide_this_step
+        status ||= @status || :passed
+        width = @table.col_width(@col_index)
+        cell_text = escape_cell(value.to_s || '')
+        padded = cell_text + (' ' * (width - cell_text.unpack('U*').length))
+        prefix = cell_prefix(status)
+        @io.print(' ' + format_string("#{prefix}#{padded}", status) + ::Cucumber::Term::ANSIColor.reset(" |"))
+        @io.flush
+      end
+
+      def before_test_case(test_case)
+        @previous_step_keyword = nil
+      end
+
+      def after_test_step(test_step, result)
+        collect_snippet_data(test_step, result)
+      end
+
+      private
+
+      def print_feature_element_name(keyword, name, file_colon_line, source_indent)
+        @io.puts if @scenario_indent == 6
+        names = name.empty? ? [name] : name.split("\n")
+        line = "#{keyword}: #{names[0]}".indent(@scenario_indent)
+        @io.print(line)
+        if @options[:source]
+          line_comment = "# #{file_colon_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        names[1..-1].each {|s| @io.puts "#{s}"}
+        @io.flush
+      end
+
+      def cell_prefix(status)
+        @prefixes[status]
+      end
+
+      def print_summary(features)
+        print_stats(features, @options)
+        print_snippets(@options)
+        print_passing_wip(@options)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/progress.rb

@@ -0,0 +1,73 @@
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/duration_extractor'
+require 'cucumber/formatter/hook_query_visitor'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format progress</tt>
+    class Progress
+      include Console
+      include Io
+      attr_reader :runtime
+
+      def initialize(runtime, path_or_io, options)
+        @runtime, @io, @options = runtime, ensure_io(path_or_io), options
+        @previous_step_keyword = nil
+        @snippets_input = []
+        @total_duration = 0
+      end
+
+      def before_test_case(_test_case)
+        unless @profile_information_printed
+          print_profile_information
+          @profile_information_printed = true
+        end
+        @previous_step_keyword = nil
+      end
+
+      def after_test_step(test_step, result)
+        progress(result.to_sym) if !HookQueryVisitor.new(test_step).hook? || result.failed?
+        collect_snippet_data(test_step, result) unless HookQueryVisitor.new(test_step).hook?
+      end
+
+      def after_test_case(_test_case, result)
+        @total_duration += DurationExtractor.new(result).result_duration
+      end
+
+      def done
+        @io.puts
+        @io.puts
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        print_steps(:pending)
+        print_steps(:failed)
+        print_statistics(@total_duration, @options)
+        print_snippets(@options)
+        print_passing_wip(@options)
+      end
+
+      CHARS = {
+        :passed    => '.',
+        :failed    => 'F',
+        :undefined => 'U',
+        :pending   => 'P',
+        :skipped   => '-'
+      }
+
+      def progress(status)
+        char = CHARS[status]
+        @io.print(format_string(char, status))
+        @io.flush
+      end
+
+      def table_header_cell?(status)
+        status == :skipped_param
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/rerun.rb

@@ -0,0 +1,35 @@
+require 'cucumber/formatter/io'
+
+module Cucumber
+  module Formatter
+    class Rerun
+      include Formatter::Io
+
+      def initialize(runtime, path_or_io, options)
+        @io = ensure_io(path_or_io)
+        @failures = {}
+        @options = options
+      end
+
+      def after_test_case(test_case, result)
+        return if result.ok?(@options[:strict])
+        @failures[test_case.location.file] ||= []
+        @failures[test_case.location.file] << test_case.location.line
+      end
+
+      def done
+        return if @failures.empty?
+        @io.print file_failures.join(' ')
+      end
+
+      [:before_test_case, :before_test_step, :after_test_step].each do |method|
+        define_method(method) { |*| }
+      end
+
+      private
+      def file_failures
+        @failures.map { |file, lines| [file, lines].join(':') }
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/stepdefs.rb

@@ -0,0 +1,14 @@
+require 'cucumber/formatter/usage'
+
+module Cucumber
+  module Formatter
+    class Stepdefs < Usage
+      def print_steps(stepdef_key)
+      end
+
+      def max_step_length
+        0
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/steps.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format steps</tt>
+    class Steps
+
+      def initialize(runtime, path_or_io, options)
+        @io = ensure_io(path_or_io)
+        @options = options
+        @step_definition_files = collect_steps(runtime)
+      end
+
+      def after_features(features)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp_source|
+            @io.print regexp_source.indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp_source.unpack('U*').length)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(runtime)
+        runtime.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp_source ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/summary.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    module Summary
+
+      def scenario_summary(runtime, &block)
+        scenarios_proc = lambda{|status| runtime.scenarios(status)}
+        dump_count(runtime.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(runtime, &block)
+        steps_proc = lambda{|status| runtime.steps(status)}
+        dump_count(runtime.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end