cucumber 3.1.2 → 7.1.0

data/lib/cucumber/formatter/ast_lookup.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    class AstLookup
+      def initialize(config)
+        @gherkin_documents = {}
+        @test_case_lookups = {}
+        @test_step_lookups = {}
+        @step_keyword_lookups = {}
+        config.on_event :gherkin_source_parsed, &method(:on_gherkin_source_parsed)
+      end
+
+      def on_gherkin_source_parsed(event)
+        @gherkin_documents[event.gherkin_document.uri] = event.gherkin_document
+      end
+
+      def gherkin_document(uri)
+        @gherkin_documents[uri]
+      end
+
+      def scenario_source(test_case)
+        uri = test_case.location.file
+        @test_case_lookups[uri] ||= TestCaseLookupBuilder.new(gherkin_document(uri)).lookup_hash
+        @test_case_lookups[uri][test_case.location.lines.max]
+      end
+
+      def step_source(test_step)
+        uri = test_step.location.file
+        @test_step_lookups[uri] ||= TestStepLookupBuilder.new(gherkin_document(uri)).lookup_hash
+        @test_step_lookups[uri][test_step.location.lines.min]
+      end
+
+      def snippet_step_keyword(test_step)
+        uri = test_step.location.file
+        document = gherkin_document(uri)
+        dialect = ::Gherkin::Dialect.for(document.feature.language)
+        given_when_then_keywords = [dialect.given_keywords, dialect.when_keywords, dialect.then_keywords].flatten.uniq.reject { |kw| kw == '* ' }
+        keyword_lookup = step_keyword_lookup(uri)
+        keyword = nil
+        node = keyword_lookup[test_step.location.lines.min]
+        while keyword.nil?
+          if given_when_then_keywords.include?(node.keyword)
+            keyword = node.keyword
+            break
+          end
+          break if node.previous_node.nil?
+          node = node.previous_node
+        end
+        keyword = dialect.given_keywords.reject { |kw| kw == '* ' }[0] if keyword.nil?
+        keyword = Cucumber::Gherkin::I18n.code_keyword_for(keyword)
+        keyword
+      end
+
+      ScenarioSource = Struct.new(:type, :scenario)
+
+      ScenarioOutlineSource = Struct.new(:type, :scenario_outline, :examples, :row)
+
+      StepSource = Struct.new(:type, :step)
+
+      private
+
+      def step_keyword_lookup(uri)
+        @step_keyword_lookups[uri] ||= KeywordLookupBuilder.new(gherkin_document(uri)).lookup_hash
+      end
+
+      class TestCaseLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature)
+        end
+
+        private
+
+        def process_scenario_container(container)
+          container.children.each do |child|
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule)
+            elsif child.respond_to?(:scenario) && child.scenario
+              process_scenario(child)
+            end
+          end
+        end
+
+        def process_scenario(child)
+          if child.scenario.examples.empty?
+            @lookup_hash[child.scenario.location.line] = ScenarioSource.new(:Scenario, child.scenario)
+          else
+            child.scenario.examples.each do |examples|
+              examples.table_body.each do |row|
+                @lookup_hash[row.location.line] = ScenarioOutlineSource.new(:ScenarioOutline, child.scenario, examples, row)
+              end
+            end
+          end
+        end
+      end
+
+      class TestStepLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature)
+        end
+
+        private
+
+        def process_scenario_container(container)
+          container.children.each do |child|
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule)
+            elsif child.respond_to?(:scenario) && child.scenario
+              child.scenario.steps.each do |step|
+                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+              end
+            elsif !child.background.nil?
+              child.background.steps.each do |step|
+                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+              end
+            end
+          end
+        end
+      end
+
+      KeywordSearchNode = Struct.new(:keyword, :previous_node)
+
+      class KeywordLookupBuilder
+        attr_reader :lookup_hash
+
+        def initialize(gherkin_document)
+          @lookup_hash = {}
+          process_scenario_container(gherkin_document.feature, nil)
+        end
+
+        private
+
+        def process_scenario_container(container, original_previous_node)
+          container.children.each do |child|
+            previous_node = original_previous_node
+            if child.respond_to?(:rule) && child.rule
+              process_scenario_container(child.rule, original_previous_node)
+            elsif child.respond_to?(:scenario) && child.scenario
+              child.scenario.steps.each do |step|
+                node = KeywordSearchNode.new(step.keyword, previous_node)
+                @lookup_hash[step.location.line] = node
+                previous_node = node
+              end
+            elsif child.respond_to?(:background) && child.background
+              child.background.steps.each do |step|
+                node = KeywordSearchNode.new(step.keyword, previous_node)
+                @lookup_hash[step.location.line] = node
+                previous_node = node
+                original_previous_node = previous_node
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -4,22 +4,24 @@ require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    @backtrace_filters = %w(
+    @backtrace_filters = %w[
       /vendor/rails
       lib/cucumber
       bin/cucumber:
       lib/rspec
       gems/
+      site_ruby/
       minitest
       test/unit
       .gem/ruby
-      lib/ruby/
       bin/bundle
-    )
+      rdebug-ide
+    ]
 
-    if ::Cucumber::JRUBY
-      @backtrace_filters << 'org/jruby/'
-    end
+    @backtrace_filters << RbConfig::CONFIG['rubyarchdir'] if RbConfig::CONFIG['rubyarchdir']
+    @backtrace_filters << RbConfig::CONFIG['rubylibdir'] if RbConfig::CONFIG['rubylibdir']
+
+    @backtrace_filters << 'org/jruby/' if ::Cucumber::JRUBY
 
     BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
 
@@ -31,7 +33,7 @@ module Cucumber
       def exception
         return @exception if ::Cucumber.use_full_backtrace
 
-        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
+        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m # rubocop:disable Style/RegexpLiteral
         backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, './') }
 
         filtered = (backtrace || []).reject do |line|
@@ -41,7 +43,7 @@ module Cucumber
         if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
           # Strip off file locations
           filtered = filtered.map do |line|
-            line =~ /(.*):in `/ ? $1 : line
+            line =~ /(.*):in `/ ? Regexp.last_match(1) : line
           end
         end
 

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.to_s), 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,40 @@ 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)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }.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 +148,14 @@ 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 +167,55 @@ 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 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))
+      def attach(src, media_type)
+        return unless media_type == 'text/x.cucumber.log+plain'
+        return unless @io
+        @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 }
@@ -225,10 +227,6 @@ module Cucumber
         fmt
       end
 
-      def hook?(test_step)
-        not test_step.source.last.respond_to?(:actual_keyword)
-      end
-
       def element_messages(elements, status)
         elements.map do |element|
           if status == :failed
@@ -249,9 +247,11 @@ 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,6 +18,7 @@ module Cucumber
             @issues[:failed].delete(event.test_case)
           end
         end
+        @ast_lookup = ast_lookup
       end
 
       def to_s
@@ -35,8 +36,10 @@ 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
 

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

@@ -22,8 +22,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,6 @@
+module Cucumber
+  module Formatter
+    class TestCaseUnknownError < StandardError; end
+    class TestStepUnknownError < StandardError; end
+  end
+end

data/lib/cucumber/formatter/fanout.rb

@@ -13,6 +13,8 @@ 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