cucumber 3.1.2 → 5.2.0

data/lib/cucumber/formatter/summary.rb

@@ -5,6 +5,7 @@ require 'cucumber/formatter/console'
 require 'cucumber/formatter/console_counts'
 require 'cucumber/formatter/console_issues'
 require 'cucumber/core/test/result'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
@@ -14,9 +15,11 @@ module Cucumber
       include Console
 
       def initialize(config)
-        @config, @io = config, ensure_io(config.out_stream)
+        @config = config
+        @io = ensure_io(config.out_stream, config.error_stream)
+        @ast_lookup = AstLookup.new(config)
         @counts = ConsoleCounts.new(@config)
-        @issues = ConsoleIssues.new(@config)
+        @issues = ConsoleIssues.new(@config, @ast_lookup)
         @start_time = Time.now
 
         @config.on_event :test_case_started do |event|
@@ -28,7 +31,7 @@ module Cucumber
           print_result event.result
         end
 
-        @config.on_event :test_run_finished do |event|
+        @config.on_event :test_run_finished do |_event|
           duration = Time.now - @start_time
           @io.puts
           print_statistics(duration, @config, @counts, @issues)
@@ -37,12 +40,17 @@ module Cucumber
 
       private
 
+      def gherkin_document(uri)
+        @ast_lookup.gherkin_document(uri)
+      end
+
       def print_feature(test_case)
-        feature = test_case.feature
-        return if @current_feature == feature
-        @io.puts unless @current_feature.nil?
-        @io.puts feature
-        @current_feature = feature
+        uri = test_case.location.file
+        return if @current_feature_uri == uri
+        feature_name = gherkin_document(uri).feature.name
+        @io.puts unless @current_feature_uri.nil?
+        @io.puts feature_name
+        @current_feature_uri = uri
       end
 
       def print_test_case(test_case)

data/lib/cucumber/formatter/unicode.rb

@@ -9,39 +9,37 @@ if Cucumber::WINDOWS
   if ENV['CUCUMBER_OUTPUT_ENCODING']
     Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
   elsif `cmd /c chcp` =~ /(\d+)/
-    if [65000, 65001].include? $1.to_i
-      Cucumber::CODEPAGE = 'UTF-8'
+    if [65_000, 65_001].include? Regexp.last_match(1).to_i
+      Cucumber::CODEPAGE = 'UTF-8'.freeze
       ENV['ANSICON_API'] = 'ruby'
     else
-      Cucumber::CODEPAGE = "cp#{$1.to_i}"
+      Cucumber::CODEPAGE = "cp#{Regexp.last_match(1).to_i}".freeze
     end
   else
-    Cucumber::CODEPAGE = 'cp1252'
+    Cucumber::CODEPAGE = 'cp1252'.freeze
     STDERR.puts("WARNING: Couldn't detect your output codepage. Assuming it is 1252. You may have to chcp 1252 or SET CUCUMBER_OUTPUT_ENCODING=cp1252.")
   end
 
   module Cucumber
     # @private
     module WindowsOutput
-      def self.extended(o)
-        o.instance_eval do
-          def cucumber_preprocess_output(*a)
-            begin
-              a.map { |arg| arg.to_s.encode(Encoding.default_external) }
-            rescue Encoding::UndefinedConversionError => e
-              STDERR.cucumber_puts("WARNING: #{e.message}")
-              a
-            end
+      def self.extended(output)
+        output.instance_eval do
+          def cucumber_preprocess_output(*out)
+            out.map { |arg| arg.to_s.encode(Encoding.default_external) }
+          rescue Encoding::UndefinedConversionError => e
+            STDERR.cucumber_puts("WARNING: #{e.message}")
+            out
           end
 
           alias cucumber_print print
-          def print(*a)
-            cucumber_print(*cucumber_preprocess_output(*a))
+          def print(*out)
+            cucumber_print(*cucumber_preprocess_output(*out))
           end
 
           alias cucumber_puts puts
