cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/lib/cucumber/formatter/junit.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
+
 require 'builder'
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/interceptor'
 require 'fileutils'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format junit</tt>
     class Junit
-
-      # TODO: remove coupling to types
-      AST_SCENARIO_OUTLINE = Core::Ast::ScenarioOutline
-      AST_EXAMPLE_ROW = LegacyApi::Ast::ExampleTableRow
-
       include Io
 
       class UnNamedFeatureError < StandardError
@@ -20,166 +19,150 @@ module Cucumber
         end
       end
 
-      def initialize(runtime, io, options)
-        @reportdir = ensure_dir(io, "junit")
-        @options = options
+      def initialize(config)
+        @ast_lookup = AstLookup.new(config)
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
+        @reportdir = ensure_dir(config.out_stream, 'junit')
+        @config = config
+        @features_data = Hash.new do |h, k|
+          h[k] = {
+            feature: nil,
+            failures: 0,
+            errors: 0,
+            tests: 0,
+            skipped: 0,
+            time: 0,
+            builder: Builder::XmlMarkup.new(indent: 2)
+          }
+        end
       end
 
-      def before_feature(feature)
-        @current_feature = feature
-        @failures = @errors = @tests = @skipped = 0
-        @builder = Builder::XmlMarkup.new( :indent => 2 )
-        @time = 0
+      def on_test_case_started(event)
+        test_case = event.test_case
+        start_feature(test_case) unless same_feature_as_previous_test_case?(test_case)
+        @failing_test_step = nil
         # In order to fill out <system-err/> and <system-out/>, we need to
         # intercept the $stderr and $stdout
         @interceptedout = Interceptor::Pipe.wrap(:stdout)
         @interceptederr = Interceptor::Pipe.wrap(:stderr)
       end
 
-      def before_feature_element(feature_element)
-        @in_examples = AST_SCENARIO_OUTLINE === feature_element
-        @steps_start = Time.now
-      end
+      def on_test_step_finished(event)
+        test_step, result = *event.attributes
+        return if @failing_test_step
 
-      def after_feature(feature)
-        @testsuite = Builder::XmlMarkup.new( :indent => 2 )
-        @testsuite.instruct!
-        @testsuite.testsuite(
-          :failures => @failures,
-          :errors => @errors,
-          :skipped => @skipped,
-          :tests => @tests,
-          :time => "%.6f" % @time,
-          :name => @feature_name ) do
-          @testsuite << @builder.target!
-          @testsuite.tag!('system-out') do
-            @testsuite.cdata! strip_control_chars(@interceptedout.buffer.join)
-          end
-          @testsuite.tag!('system-err') do
-            @testsuite.cdata! strip_control_chars(@interceptederr.buffer.join)
-          end
-        end
+        @failing_test_step = test_step unless result.ok?(@config.strict)
+      end
 
-        write_file(feature_result_filename(feature.file), @testsuite.target!)
+      def on_test_case_finished(event)
+        test_case, result = *event.attributes
+        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        test_case_name = NameBuilder.new(test_case, @ast_lookup)
+        scenario = test_case_name.scenario_name
+        scenario_designation = "#{scenario}#{test_case_name.name_suffix}"
+        output = create_output_string(test_case, scenario, result, test_case_name.row_name)
+        build_testcase(result, scenario_designation, output)
 
         Interceptor::Pipe.unwrap! :stdout
         Interceptor::Pipe.unwrap! :stderr
       end
 
-      def before_background(*args)
-        @in_background = true
+      def on_test_run_finished(_event)
+        @features_data.each { |_file, data| end_feature(data) }
       end
 
-      def after_background(*args)
-        @in_background = false
-      end
-
-      def feature_name(keyword, name)
-        raise UnNamedFeatureError.new(@current_feature.file) if name.empty?
-        lines = name.split(/\r?\n/)
-        @feature_name = lines[0]
-      end
+      private
 
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        @scenario = (name.nil? || name == "") ? "Unnamed scenario" : name.split("\n")[0]
-        @output = "#{keyword}: #{@scenario}\n\n"
+      def same_feature_as_previous_test_case?(test_case)
+        @current_feature_data && @current_feature_data[:uri] == test_case.location.file
       end
 
