cucumber 3.1.2 → 4.0.0.rc.1

data/lib/cucumber/formatter/pretty.rb

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'gherkin/dialect'
 require 'cucumber/formatter/console'
 require 'cucumber/formatter/io'
 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.
     #
@@ -21,233 +24,424 @@ module Cucumber
       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
-        @config = runtime.configuration
-        @exceptions = []
-        @indent = 0
-        @prefixes = options[:prefixes] || {}
-        @delayed_messages = []
-        @previous_step_keyword = nil
+      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 = []
-        @counts = ConsoleCounts.new(runtime.configuration)
-        @issues = ConsoleIssues.new(runtime.configuration)
+        @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) # rubocop:disable Metrics/PerceivedComplexity
+        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)
+        # rubocop:disable Metrics/LineLength
+        print_step_data(event.test_step, event.result) if !event.test_step.hook? && (print_background_steps || event.test_step.location.lines.max >= current_test_case.location.lines.max || exception_to_be_printed)
+        # rubocop:enable Metrics/LineLength
+        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
-        @io.puts("    #{keyword}: #{name}")
+      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(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.to_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 { |cell| cell[: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_statistics(features.duration, @config, @counts, @issues)
-        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