-          def puts(*a)
-            cucumber_puts(*cucumber_preprocess_output(*a))
+          def puts(*out)
+            cucumber_puts(*cucumber_preprocess_output(*out))
           end
         end
       end

data/lib/cucumber/formatter/url_reporter.rb

@@ -0,0 +1,17 @@
+module Cucumber
+  module Formatter
+    class URLReporter
+      def initialize(io)
+        @io = io
+      end
+
+      def report(banner)
+        @io.puts(banner)
+      end
+    end
+
+    class NoReporter
+      def report(banner); end
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -17,7 +17,7 @@ module Cucumber
         @matches = {}
         config.on_event :step_activated do |event|
           test_step, step_match = *event.attributes
-          @matches[test_step.source] = step_match
+          @matches[test_step.to_s] = step_match
         end
         config.on_event :step_definition_registered, &method(:on_step_definition_registered)
       end
@@ -28,25 +28,26 @@ module Cucumber
       end
 
       def on_step_match(event)
-        @matches[event.test_step.source] = event.step_match
+        @matches[event.test_step.to_s] = event.step_match
         super
       end
 
       def on_test_step_finished(event)
-        return if HookQueryVisitor.new(event.test_step).hook?
+        return if event.test_step.hook?
 
         test_step = event.test_step
         result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
-        step_match = @matches[test_step.source]
+        step_match = @matches[test_step.to_s]
 
         unless step_match.nil?
           step_definition = step_match.step_definition
           stepdef_key = StepDefKey.new(step_definition.expression.to_s, step_definition.location)
           unless @stepdef_to_match[stepdef_key].map { |key| key[:location] }.include? test_step.location
             duration = DurationExtractor.new(result).result_duration
+            keyword = @ast_lookup.step_source(test_step).step.keyword
 
             @stepdef_to_match[stepdef_key] << {
-              keyword: test_step.source.last.keyword,
+              keyword: keyword,
               step_match: step_match,
               status: result.to_sym,
               location: test_step.location,
@@ -64,9 +65,9 @@ module Cucumber
         aggregate_info
 
         keys = if config.dry_run?
-                 @stepdef_to_match.keys.sort { |a, b| a.regexp_source <=> b.regexp_source }
+                 @stepdef_to_match.keys.sort_by(&:regexp_source)
                else
-                 @stepdef_to_match.keys.sort { |a, b| a.mean_duration <=> b.mean_duration }.reverse
+                 @stepdef_to_match.keys.sort_by(&:mean_duration).reverse
                end
 
         keys.each do |stepdef_key|
@@ -83,7 +84,7 @@ module Cucumber
       end
 
       def print_step_definition(stepdef_key)
-        @io.print format_string(format('%.7f', stepdef_key.mean_duration), :skipped) + ' ' unless config.dry_run?
+        @io.print format_string(format('%<duration>.7f', duration: stepdef_key.mean_duration), :skipped) + ' ' unless config.dry_run?
         @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
         if config.source?
           indent = max_length - stepdef_key.regexp_source.unpack('U*').length
@@ -96,7 +97,7 @@ module Cucumber
       def print_steps(stepdef_key)
         @stepdef_to_match[stepdef_key].each do |step|
           @io.print '  '
-          @io.print format_string(format('%.7f', step[:duration]), :skipped) + ' ' unless config.dry_run?
+          @io.print format_string(format('%<duration>.7f', duration: step[:duration]), :skipped) + ' ' unless config.dry_run?
           @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
           if config.source?
             indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
@@ -135,7 +136,7 @@ module Cucumber
       end
 
       def worst_status(statuses)
-        [:passed, :undefined, :pending, :skipped, :failed].find do |status|
+        %i[passed undefined pending skipped failed].find do |status|
           statuses.include?(status)
         end
       end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'gherkin/token_scanner'
-require 'gherkin/parser'
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -12,15 +11,27 @@ module Cucumber
       end
 
       def parse(text)
-        token_scanner = ::Gherkin::TokenScanner.new(feature_header + text)
-        parser = ::Gherkin::Parser.new
-        gherkin_document = parser.parse(token_scanner)
+        gherkin_document = nil
+        messages = ::Gherkin.from_source('dummy', feature_header + text, gherkin_options)
 
-        gherkin_document[:feature][:children][0][:steps][0][:argument][:rows].each do |row|
+        messages.each do |message|
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+        end
+
+        return if gherkin_document.nil?
+        gherkin_document[:feature][:children][0][:scenario][:steps][0][:data_table][:rows].each do |row|
           @builder.row(row[:cells].map { |cell| cell[:value] })
         end
       end
 
+      def gherkin_options
+        {
+          include_source: false,
+          include_gherkin_document: true,
+          include_pickles: false
+        }
+      end
+
       def feature_header
         dialect = ::Gherkin::Dialect.for('en')
         %(#{dialect.feature_keywords[0]}:

data/lib/cucumber/gherkin/formatter/ansi_escapes.rb

@@ -51,23 +51,21 @@ module Cucumber
           'white'   => "\e[37m",
           'grey'    => "\e[90m",
           'bold'    => "\e[1m"
-        }
+        }.freeze
 
         ALIASES = Hash.new do |h, k|