-      def before_steps(steps)
+      def start_feature(test_case)
+        uri = test_case.location.file
+        feature = @ast_lookup.gherkin_document(uri).feature
+        raise UnNamedFeatureError, uri if feature.name.empty?
+        @current_feature_data = @features_data[uri]
+        @current_feature_data[:uri] = uri unless @current_feature_data[:uri]
+        @current_feature_data[:feature] = feature unless @current_feature_data[:feature]
       end
 
-      def after_steps(steps)
-        return if @in_background || @in_examples
-
-        duration = Time.now - @steps_start
-        if steps.failed?
-          steps.each { |step| @output += "#{step.keyword}#{step.name}\n" }
-          @output += "\nMessage:\n"
+      def end_feature(feature_data)
+        @testsuite = Builder::XmlMarkup.new(indent: 2)
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          failures: feature_data[:failures],
+          errors: feature_data[:errors],
+          skipped: feature_data[:skipped],
+          tests: feature_data[:tests],
+          time: format('%<time>.6f', time: feature_data[:time]),
+          name: feature_data[:feature].name
+        ) do
+          @testsuite << feature_data[:builder].target!
         end
-        build_testcase(duration, steps.status, steps.exception)
-      end
-
-      def before_examples(*args)
-        @header_row = true
-        @in_examples = true
-      end
 
-      def after_examples(*args)
-        @in_examples = false
-      end
-
-      def before_table_row(table_row)
-        return unless @in_examples
-
-        @table_start = Time.now
-      end
-
-      def after_table_row(table_row)
-        return unless @in_examples and AST_EXAMPLE_ROW === table_row
-        duration = Time.now - @table_start
-        unless @header_row
-          name_suffix = " (outline example : #{table_row.name})"
-          if table_row.failed?
-            @output += "Example row: #{table_row.name}\n"
-            @output += "\nMessage:\n"
+        write_file(feature_result_filename(feature_data[:uri]), @testsuite.target!)
+      end
+
+      def create_output_string(test_case, scenario, result, row_name) # rubocop:disable Metrics/PerceivedComplexity
+        scenario_source = @ast_lookup.scenario_source(test_case)
+        keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+        output = "#{keyword}: #{scenario}\n\n"
+        return output if result.ok?(@config.strict)
+        if scenario_source.type == :Scenario
+          if @failing_test_step
+            if @failing_test_step.hook?
+              output += "#{@failing_test_step.text} at #{@failing_test_step.location}\n"
+            else
+              step_source = @ast_lookup.step_source(@failing_test_step).step
+              output += "#{step_source.keyword}#{@failing_test_step.text}\n"
+            end
+          else # An Around hook has failed
+            output += "Around hook\n"
           end
-          build_testcase(duration, table_row.status, table_row.exception, name_suffix)
-        end
-
-        @header_row = false if @header_row
-      end
-
-      def before_test_case(test_case)
-        if @options[:expand] and test_case.keyword == "Scenario Outline"
-          @exception = nil
+        else
+          output += "Example row: #{row_name}\n"
         end
-      end
-
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        if @options[:expand] and @in_examples
-          if not @exception and exception
-            @exception = exception
+        output + "\nMessage:\n"
+      end
+
+      def build_testcase(result, scenario_designation, output)
+        duration = ResultBuilder.new(result).test_case_duration
+        @current_feature_data[:time] += duration
+        classname = @current_feature_data[:feature].name
+        name = scenario_designation
+
+        @current_feature_data[:builder].testcase(classname: classname, name: name, time: format('%<duration>.6f', duration: duration)) do
+          if !result.passed? && result.ok?(@config.strict)
+            @current_feature_data[:builder].skipped
+            @current_feature_data[:skipped] += 1
+          elsif !result.passed?
+            status = result.to_sym
+            exception = get_backtrace_object(result)
+            @current_feature_data[:builder].failure(message: "#{status} #{name}", type: status) do
+              @current_feature_data[:builder].cdata! output
+              @current_feature_data[:builder].cdata!(format_exception(exception)) if exception
+            end
+            @current_feature_data[:failures] += 1
           end
