cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/lib/cucumber/formatter/ast_lookup.rb

@@ -0,0 +1,165 @@
+# 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
+
+        # rubocop:disable Metrics/PerceivedComplexity
+        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
+        # rubocop:enable Metrics/PerceivedComplexity
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -1,15 +1,28 @@
 # frozen_string_literal: true
-require 'cucumber/platform'
 
+require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    BACKTRACE_FILTER_PATTERNS = \
-      [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|.gem\/ruby|lib\/ruby/]
-
-    if(::Cucumber::JRUBY)
-      BACKTRACE_FILTER_PATTERNS << /org\/jruby/
-    end
+    @backtrace_filters = %w[
+      /vendor/rails
+      lib/cucumber
+      bin/cucumber:
+      lib/rspec
+      gems/
+      site_ruby/
+      minitest
+      test/unit
+      .gem/ruby
+      bin/bundle
+    ]
+
+    @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('|'))
 
     class BacktraceFilter
       def initialize(exception)
@@ -19,17 +32,17 @@ module Cucumber
       def exception
         return @exception if ::Cucumber.use_full_backtrace
 
-        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
-        backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, "./") }
+        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|
-          BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
+          line =~ BACKTRACE_FILTER_PATTERNS
         end
 
         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
 
@@ -37,6 +50,5 @@ module Cucumber
         @exception
       end
     end
-
   end
 end

data/lib/cucumber/formatter/console.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
 require 'cucumber/gherkin/i18n'
 
 module Cucumber
   module Formatter
-
     # This module contains helper methods that are used by formatters that
     # print output to the terminal.
     #
@@ -32,11 +32,11 @@ module Cucumber
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-          c = ('# ' + step_match.location.to_s).indent(source_indent)
-          format_string(c, :comment)
-        else
-          ''
-        end
+                    c = ('# ' + step_match.location.to_s).indent(source_indent)
+                    format_string(c, :comment)
+                  else
+                    ''
+                  end
 
         format = format_for(status, :param)
         line = keyword + step_match.format_args(format) + comment
@@ -46,7 +46,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 +54,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?
 
@@ -102,42 +98,37 @@ module Cucumber
       end
 
       def exception_message_string(e, indent)
-        message = "#{e.message} (#{e.class})".dup.force_encoding("UTF-8")
+        message = "#{e.message} (#{e.class})".dup.force_encoding('UTF-8')
         message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
 
-        string = "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
+        "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
       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
-        unless hook?(test_step)
-          keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
-          @previous_step_keyword = keyword
-          if result.undefined?
-            @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
-          end
-        end
+        keyword = ast_lookup.snippet_step_keyword(test_step)
+        @snippets_input << Console::SnippetData.new(keyword, test_step)
       end
 
       def print_snippets(options)
         return unless options[:snippets]
-        return if runtime.steps(:undefined).empty?
+        return if @snippets_input.empty?
 
-        snippet_text_proc = lambda { |step_keyword, step_name, multiline_arg|
-          runtime.snippet_text(step_keyword, step_name, multiline_arg)
-        }
+        snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
+          snippet_text(step_keyword, step_name, multiline_arg)
+        end
         do_print_snippets(snippet_text_proc)
       end
 
       def do_print_snippets(snippet_text_proc)
         snippets = @snippets_input.map do |data|
-          snippet_text_proc.call(data.actual_keyword, data.step.name, data.step.multiline_arg)
+          snippet_text_proc.call(data.actual_keyword, data.step.text, data.step.multiline_arg)
         end.uniq
 
         text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
@@ -148,78 +139,51 @@ 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)
         if passed_messages.any?
           @io.puts format_string("\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:", :failed)
-          print_element_messages(passed_messages, :passed, "scenarios")
+          print_element_messages(passed_messages, :passed, 'scenarios')
         else
           @io.puts format_string("\nThe --wip switch was used, so the failures were expected. All is good.\n", :passed)
         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_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}..."
+        @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
       end
 
       private
 
-      FORMATS = Hash.new{ |hash, format| hash[format] = method(format).to_proc }
+      FORMATS = Hash.new { |hash, format| hash[format] = method(format).to_proc }
 
       def format_for(*keys)
         key = keys.join('_').to_sym
@@ -228,34 +192,30 @@ module Cucumber
         fmt
       end
 
-      def hook?(test_step)
-        not test_step.source.last.respond_to?(:actual_keyword)
-      end
-
       def element_messages(elements, status)
-        element_messages = elements.map do |element|
+        elements.map do |element|
           if status == :failed
-            message = exception_message_string(element.exception, 0)
+            exception_message_string(element.exception, 0)
           else
-            message = linebreaks(element.backtrace_line, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+            linebreaks(element.backtrace_line, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
           end
         end
       end
 
       def snippet_text(step_keyword, step_name, multiline_arg)
         keyword = Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip
-        config.snippet_generators.map { |generator|
+        config.snippet_generators.map do |generator|
           generator.call(keyword, step_name, multiline_arg, config.snippet_type)
-        }.join("\n")
+        end.join("\n")
       end
 
       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