-          if k.to_s =~ /(.*)_arg/
-            h[$1] + ',bold'
-          end
-        end.merge({
-                    'undefined' => 'yellow',
-                    'pending'   => 'yellow',
-                    'executing' => 'grey',
-                    'failed'    => 'red',
-                    'passed'    => 'green',
-                    'outline'   => 'cyan',
-                    'skipped'   => 'cyan',
-                    'comments'  => 'grey',
-                    'tag'       => 'cyan'
-                  })
+          h[Regexp.last_match(1)] + ',bold' if k.to_s =~ /(.*)_arg/
+        end.merge(
+          'undefined' => 'yellow',
+          'pending'   => 'yellow',
+          'executing' => 'grey',
+          'failed'    => 'red',
+          'passed'    => 'green',
+          'outline'   => 'cyan',
+          'skipped'   => 'cyan',
+          'comments'  => 'grey',
+          'tag'       => 'cyan'
+        )
 
         if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
           ENV['GHERKIN_COLORS'].split(':').each do |pair|
@@ -93,8 +91,6 @@ module Cucumber
         def up(n)
           "\e[#{n}A"
         end
-
-        extend self
       end
     end
   end

data/lib/cucumber/gherkin/formatter/escaping.rb

@@ -10,8 +10,8 @@ module Cucumber
         # * \ becomes \\
         #
         # This is used in the pretty formatter.
-        def escape_cell(s)
-          s.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
+        def escape_cell(sym)
+          sym.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
         end
       end
     end

data/lib/cucumber/gherkin/steps_parser.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'gherkin/token_scanner'
-require 'gherkin/token_matcher'
-require 'gherkin/parser'
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -15,12 +13,23 @@ module Cucumber
 
       def parse(text)
         dialect = ::Gherkin::Dialect.for(@language)
-        token_matcher = ::Gherkin::TokenMatcher.new(@language)
-        token_scanner = ::Gherkin::TokenScanner.new(feature_header(dialect) + text)
-        parser = ::Gherkin::Parser.new
-        gherkin_document = parser.parse(token_scanner, token_matcher)
+        gherkin_document = nil
+        messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
 
-        @builder.steps(gherkin_document[:feature][:children][0][:steps])
+        messages.each do |message|
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+        end
+
+        @builder.steps(gherkin_document[:feature][:children][0][:scenario][:steps])
+      end
+
+      def gherkin_options
+        {
+          default_dialect: @language,
+          include_source: false,
+          include_gherkin_document: true,
+          include_pickles: false
+        }
       end
 
       def feature_header(dialect)

data/lib/cucumber/glue/hook.rb

@@ -6,14 +6,15 @@ module Cucumber
   module Glue
     # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
     class Hook
-      attr_reader :tag_expressions, :location
+      attr_reader :id, :tag_expressions, :location
 
-      def initialize(registry, tag_expressions, proc)
+      def initialize(id, registry, tag_expressions, proc)
+        @id = id
         @registry = registry
