cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/formatter/usage.rb

@@ -1,60 +1,74 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/progress'
 require 'cucumber/step_definition_light'
 
 module Cucumber
   module Formatter
     class Usage < Progress
-      include Console
-
       class StepDefKey < StepDefinitionLight
         attr_accessor :mean_duration, :status
       end
 
-      def initialize(runtime, path_or_io, options)
-        @runtime = runtime
-        @io = ensure_io(path_or_io, "usage")
-        @options = options
-        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
-      end
-
-      def before_features(features)
-        print_profile_information
+      def initialize(config)
+        super
+        @stepdef_to_match = Hash.new { |h, stepdef_key| h[stepdef_key] = [] }
+        @total_duration = 0
+        @matches = {}
+        config.on_event :step_activated do |event|
+          test_step, step_match = *event.attributes
+          @matches[test_step.to_s] = step_match
+        end
+        config.on_event :step_definition_registered, &method(:on_step_definition_registered)
       end
 
-      def before_step(step)
-        @step = step
-        @start_time = Time.now
+      def on_step_definition_registered(event)
+        stepdef_key = StepDefKey.new(event.step_definition.expression.to_s, event.step_definition.location)
+        @stepdef_to_match[stepdef_key] = []
       end
 
-      def before_step_result(*args)
-        @duration = Time.now - @start_time
+      def on_step_match(event)
+        @matches[event.test_step.to_s] = event.step_match
+        super
       end
 
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        step_definition = step_match.step_definition
-        unless step_definition.nil? # nil if it's from a scenario outline
-          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
-
-          @stepdef_to_match[stepdef_key] << {
-            :keyword => keyword,
-            :step_match => step_match,
-            :status => status,
-            :file_colon_line => @step.file_colon_line,
-            :duration => @duration
-          }
+      def on_test_step_finished(event)
+        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.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
 
-      def print_summary(features)
-        add_unused_stepdefs
+      private
+
+      def print_summary
         aggregate_info
 
-        if @options[:dry_run]
-          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
-        else
-          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
-        end
+        keys = if config.dry_run?
+                 @stepdef_to_match.keys.sort_by(&:regexp_source)
+               else
+                 @stepdef_to_match.keys.sort_by(&:mean_duration).reverse
+               end
 
         keys.each do |stepdef_key|
           print_step_definition(stepdef_key)
@@ -62,7 +76,7 @@ module Cucumber
           if @stepdef_to_match[stepdef_key].any?
             print_steps(stepdef_key)
           else
-            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
+            @io.puts('  ' + format_string('NOT MATCHED BY ANY STEPS', :failed))
           end
         end
         @io.puts
@@ -70,11 +84,11 @@ module Cucumber
       end
 
       def print_step_definition(stepdef_key)
-        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[: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 @options[:source]
+        if config.source?
           indent = max_length - stepdef_key.regexp_source.unpack('U*').length
-          line_comment = "   # #{stepdef_key.file_colon_line}".indent(indent)
+          line_comment = "   # #{stepdef_key.location}".indent(indent)
           @io.print(format_string(line_comment, :comment))
         end
         @io.puts
@@ -82,12 +96,12 @@ module Cucumber
 
       def print_steps(stepdef_key)
         @stepdef_to_match[stepdef_key].each do |step|
-          @io.print "  "
-          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print '  '
+          @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 @options[:source]
+          if config.source?
             indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
-            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            line_comment = " # #{step[:location]}".indent(indent)
             @io.print(format_string(line_comment, :comment))
           end
           @io.puts
@@ -99,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
@@ -114,25 +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
-
-      def add_unused_stepdefs
-        @runtime.unmatched_step_definitions.each do |step_definition|
-          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
-          @stepdef_to_match[stepdef_key] = []
-        end
-      end
     end
   end
 end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'gherkin'
+require 'gherkin/dialect'
+
+module Cucumber
+  module Gherkin
+    class DataTableParser
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def parse(text)
+        gherkin_document = nil
+        messages = ::Gherkin.from_source('dummy', feature_header + text, gherkin_options)
+
+        messages.each do |message|
+          gherkin_document = message.gherkinDocument.to_hash unless message.gherkinDocument.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]}:
+            #{dialect.scenario_keywords[0]}:
+              #{dialect.given_keywords[0]} x
+         )
+      end
+    end
+  end
+end

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

