cucumber 3.1.2 → 4.0.0.rc.1

data/lib/cucumber/formatter/ast_lookup.rb

@@ -0,0 +1,160 @@
+# 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[:rule].nil?
+              process_scenario_container(child[:rule])
+            elsif !child[:scenario].nil?
+              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
+        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[:rule].nil?
+              process_scenario_container(child[:rule])
+            elsif !child[:scenario].nil?
+              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[:rule].nil?
+              process_scenario_container(child[:rule], original_previous_node)
+            elsif !child[:scenario].nil?
+              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[:background].nil?
+              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,7 +4,7 @@ require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    @backtrace_filters = %w(
+    @backtrace_filters = %w[
       /vendor/rails
       lib/cucumber
       bin/cucumber:
@@ -15,11 +15,9 @@ module Cucumber
       .gem/ruby
       lib/ruby/
       bin/bundle
-    )
+    ]
 
-    if ::Cucumber::JRUBY
-      @backtrace_filters << 'org/jruby/'
-    end
+    @backtrace_filters << 'org/jruby/' if ::Cucumber::JRUBY
 
     BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
 
@@ -31,7 +29,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 +39,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

@@ -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?
 
@@ -109,26 +105,23 @@ module Cucumber
       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 print_snippets(options)
         return unless options[:snippets]
-        return if runtime.steps(:undefined).empty?
+        return if @snippets_input.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)
       end
@@ -146,10 +139,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)
@@ -165,51 +162,26 @@ module Cucumber
         # 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
+        return unless @io
+        @io.puts
+        messages.each do |message|
+          @io.puts(format_string(message, :tag))
         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))
         @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
@@ -225,10 +197,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,7 +217,8 @@ 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

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_extractor.rb

@@ -22,7 +22,7 @@ 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
     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

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -8,7 +8,7 @@ module Cucumber
       end
 
       def method_missing(message, *args)
-        @receiver.send(message, *args) if @receiver.respond_to?(message)
+        @receiver.respond_to?(message) ? @receiver.send(message, *args) : super
       end
 
       def respond_to_missing?(name, include_private = false)

data/lib/cucumber/formatter/interceptor.rb

@@ -43,17 +43,15 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk)
+          @pipe.send(method, *args, &blk) || super
         end
 
-        def respond_to?(method, include_private = false)
+        def respond_to_missing?(method, include_private = false)
           super || @pipe.respond_to?(method, include_private)
         end
 
         def self.validate_pipe(pipe)
-          unless [:stdout, :stderr].include? pipe
-            raise ArgumentError, '#wrap only accepts :stderr or :stdout'
-          end
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
         end
 
         def self.unwrap!(pipe)
@@ -75,10 +73,10 @@ module Cucumber
 
           case pipe
           when :stderr
-            $stderr = self.new($stderr)
+            $stderr = new($stderr)
             return $stderr
           when :stdout
-            $stdout = self.new($stdout)
+            $stdout = new($stdout)
             return $stdout
           end
         end