-        @tag_expressions = tag_expressions
+        @tag_expressions = sanitize_tag_expressions(tag_expressions)
         @proc = proc
-        @location = Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
-        warn_for_old_style_tag_expressions(tag_expressions)
+        @location = Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
+        fail_for_old_style_tag_expressions(@tag_expressions)
       end
 
       def invoke(pseudo_method, arguments, &block)
@@ -27,16 +28,38 @@ module Cucumber
         )
       end
 
+      def to_envelope
+        Cucumber::Messages::Envelope.new(
+          hook: Cucumber::Messages::Hook.new(
+            id: id,
+            tag_expression: tag_expressions.join(' '),
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: location.file,
+              location: Cucumber::Messages::Location.new(
+                line: location.lines.first
+              )
+            )
+          )
+        )
+      end
+
       private
 
-      def warn_for_old_style_tag_expressions(tag_expressions)
+      def sanitize_tag_expressions(tag_expressions)
+        # TODO: remove when '~@no-clobber' has been changed to 'not @no-clobber' in aruba
+        tag_expressions.map { |tag_expression| tag_expression == '~@no-clobber' ? 'not @no-clobber' : tag_expression }
+      end
+
+      def fail_for_old_style_tag_expressions(tag_expressions)
         tag_expressions.each do |tag_expression|
-          if tag_expression.include?('~') && tag_expression != '~@no-clobber' # ~@no-clobber is used in aruba
-            warn("Deprecated: Found tagged hook with '#{tag_expression}'. Support for '~@tag' will be removed from the next release of Cucumber. Please use 'not @tag' instead.")
-          end
-          if tag_expression.include?(',')
-            warn("Deprecated: Found tagged hook with '#{tag_expression}'. Support for '@tag1,@tag2' will be removed from the next release of Cucumber. Please use '@tag or @tag2' instead.")
+          if tag_expression.include?('~')
+            raise("Found tagged hook with '#{tag_expression}'." \
+            "'~@tag' is no longer supported, use 'not @tag' instead.")
           end
+
+          next unless tag_expression.include?(',')
+          warn("Found tagged hook with '#{tag_expression}'." \
+            "'@tag1,@tag2' is no longer supported, use '@tag or @tag2' instead.")
         end
       end
     end

data/lib/cucumber/glue/invoke_in_world.rb

@@ -11,16 +11,15 @@ module Cucumber
         return if Cucumber.use_full_backtrace
 
         instance_exec_pos = backtrace.index(instance_exec_invocation_line)
-        if instance_exec_pos
-          replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
-          backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+        return unless instance_exec_pos
+        replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+        backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
 
-          depth = backtrace.count { |line| line == instance_exec_invocation_line }
-          end_pos = depth > 1 ? instance_exec_pos : -1
+        depth = backtrace.count { |line| line == instance_exec_invocation_line }
+        end_pos = depth > 1 ? instance_exec_pos : -1
 
-          backtrace[replacement_line + 1..end_pos] = nil
-          backtrace.compact!
-        end
+        backtrace[replacement_line + 1..end_pos] = nil
+        backtrace.compact!
       end
 
       def self.cucumber_instance_exec_in(world, check_arity, pseudo_method, *args, &block)
@@ -31,9 +30,7 @@ module Cucumber
               ari = ari < 0 ? (ari.abs - 1).to_s + '+' : ari
               s1 = ari == 1 ? '' : 's'
               s2 = args.length == 1 ? '' : 's'
-              raise ArityMismatchError.new(
-                "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
-              )
+              raise ArityMismatchError, "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
             end
           else
             world.instance_exec(*args, &block)
@@ -50,13 +47,11 @@ module Cucumber
       end
 
       def self.cucumber_run_with_backtrace_filtering(pseudo_method)
-        begin
-          yield
-        rescue Exception => e
-          instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
-          replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
-          raise e
-        end
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
+        replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+        raise e
       end
 
       INSTANCE_EXEC_OFFSET = -3