-        end
-      end
-
-      def after_test_case(test_case, result)
-        if @options[:expand] and test_case.keyword == "Scenario Outline"
-          test_case_name = NameBuilder.new(test_case)
-          @scenario = test_case_name.outline_name
-          @output = "#{test_case.keyword}: #{@scenario}\n\n"
-          if result.failed?
-            @output += "Example row: #{test_case_name.row_name}\n"
-            @output += "\nMessage:\n"
+          @current_feature_data[:builder].tag!('system-out') do
+            @current_feature_data[:builder].cdata! strip_control_chars(@interceptedout.buffer_string)
+          end
+          @current_feature_data[:builder].tag!('system-err') do
+            @current_feature_data[:builder].cdata! strip_control_chars(@interceptederr.buffer_string)
           end
-          test_case_result = ResultBuilder.new(result)
-          build_testcase(test_case_result.test_case_duration, test_case_result.status, @exception, test_case_name.name_suffix)
         end
+        @current_feature_data[:tests] += 1
       end
 
-      private
-
-      def build_testcase(duration, status, exception = nil, suffix = "")
-        @time += duration
-        classname = @feature_name
-        name = "#{@scenario}#{suffix}"
-        pending = [:pending, :undefined].include?(status) && (!@options[:strict])
-
-        @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
-          if status == :skipped || pending
-            @builder.skipped
-            @skipped += 1
-          elsif status != :passed
-            @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
-              @builder.cdata! @output
-              @builder.cdata!(format_exception(exception)) if exception
-            end
-            @failures += 1
-          end
-          @builder.tag!('system-out')
-          @builder.tag!('system-err')
+      def get_backtrace_object(result)
+        if result.failed?
+          result.exception
+        elsif result.backtrace
+          result
         end
-        @tests += 1
       end
 
       def format_exception(exception)
@@ -191,7 +174,7 @@ module Cucumber
       end
 
       def basename(feature_file)
-        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature')
+        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature') # rubocop:disable Style/RegexpLiteral
       end
 
       def write_file(feature_filename, data)
@@ -202,74 +185,61 @@ module Cucumber
       def strip_control_chars(cdata)
         cdata.scan(/[[:print:]\t\n\r]/).join
       end
-      
     end
 
     class NameBuilder
-      attr_reader :outline_name, :name_suffix, :row_name
-
-      def initialize(test_case)
-        test_case.describe_source_to self
-      end
-
-      def feature(*)
-        self
+      attr_reader :scenario_name, :name_suffix, :row_name
+
+      def initialize(test_case, ast_lookup)
+        @name_suffix = ''
+        @row_name = ''
+        scenario_source = ast_lookup.scenario_source(test_case)
+        if scenario_source.type == :Scenario
+          scenario(scenario_source.scenario)
+        else
+          scenario_outline(scenario_source.scenario_outline)
+          examples_table_row(scenario_source.row)
+        end
       end
 
-      def scenario(*)
-        self
+      def scenario(scenario)
+        @scenario_name = scenario.name.empty? ? 'Unnamed scenario' : scenario.name
       end
 
       def scenario_outline(outline)
-        @outline_name = outline.name
-        self
-      end
-
-      def examples_table(*)
-        self
+        @scenario_name = outline.name.empty? ? 'Unnamed scenario outline' : outline.name
       end
 
       def examples_table_row(row)
-        @row_name = '| ' + row.values.join(' | ') + ' |'
+        @row_name = '| ' + row.cells.map(&:value).join(' | ') + ' |'
         @name_suffix = " (outline example : #{@row_name})"
-        self
       end
     end
 
     class ResultBuilder
