cucumber 3.1.2 → 8.0.0

data/lib/cucumber/formatter/console.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength
+
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
 require 'cucumber/gherkin/i18n'
@@ -32,7 +34,7 @@ module Cucumber
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-                    c = ('# ' + step_match.location.to_s).indent(source_indent)
+                    c = indent("# #{step_match.location}", source_indent)
                     format_string(c, :comment)
                   else
                     ''
@@ -46,7 +48,7 @@ module Cucumber
       def format_string(o, status)
         fmt = format_for(status)
         o.to_s.split("\n").map do |line|
-          if Proc === fmt
+          if Proc == fmt.class
             fmt.call(line)
           else
             fmt % line
@@ -54,10 +56,6 @@ module Cucumber
         end.join("\n")
       end
 
-      def print_steps(status)
-        print_elements(runtime.steps(status), status, 'steps')
-      end
-
       def print_elements(elements, status, kind)
         return if elements.empty?
 
@@ -101,36 +99,43 @@ module Cucumber
         @io.puts(format_string(string, status))
       end
 
-      def exception_message_string(e, indent)
+      def exception_message_string(e, indent_amount)
         message = "#{e.message} (#{e.class})".dup.force_encoding('UTF-8')
         message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
 
-        "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
+        indent("#{message}\n#{e.backtrace.join("\n")}", indent_amount)
       end
 
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
-      def linebreaks(s, max)
-        return s unless max && max > 0
-        s.gsub(/.{1,#{max}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }.rstrip
+      def linebreaks(msg, max)
+        return msg unless max && max > 0
+
+        msg.gsub(/.{1,#{max}}(?:\s|\Z)/) do
+          (Regexp.last_match(0) + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n")
+        end.rstrip
       end
 
-      def collect_snippet_data(test_step, result)
+      def collect_snippet_data(test_step, ast_lookup)
         # collect snippet data for undefined steps
-        return if hook?(test_step)
-        keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
-        @previous_step_keyword = keyword
-        return unless result.undefined?
-        @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
+        keyword = ast_lookup.snippet_step_keyword(test_step)
+        @snippets_input << Console::SnippetData.new(keyword, test_step)
+      end
+
+      def collect_undefined_parameter_type_names(undefined_parameter_type)
+        @undefined_parameter_types << undefined_parameter_type.type_name
       end
 
       def print_snippets(options)
         return unless options[:snippets]
-        return if runtime.steps(:undefined).empty?
 
         snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
-          runtime.snippet_text(step_keyword, step_name, multiline_arg)
+          snippet_text(step_keyword, step_name, multiline_arg)
+        end
+        do_print_snippets(snippet_text_proc) unless @snippets_input.empty?
+
+        @undefined_parameter_types.map do |type_name|
+          do_print_undefined_parameter_type_snippet(type_name)
         end
-        do_print_snippets(snippet_text_proc)
       end
 
       def do_print_snippets(snippet_text_proc)
@@ -146,10 +151,15 @@ module Cucumber
         @io.flush
       end
 
-      def print_passing_wip(options)
-        return unless options[:wip]
-        passed_messages = element_messages(runtime.scenarios(:passed), :passed)
-        do_print_passing_wip(passed_messages)
+      def print_passing_wip(config, passed_test_cases, ast_lookup)
+        return unless config.wip?
+
+        messages = passed_test_cases.map do |test_case|
+          scenario_source = ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          linebreaks("#{test_case.location.on_line(test_case.location.lines.max)}:in `#{keyword}: #{test_case.name}'", ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+        end
+        do_print_passing_wip(messages)
       end
 
       def do_print_passing_wip(passed_messages)
@@ -161,59 +171,57 @@ module Cucumber
         end
       end
 
-      def embed(file, mime_type, label)
-        # no-op
-      end
-
-      # define @delayed_messages = [] in your Formatter if you want to
-      # activate this feature
-      def puts(*messages)
-        if @delayed_messages
-          @delayed_messages += messages
-        else
-          if @io
-            @io.puts
-            messages.each do |message|
-              @io.puts(format_string(message, :tag))
-            end
-            @io.flush
-          end
-        end
-      end
-
-      def print_messages
-        @delayed_messages.each { |message| print_message(message) }
-        empty_messages
-      end
+      def attach(src, media_type)
+        return unless media_type == 'text/x.cucumber.log+plain'
+        return unless @io
 
-      def print_table_row_messages
-        return if @delayed_messages.empty?
-        @io.print(format_string(@delayed_messages.join(', '), :tag).indent(2))
-        @io.flush
-        empty_messages
-      end
-
-      def print_message(message)
-        @io.puts(format_string(message, :tag).indent(@indent))
+        @io.puts
+        @io.puts(format_string(src, :tag))
         @io.flush
       end
 
-      def empty_messages
-        @delayed_messages = []
-      end
-
       def print_profile_information
         return if @options[:skip_profile_information] || @options[:profiles].nil? || @options[:profiles].empty?
+
         do_print_profile_information(@options[:profiles])
       end
 
       def do_print_profile_information(profiles)
-        profiles_sentence = profiles.size == 1 ? profiles.first :
-          "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+        profiles_sentence = if profiles.size == 1
+                              profiles.first
+                            else
+                              "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+                            end
 
         @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
       end
 
+      def do_print_undefined_parameter_type_snippet(type_name)
+        camelized = type_name.split(/_|-/).collect(&:capitalize).join
+
+        @io.puts [
+          "The parameter #{type_name} is not defined. You can define a new one with:",
+          '',
+          'ParameterType(',
+          "  name:        '#{type_name}',",
+          '  regexp:      /some regexp here/,',
+          "  type:        #{camelized},",
+          '  # The transformer takes as many arguments as there are capture groups in the regexp,',
+          '  # or just one if there are none.',
+          "  transformer: ->(s) { #{camelized}.new(s) }",
+          ')',
+          ''
+        ].join("\n")
+      end
+
+      def indent(string, padding)
+        if padding >= 0
+          string.gsub(/^/, ' ' * padding)
+        else
+          string.gsub(/^ {0,#{-padding}}/, '')
+        end
+      end
+
       private
 
       FORMATS = Hash.new { |hash, format| hash[format] = method(format).to_proc }
@@ -222,11 +230,8 @@ module Cucumber
         key = keys.join('_').to_sym
         fmt = FORMATS[key]
         raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
-        fmt
-      end
 
-      def hook?(test_step)
-        not test_step.source.last.respond_to?(:actual_keyword)
+        fmt
       end
 
       def element_messages(elements, status)
@@ -248,10 +253,13 @@ module Cucumber
 
       class SnippetData
         attr_reader :actual_keyword, :step
+
         def initialize(actual_keyword, step)
-          @actual_keyword, @step = actual_keyword, step
+          @actual_keyword = actual_keyword
+          @step = step
         end
       end
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/cucumber/formatter/console_counts.rb

@@ -29,15 +29,10 @@ module Cucumber
       end
 
       def status_counts(summary)
-        counts = Core::Test::Result::TYPES.map do |status|
-          count = summary.total(status)
-          [status, count]
-        end.select do |status, count|
-          count > 0
-        end.map do |status, count|
-          format_string("#{count} #{status}", status)
-        end
-        "(#{counts.join(", ")})" if counts.any?
+        counts = Core::Test::Result::TYPES.map { |status| [status, summary.total(status)] }
+        counts = counts.select { |_status, count| count > 0 }
+        counts = counts.map { |status, count| format_string("#{count} #{status}", status) }
+        "(#{counts.join(', ')})" if counts.any?
       end
     end
   end

data/lib/cucumber/formatter/console_issues.rb

@@ -5,7 +5,7 @@ module Cucumber
     class ConsoleIssues
       include Console
 
-      def initialize(config)
+      def initialize(config, ast_lookup = AstLookup.new(config))
         @previous_test_case = nil
         @issues = Hash.new { |h, k| h[k] = [] }
         @config = config
@@ -18,10 +18,12 @@ module Cucumber
             @issues[:failed].delete(event.test_case)
           end
         end
+        @ast_lookup = ast_lookup
       end
 
       def to_s
         return if @issues.empty?
+
         result = Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
         result.flatten.join("\n")
       end
@@ -34,9 +36,12 @@ module Cucumber
 
       def scenario_listing(type, test_cases)
         return [] if test_cases.empty?
+
         [format_string("#{type_heading(type)} Scenarios:", type)] + test_cases.map do |test_case|
-          source = @config.source? ? format_string(" # #{test_case.keyword}: #{test_case.name}", :comment) : ''
-          format_string("cucumber #{profiles_string}" + test_case.location, type) + source
+          scenario_source = @ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          source = @config.source? ? format_string(" # #{keyword}: #{test_case.name}", :comment) : ''
+          format_string("cucumber #{profiles_string}#{test_case.location.file}:#{test_case.location.lines.max}", type) + source
         end
       end
 
@@ -51,7 +56,10 @@ module Cucumber
 
       def profiles_string
         return if @config.custom_profiles.empty?
-        @config.custom_profiles.map { |profile| "-p #{profile}" }.join(' ') + ' '
+
+        profiles = @config.custom_profiles.map { |profile| "-p #{profile}" }.join(' ')
+
+        "#{profiles} "
       end
     end
   end

data/lib/cucumber/formatter/duration.rb

@@ -8,7 +8,7 @@ module Cucumber
       # <tt>time</tt> format.
       def format_duration(seconds)
         m, s = seconds.divmod(60)
-        "#{m}m#{format('%.3f', s)}s"
+        "#{m}m#{format('%<seconds>.3f', seconds: s)}s"
       end
     end
   end

data/lib/cucumber/formatter/duration_extractor.rb

@@ -4,6 +4,7 @@ module Cucumber
   module Formatter
     class DurationExtractor
       attr_reader :result_duration
+
       def initialize(result)
         @result_duration = 0
         result.describe_to(self)
@@ -22,8 +23,10 @@ module Cucumber
       def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @result_duration = duration.nanoseconds / 10**9.0 }
+        duration.tap { |dur| @result_duration = dur.nanoseconds / 10**9.0 }
       end
+
+      def attach(*) end
     end
   end
 end

data/lib/cucumber/formatter/errors.rb

@@ -0,0 +1,7 @@
+module Cucumber
+  module Formatter
+    class TestCaseUnknownError < StandardError; end
+
+    class TestStepUnknownError < StandardError; end
+  end
+end

data/lib/cucumber/formatter/fanout.rb

@@ -13,13 +13,15 @@ module Cucumber
       end
 
       def method_missing(message, *args)
+        super unless recipients
+
         recipients.each do |recipient|
           recipient.send(message, *args) if recipient.respond_to?(message)
         end
       end
 
       def respond_to_missing?(name, include_private = false)
-        recipients.any? { |recipient| recipient.respond_to?(name, include_private) }
+        recipients.any? { |recipient| recipient.respond_to?(name, include_private) } || super(name, include_private)
       end
     end
   end