cucumber 3.0.2 → 4.0.0

data/lib/cucumber/formatter/unicode.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Require this file if you need Unicode support.
 # Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
 require 'cucumber/platform'
@@ -8,40 +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/usage.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require 'cucumber/formatter/progress'
 require 'cucumber/step_definition_light'
 
 module Cucumber
   module Formatter
     class Usage < Progress
-
       class StepDefKey < StepDefinitionLight
         attr_accessor :mean_duration, :status
       end
@@ -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,29 +28,34 @@ 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_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
-
-          @stepdef_to_match[stepdef_key] << {
-            keyword: test_step.source.last.keyword,
-            step_match: step_match,
-            status: result.to_sym,
-            location: test_step.location,
-            duration: duration
-          }
+        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: keyword,
+              step_match: step_match,
+              status: result.to_sym,
+              location: test_step.location,
+              duration: duration
+            }
+          end
         end
+
         super
       end
 
@@ -60,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|
@@ -79,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
@@ -92,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)
@@ -108,7 +113,7 @@ module Cucumber
       end
 
       def max_stepdef_length
-        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.unpack('U*').length}.max
+        @stepdef_to_match.keys.flatten.map { |key| key.regexp_source.unpack('U*').length }.max
       end
 
       def max_step_length
@@ -123,19 +128,18 @@ module Cucumber
             key.status = :skipped
             key.mean_duration = 0
           else
-            key.status = worst_status(steps.map{ |step| step[:status] })
-            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.status = worst_status(steps.map { |step| step[:status] })
+            total_duration = steps.inject(0) { |sum, step| step[:duration] + sum }
             key.mean_duration = total_duration / steps.length
           end
         end
       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
-
     end
   end
 end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-require 'gherkin/token_scanner'
-require 'gherkin/parser'
+
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -11,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)
+
+        messages.each do |message|
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+        end
 
-        gherkin_document[:feature][:children][0][:steps][0][:argument][:rows].each do |row|
+        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

@@ -1,100 +1,97 @@
 # frozen_string_literal: true
+
 module Cucumber
-module Gherkin
-  module Formatter
-    # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
-    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
-    # tweak the familiar POSIX command <tt>ls</tt> with
-    # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
-    #
-    # The colours that you can change are:
-    #
-    # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
-    # <tt>pending</tt>::       defaults to <tt>yellow</tt>
-    # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
-    # <tt>executing</tt>::     defaults to <tt>grey</tt>
-    # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
-    # <tt>failed</tt>::        defaults to <tt>red</tt>
-    # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
-    # <tt>passed</tt>::        defaults to <tt>green</tt>
-    # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
-    # <tt>outline</tt>::       defaults to <tt>cyan</tt>
-    # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
-    # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
-    # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
-    # <tt>comment</tt>::       defaults to <tt>grey</tt>
-    # <tt>tag</tt>::           defaults to <tt>cyan</tt>
-    #
-    # For instance, if your shell has a black background and a green font (like the
-    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
-    # steps to be white instead of green. Examples:
-    #
-    #   export GHERKIN_COLORS="passed=white"
-    #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
-    #
-    # (If you're on Windows, use SET instead of export).
-    # To see what colours and effects are available, just run this in your shell:
-    #
-    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
-    #
-    # Although not listed, you can also use <tt>grey</tt>
-    module AnsiEscapes
-      COLORS = {
-        'black'   => "\e[30m",
-        'red'     => "\e[31m",
-        'green'   => "\e[32m",
-        'yellow'  => "\e[33m",
-        'blue'    => "\e[34m",
-        'magenta' => "\e[35m",
-        'cyan'    => "\e[36m",
-        'white'   => "\e[37m",
-        'grey'    => "\e[90m",
-        'bold'    => "\e[1m"
-      }
+  module Gherkin
+    module Formatter
+      # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
+      # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+      # tweak the familiar POSIX command <tt>ls</tt> with
+      # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
+      #
+      # The colours that you can change are:
+      #
+      # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
+      # <tt>pending</tt>::       defaults to <tt>yellow</tt>
+      # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
+      # <tt>executing</tt>::     defaults to <tt>grey</tt>
+      # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
+      # <tt>failed</tt>::        defaults to <tt>red</tt>
+      # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
+      # <tt>passed</tt>::        defaults to <tt>green</tt>
+      # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
+      # <tt>outline</tt>::       defaults to <tt>cyan</tt>
+      # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
+      # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
+      # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
+      # <tt>comment</tt>::       defaults to <tt>grey</tt>
+      # <tt>tag</tt>::           defaults to <tt>cyan</tt>
+      #
+      # For instance, if your shell has a black background and a green font (like the
+      # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+      # steps to be white instead of green. Examples:
+      #
+      #   export GHERKIN_COLORS="passed=white"
+      #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
+      #
+      # (If you're on Windows, use SET instead of export).
+      # To see what colours and effects are available, just run this in your shell:
+      #
+      #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+      #
+      # Although not listed, you can also use <tt>grey</tt>
+      module AnsiEscapes
+        COLORS = {
+          'black'   => "\e[30m",
+          'red'     => "\e[31m",
+          'green'   => "\e[32m",
+          'yellow'  => "\e[33m",
+          'blue'    => "\e[34m",
+          'magenta' => "\e[35m",
+          'cyan'    => "\e[36m",
+          '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'
-      })
+        ALIASES = Hash.new do |h, k|
+          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|
-          a = pair.split('=')
-          ALIASES[a[0]] = a[1]
+        if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+          ENV['GHERKIN_COLORS'].split(':').each do |pair|
+            a = pair.split('=')
+            ALIASES[a[0]] = a[1]
+          end
         end
-      end
 
-      ALIASES.keys.each do |key|
-        define_method(key) do
-          ALIASES[key].split(',').map{|color| COLORS[color]}.join('')
-        end
+        ALIASES.keys.each do |key|
+          define_method(key) do
+            ALIASES[key].split(',').map { |color| COLORS[color] }.join('')
+          end
 
-        define_method("#{key}_arg") do
-          ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
+          define_method("#{key}_arg") do
+            ALIASES["#{key}_arg"].split(',').map { |color| COLORS[color] }.join('')
+          end
         end
-      end
 
-      def reset
-        "\e[0m"
-      end
+        def reset
+          "\e[0m"
+        end
 
-      def up(n)
-        "\e[#{n}A"
+        def up(n)
+          "\e[#{n}A"
+        end
       end
-
-      extend self
     end
   end
 end
-end

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

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
+
 module Cucumber
-module Gherkin
-  module Formatter
-    module Escaping
-      # Escapes a pipes and backslashes:
-      #
-      # * | becomes \|
-      # * \ becomes \\
-      #
-      # This is used in the pretty formatter.
-      def escape_cell(s)
-        s.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
+  module Gherkin
+    module Formatter
+      module Escaping
+        # Escapes a pipes and backslashes:
+        #
+        # * | becomes \|
+        # * \ becomes \\
+        #
+        # This is used in the pretty formatter.
+        def escape_cell(sym)
+          sym.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
+        end
       end
     end
   end
 end
-end

data/lib/cucumber/gherkin/i18n.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Gherkin
     module I18n