-      attr_reader :status, :test_case_duration
+      attr_reader :test_case_duration
       def initialize(result)
         @test_case_duration = 0
         result.describe_to(self)
       end
 
-      def passed
-        @status = :passed
-      end
+      def passed(*) end
 
-      def failed
-        @status = :failed
-      end
+      def failed(*) end
 
-      def undefined
-        @status = :undefined
-      end
+      def undefined(*) end
 
-      def skipped
-        @status = :skipped
-      end
+      def skipped(*) end
 
-      def pending(*)
-        @status = :pending
-      end
+      def pending(*) end
 
-      def exception(*)
-      end
+      def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @test_case_duration = duration.nanoseconds / 10 ** 9.0 }
+        duration.tap { |dur| @test_case_duration = dur.nanoseconds / 10**9.0 }
       end
-    end
 
+      def embed(*) end
+    end
   end
 end

data/lib/cucumber/formatter/pretty.rb

@@ -1,248 +1,453 @@
+# frozen_string_literal: true
+
 require 'fileutils'
+require 'gherkin/dialect'
 require 'cucumber/formatter/console'
 require 'cucumber/formatter/io'
-require 'gherkin/formatter/escaping'
+require 'cucumber/gherkin/formatter/escaping'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
+require 'cucumber/formatter/duration_extractor'
+require 'cucumber/formatter/backtrace_filter'
+require 'cucumber/formatter/ast_lookup'
 
 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.
+    # This formatter prints the result of the feature executions to plain text - exactly how they were parsed.
     #
     # If the output is STDOUT (and not a file), there are bright colours to watch too.
     #
-    class Pretty
+    class Pretty # rubocop:disable Metrics/ClassLength
       include FileUtils
       include Console
       include Io
-      include 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, "pretty"), options
-        @exceptions = []
-        @indent = 0
-        @prefixes = options[:prefixes] || {}
-        @delayed_messages = []
-        @previous_step_keyword = nil
+      include Cucumber::Gherkin::Formatter::Escaping
+      attr_reader :config, :options
+      private :config, :options
+      attr_reader :current_feature_uri, :current_scenario_outline, :current_examples, :current_test_case
+      private :current_feature_uri, :current_scenario_outline, :current_examples, :current_test_case
+      attr_reader :in_scenario_outline, :print_background_steps
+      private :in_scenario_outline, :print_background_steps
+
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        @config = config
+        @options = config.to_hash
         @snippets_input = []
+        @total_duration = 0
+        @exceptions = []
+        @gherkin_sources = {}
+        @step_matches = {}
+        @ast_lookup = AstLookup.new(config)
+        @counts = ConsoleCounts.new(config)
+        @issues = ConsoleIssues.new(config, @ast_lookup)
+        @first_feature = true
+        @current_feature_uri = ''
+        @current_scenario_outline = nil
+        @current_examples = nil
+        @current_test_case = nil
+        @in_scenario_outline = false
+        @print_background_steps = false
+        @test_step_output = []
+        @passed_test_cases = []
+        @source_indent = 0
+        @next_comment_to_be_printed = 0
+        config.on_event :gherkin_source_read, &method(:on_gherkin_source_read)
+        config.on_event :step_activated, &method(:on_step_activated)
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_step_started, &method(:on_test_step_started)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
+      end
+
+      def on_gherkin_source_read(event)
+        @gherkin_sources[event.path] = event.body
+      end
+
+      def on_step_activated(event)
+        test_step, step_match = *event.attributes
+        @step_matches[test_step.to_s] = step_match
+      end
+
+      def on_test_case_started(event)
+        if !same_feature_as_previous_test_case?(event.test_case.location)
+          if first_feature?
+            @first_feature = false
+            print_profile_information
+          else
+            print_comments(gherkin_source.split("\n").length, 0)
+            @io.puts
+          end
+          @current_feature_uri = event.test_case.location.file
+          @exceptions = []
+          print_feature_data
+          if feature_has_background?
+            print_background_data
+            @print_background_steps = true
+            @in_scenario_outline = false
+          end
+        else
+          @print_background_steps = false
+        end
+        @current_test_case = event.test_case
+        print_step_header(current_test_case) unless print_background_steps
+      end
+
+      def on_test_step_started(event)
+        return if event.test_step.hook?
+        print_step_header(current_test_case) if first_step_after_printing_background_steps?(event.test_step)
+      end
+
+      def on_test_step_finished(event)
+        collect_snippet_data(event.test_step, @ast_lookup) if event.result.undefined?
+        return if in_scenario_outline && !options[:expand]
+        exception_to_be_printed = find_exception_to_be_printed(event.result)
+        print_step_data(event.test_step, event.result) if print_step_data?(event, exception_to_be_printed)
+        print_step_output
+        return unless exception_to_be_printed
+        print_exception(exception_to_be_printed, event.result.to_sym, 6)
+        @exceptions << exception_to_be_printed
+      end
+
+      def on_test_case_finished(event)
+        @total_duration += DurationExtractor.new(event.result).result_duration
+        @passed_test_cases << event.test_case if config.wip? && event.result.passed?
+        if in_scenario_outline && !options[:expand]
+          print_row_data(event.test_case, event.result)
+        else
+          exception_to_be_printed = find_exception_to_be_printed(event.result)
+          return unless exception_to_be_printed
+          print_exception(exception_to_be_printed, event.result.to_sym, 6)
+          @exceptions << exception_to_be_printed
+        end
       end
 