@@ -0,0 +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"
+        }.freeze
+
+        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]
+          end
+        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('')
+          end
+        end
+
+        def reset
+          "\e[0m"
+        end
+
+        def up(n)
+          "\e[#{n}A"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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(sym)
+          sym.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/i18n.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Gherkin
+    module I18n
+      class << self
+        def code_keyword_for(gherkin_keyword)
+          gherkin_keyword.gsub(/[\s',!]/, '').strip
+        end
+
+        def code_keywords_for(gherkin_keywords)
+          gherkin_keywords.reject { |kw| kw == '* ' }.map { |kw| code_keyword_for(kw) }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/steps_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'gherkin'
+require 'gherkin/dialect'
+
+module Cucumber
+  module Gherkin
+    class StepsParser
+      def initialize(builder, language)
+        @builder = builder
+        @language = language
+      end
+
+      def parse(text)
+        dialect = ::Gherkin::Dialect.for(@language)
+        gherkin_document = nil
+        messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
+
+        messages.each do |message|
+          gherkin_document = message.gherkinDocument.to_hash unless message.gherkinDocument.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)
+        %(#{dialect.feature_keywords[0]}:
+            #{dialect.scenario_keywords[0]}:
+         )
+      end
+    end
+  end
+end

data/lib/cucumber/{rb_support/rb_dsl.rb → glue/dsl.rb}

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/deprecate'
+
 module Cucumber
-  module RbSupport
-    # This module defines the methods you can use to define pure Ruby
-    # Step Definitions and Hooks. This module is mixed into the toplevel
-    # object.
-    module RbDsl
+  module Glue
+    # This module provides the methods the DSL you can use to define
+    # steps, hooks, transforms etc.
+    module Dsl
       class << self
         attr_writer :rb_language
 
@@ -11,16 +15,16 @@ module Cucumber
           alias_method adverb, :register_rb_step_definition
         end
 
-        def build_rb_world_factory(world_modules, proc)
-          @rb_language.build_rb_world_factory(world_modules, proc)
+        def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
+          @rb_language.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
         end
 
         def register_rb_hook(phase, tag_names, proc)
           @rb_language.register_rb_hook(phase, tag_names, proc)
         end
 
-        def register_rb_transform(regexp, proc)
-          @rb_language.register_rb_transform(regexp, proc)
+        def define_parameter_type(parameter_type)
+          @rb_language.define_parameter_type(parameter_type)
         end
 
         def register_rb_step_definition(regexp, proc_or_sym, options = {})
@@ -33,6 +37,10 @@ module Cucumber
       # Object that the scenario's steps will run within. Any +world_modules+
       # will be mixed into this Object (via Object#extend).
       #
+      # By default the +world modules+ are added to a global namespace. It is
+      # possible to create a namespaced World by using an hash, where the
+      # symbols are the namespaces.
+      #
       # This method is typically called from one or more Ruby scripts under
       # <tt>features/support</tt>. You can call this method as many times as you
       # like (to register more modules), but if you try to register more than
@@ -46,20 +54,22 @@ module Cucumber
       #
       #    World(MyModule)
       #
-      def World(*world_modules, &proc)
-        RbDsl.build_rb_world_factory(world_modules, proc)
+      #    World(my_module: MyModule)
+      #
+      def World(*world_modules, **namespaced_world_modules, &proc)
+        Dsl.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
       end
 
       # Registers a proc that will run before each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def Before(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('before', tag_expressions, proc)
+        Dsl.register_rb_hook('before', tag_expressions, proc)
       end
 
       # Registers a proc that will run after each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def After(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('after', tag_expressions, proc)
+        Dsl.register_rb_hook('after', tag_expressions, proc)
       end
 
       # Registers a proc that will be wrapped around each scenario. The proc
@@ -68,29 +78,39 @@ module Cucumber
       # blocks in 1.8), on which it should call the .call method. You can register
       # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def Around(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('around', tag_expressions, proc)
+        Dsl.register_rb_hook('around', tag_expressions, proc)
       end
 
       # Registers a proc that will run after each Step. You can register as
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def AfterStep(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('after_step', tag_expressions, proc)
+        Dsl.register_rb_hook('after_step', tag_expressions, proc)
+      end
+
+      def ParameterType(options)
+        type = options[:type] || Object
+        use_for_snippets = if_nil(options[:use_for_snippets], true)
+        prefer_for_regexp_match = if_nil(options[:prefer_for_regexp_match], false)
+
+        parameter_type = CucumberExpressions::ParameterType.new(
+          options[:name],
+          options[:regexp],
+          type,
+          options[:transformer],
+          use_for_snippets,
+          prefer_for_regexp_match
+        )
+        Dsl.define_parameter_type(parameter_type)
       end
 
-      # Registers a proc that will be called with a step definition argument if it
-      # matches the pattern passed as the first argument to Transform. Alternatively, if
-      # the pattern contains captures then they will be yielded as arguments to the
-      # provided proc. The return value of the proc is consequently yielded to the
-      # step definition.
-      def Transform(regexp, &proc)
-        RbDsl.register_rb_transform(regexp, proc)
+      def if_nil(value, default)
+        value.nil? ? default : value
       end
 
       # Registers a proc that will run after Cucumber is configured. You can register as
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      # TODO: Deprecate this
       def AfterConfiguration(&proc)
-        RbDsl.register_rb_hook('after_configuration', [], proc)
+        Dsl.register_rb_hook('after_configuration', [], proc)
       end
 
       # Registers a new Ruby StepDefinition. This method is aliased
@@ -110,10 +130,11 @@ module Cucumber
       # the context of the <tt>World</tt> object.
       def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
         proc_or_sym = symbol || proc
-        RbDsl.register_rb_step_definition(regexp, proc_or_sym, options)
+        Dsl.register_rb_step_definition(regexp, proc_or_sym, options)
       end
     end
   end
 end
 
-extend(Cucumber::RbSupport::RbDsl)
+# TODO: can we avoid adding methods to the global namespace (Kernel)
+extend(Cucumber::Glue::Dsl) # rubocop:disable Style/MixinUsage