-      def before_features(features)
-        print_profile_information
+      def on_test_run_finished(_event)
+        print_comments(gherkin_source.split("\n").length, 0) unless current_feature_uri.empty?
+        @io.puts
+        print_summary
       end
 
-      def after_features(features)
-        print_summary(features)
+      def puts(*messages)
+        messages.each do |message|
+          @test_step_output.push message
+        end
       end
 
-      def before_feature(feature)
-        @exceptions = []
-        @indent = 0
+      private
+
+      def find_exception_to_be_printed(result)
+        return nil if result.ok?(options[:strict])
+        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        exception = result.failed? ? result.exception : result
+        return nil if @exceptions.include?(exception)
+        exception
       end
 
-      def comment_line(comment_line)
-        @io.puts(comment_line.indent(@indent))
-        @io.flush
+      def calculate_source_indent(test_case)
+        scenario = scenario_source(test_case).scenario
+        @source_indent = calculate_source_indent_for_ast_node(scenario)
       end
 
-      def after_tags(tags)
-        if @indent == 1
-          @io.puts
-          @io.flush
+      def calculate_source_indent_for_ast_node(ast_node)
+        indent = 4 + ast_node.keyword.length
+        indent += 1 + ast_node.name.length
+        ast_node.steps.each do |step|
+          step_indent = 5 + step.keyword.length + step.text.length
+          indent = step_indent if step_indent > indent
         end
+        indent
       end
 
-      def tag_name(tag_name)
-        tag = format_string(tag_name, :tag).indent(@indent)
-        @io.print(tag)
-        @io.flush
-        @indent = 1
+      def calculate_source_indent_for_expanded_test_case(test_case, scenario_keyword, expanded_name)
+        indent = 7 + scenario_keyword.length
+        indent += 2 + expanded_name.length
+        test_case.test_steps.each do |step|
+          if !step.hook? && step.location.lines.max >= test_case.location.lines.max
+            step_indent = 9 + test_step_keyword(step).length + step.text.length
+            indent = step_indent if step_indent > indent
+          end
+        end
+        indent
       end
 
-      def feature_name(keyword, name)
-        @io.puts("#{keyword}: #{name}")
-        @io.puts
-        @io.flush
+      def print_step_output
+        @test_step_output.each { |message| @io.puts(format_string(message, :tag).indent(6)) }
+        @test_step_output = []
       end
 
-      def before_feature_element(feature_element)
-        @indent = 2
-        @scenario_indent = 2
+      def first_feature?
+        @first_feature
       end
 
-      def after_feature_element(feature_element)
-        print_messages
-        @io.puts
-        @io.flush
+      def same_feature_as_previous_test_case?(location)
+        location.file == current_feature_uri
       end
 
-      def before_background(background)
-        @indent = 2
-        @scenario_indent = 2
-        @in_background = true
+      def feature_has_background?
+        feature_children = gherkin_document.feature.children
+        return false if feature_children.empty?
+        !feature_children.first.background.nil?
       end
 
-      def after_background(background)
-        print_messages
-        @in_background = nil
-        @io.puts
-        @io.flush
+      def print_step_header(test_case)
+        if from_scenario_outline?(test_case)
+          @in_scenario_outline = true
+          unless same_outline_as_previous_test_case?(test_case)
+            @current_scenario_outline = scenario_source(test_case).scenario_outline
+            @io.puts
+            print_outline_data(current_scenario_outline)
+          end
+          unless same_examples_as_previous_test_case?(test_case)
+            @current_examples = scenario_source(test_case).examples
+            @io.puts
+            print_examples_data(current_examples)
+          end
+          print_expanded_row_data(current_test_case) if options[:expand]
+        else
+          @in_scenario_outline = false
+          @current_scenario_outline = nil
+          @current_examples = nil
+          @io.puts
+          @source_indent = calculate_source_indent(current_test_case)
+          print_scenario_data(test_case)
+        end
       end
 
-      def background_name(keyword, name, file_colon_line, source_indent)
-        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      def same_outline_as_previous_test_case?(test_case)
+        scenario_source(test_case).scenario_outline == current_scenario_outline
       end
 
-      def before_examples_array(examples_array)
-        @indent = 4
-        @io.puts
-        @visiting_first_example_name = true
+      def same_examples_as_previous_test_case?(test_case)
+        scenario_source(test_case).examples == current_examples
+      end
+
+      def from_scenario_outline?(test_case)
+        scenario = scenario_source(test_case)
+        scenario.type != :Scenario
+      end
+
+      def first_step_after_printing_background_steps?(test_step)
+        return false unless print_background_steps
+        return false unless test_step.location.lines.max >= current_test_case.location.lines.max
+        @print_background_steps = false
+        true
       end
 
-      def examples_name(keyword, name)
-        @io.puts unless @visiting_first_example_name
-        @visiting_first_example_name = false
-        names = name.strip.empty? ? [name.strip] : name.split("\n")
-        @io.puts("    #{keyword}: #{names[0]}")
-        names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
+      def print_feature_data
+        feature = gherkin_document.feature
+        print_language_comment(feature.location.line)
+        print_comments(feature.location.line, 0)
+        print_tags(feature.tags, 0)
+        print_feature_line(feature)
+        print_description(feature.description)
         @io.flush
-        @indent = 6
-        @scenario_indent = 6
       end
 
-      def before_outline_table(outline_table)
-        @table = outline_table
+      def print_language_comment(feature_line)
+        gherkin_source.split("\n")[0..feature_line].each do |line|
+          @io.puts(format_string(line, :comment)) if /# *language *:/ =~ line
+        end
       end
 
-      def after_outline_table(outline_table)
-        @table = nil
-        @indent = 4
+      def print_comments(up_to_line, indent)
+        comments = gherkin_document.comments
+        return if comments.empty? || comments.length <= @next_comment_to_be_printed
+        comments[@next_comment_to_be_printed..-1].each do |comment|
+          if comment.location.line <= up_to_line
+            @io.puts(format_string(comment.text.strip, :comment).indent(indent))
+            @next_comment_to_be_printed += 1
+          end
+          break if @next_comment_to_be_printed >= comments.length
+        end
       end
 
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      def print_tags(tags, indent)
+        return if !tags || tags.empty?
+        @io.puts(tags.map { |tag| format_string(tag.name, :tag) }.join(' ').indent(indent))
       end
 
-      def before_step(step)
-        @current_step = step
-        @indent = 6
-        print_messages
+      def print_feature_line(feature)
+        print_keyword_name(feature.keyword, feature.name, 0)
       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
+      def print_keyword_name(keyword, name, indent, location = nil)
+        line = "#{keyword}:"
+        line += " #{name}"
+        @io.print(line.indent(indent))
+        if location && options[:source]
+          line_comment = format_string("# #{location}", :comment).indent(@source_indent - line.length - indent)
+          @io.print(line_comment)
         end
-        if status != :failed && @in_background ^ background
-          @hide_this_step = true
-          return
+        @io.puts
+      end
+
+      def print_description(description)
+        return unless description
+        description.split("\n").each do |line|
+          @io.puts(line)
         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
+      def print_background_data
+        @io.puts
+        background = gherkin_document.feature.children.first.background
+        @source_indent = calculate_source_indent_for_ast_node(background) if options[:source]
+        print_comments(background.location.line, 2)
+        print_background_line(background)
+        print_description(background.description)
+        @io.flush
+      end
+
+      def print_background_line(background)
+        print_keyword_name(background.keyword, background.name, 2, "#{current_feature_uri}:#{background.location.line}")
       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))
+      def print_scenario_data(test_case)
+        scenario = scenario_source(test_case).scenario
+        print_comments(scenario.location.line, 2)
+        print_tags(scenario.tags, 2)
+        print_scenario_line(scenario, test_case.location)
+        print_description(scenario.description)
         @io.flush
       end
 
-      def exception(exception, status)
-        return if @hide_this_step
-        print_messages
-        print_exception(exception, status, @indent)
+      def print_scenario_line(scenario, location = nil)
+        print_keyword_name(scenario.keyword, scenario.name, 2, location)
+      end
+
+      def print_step_data?(event, exception_to_be_printed)
+        !event.test_step.hook? && (
+          print_background_steps ||
+          event.test_step.location.lines.max >= current_test_case.location.lines.max ||
+          exception_to_be_printed
+        )
+      end
+
+      def print_step_data(test_step, result)
+        base_indent = options[:expand] && in_scenario_outline ? 8 : 4
+        step_keyword = test_step_keyword(test_step)
+        indent = options[:source] ? @source_indent - step_keyword.length - test_step.text.length - base_indent : nil
+        print_comments(test_step.location.lines.max, base_indent)
+        name_to_report = format_step(step_keyword, @step_matches.fetch(test_step.to_s) { NoStepMatch.new(test_step, test_step.text) }, result.to_sym, indent)
+        @io.puts(name_to_report.indent(base_indent))
+        print_multiline_argument(test_step, result, base_indent + 2) unless options[:no_multiline]
         @io.flush
       end
 
-      def before_multiline_arg(multiline_arg)
-        return if @options[:no_multiline] || @hide_this_step
-        @table = multiline_arg
+      def test_step_keyword(test_step)
+        step = step_source(test_step).step
+        step.keyword
       end
 
-      def after_multiline_arg(multiline_arg)
-        @table = nil
+      def step_source(test_step)
+        @ast_lookup.step_source(test_step)
       end
 
-      def before_table_row(table_row)
-        return if !@table || @hide_this_step
-        @col_index = 0
-        @io.print '  |'.indent(@indent-2)
+      def scenario_source(test_case)
+        @ast_lookup.scenario_source(test_case)
       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
+      def gherkin_source
+        @gherkin_sources[current_feature_uri]
       end
 
-      def after_table_cell(cell)
-        return unless @table
-        @col_index += 1
+      def gherkin_document
+        @ast_lookup.gherkin_document(current_feature_uri)
       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
+      def print_multiline_argument(test_step, result, indent)
+        step = step_source(test_step).step
+        if !step.doc_string.nil?
+          print_doc_string(step.doc_string.content, result.to_sym, indent)
+        elsif !step.data_table.nil?
+          print_data_table(step.data_table, result.to_sym, indent)
+        end
       end
 
-      def before_test_case(test_case)
-        @previous_step_keyword = nil
+      def print_data_table(data_table, status, indent)
+        data_table.rows.each do |row|
+          print_comments(row.location.line, indent)
+          @io.puts format_string(gherkin_source.split("\n")[row.location.line - 1].strip, status).indent(indent)
+        end
       end
 
-      def after_test_step(test_step, result)
-        collect_snippet_data(test_step, result)
+      def print_outline_data(scenario_outline) # rubocop:disable Metrics/AbcSize
+        print_comments(scenario_outline.location.line, 2)
+        print_tags(scenario_outline.tags, 2)
+        @source_indent = calculate_source_indent_for_ast_node(scenario_outline) if options[:source]
+        print_scenario_line(scenario_outline, "#{current_feature_uri}:#{scenario_outline.location.line}")
+        print_description(scenario_outline.description)
+        scenario_outline.steps.each do |step|
+          print_comments(step.location.line, 4)
+          step_line = "    #{step.keyword}#{step.text}"
+          @io.print(format_string(step_line, :skipped))
+          if options[:source]
+            comment_line = format_string("# #{current_feature_uri}:#{step.location.line}", :comment)
+            @io.print(comment_line.indent(@source_indent - step_line.length))
+          end
+          @io.puts
+          next if options[:no_multiline]
+          print_doc_string(step.doc_string.content, :skipped, 6) unless step.doc_string.nil?
+          print_data_table(step.data_table, :skipped, 6) unless step.data_table.nil?
+        end
+        @io.flush
       end
 
-      private
+      def print_doc_string(content, status, indent)
+        s = %("""\n#{content}\n""").indent(indent)
+        s = s.split("\n").map { |l| l =~ /^\s+$/ ? '' : l }.join("\n")
+        @io.puts(format_string(s, status))
+      end
 
-      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))
+      def print_examples_data(examples)
+        print_comments(examples.location.line, 4)
+        print_tags(examples.tags, 4)
+        print_keyword_name(examples.keyword, examples.name, 4)
+        print_description(examples.description)
+        unless options[:expand]
+          print_comments(examples.table_header.location.line, 6)
+          @io.puts(gherkin_source.split("\n")[examples.table_header.location.line - 1].strip.indent(6))
         end
+        @io.flush
+      end
+
+      def print_row_data(test_case, result)
+        print_comments(test_case.location.lines.max, 6)
+        @io.print(format_string(gherkin_source.split("\n")[test_case.location.lines.max - 1].strip, result.to_sym).indent(6))
+        @io.print(format_string(@test_step_output.join(', '), :tag).indent(2)) unless @test_step_output.empty?
+        @test_step_output = []
         @io.puts
-        names[1..-1].each {|s| @io.puts "    #{s}"}
+        if result.failed? || result.pending?
+          result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+          exception = result.failed? ? result.exception : result
+          unless @exceptions.include?(exception)
+            print_exception(exception, result.to_sym, 6)
+            @exceptions << exception
+          end
+        end
         @io.flush
       end
 
-      def cell_prefix(status)
-        @prefixes[status]
+      def print_expanded_row_data(test_case)
+        feature = gherkin_document.feature
+        language_code = feature.language || 'en'
+        language = ::Gherkin::Dialect.for(language_code)
+        scenario_keyword = language.scenario_keywords[0]
+        row = scenario_source(test_case).row
+        expanded_name = '| ' + row.cells.map(&:value).join(' | ') + ' |'
+        @source_indent = calculate_source_indent_for_expanded_test_case(test_case, scenario_keyword, expanded_name)
+        @io.puts
+        print_keyword_name(scenario_keyword, expanded_name, 6, test_case.location)
       end
 
-      def print_summary(features)
-        print_stats(features, @options)
-        print_snippets(@options)
-        print_passing_wip(@options)
+      def print_summary
+        print_statistics(@total_duration, config, @counts, @issues)
+        print_snippets(options)
+        print_passing_wip(config, @passed_test_cases, @ast_lookup)
       end
     end
   end