cucumber 2.99.0 → 3.0.0

data/lib/cucumber/formatter/progress.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+require 'cucumber/core/report/summary'
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/console'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/duration_extractor'
 require 'cucumber/formatter/hook_query_visitor'
@@ -10,32 +15,60 @@ module Cucumber
       include Console
       include Io
       attr_reader :runtime
+      attr_reader :config, :summary
 
-      def initialize(runtime, path_or_io, options)
-        @runtime, @io, @options = runtime, ensure_io(path_or_io), options
+      def initialize(config)
+        @config, @io = config, ensure_io(config.out_stream)
         @previous_step_keyword = nil
         @snippets_input = []
         @total_duration = 0
+        @summary = Cucumber::Core::Report::Summary.new(config.event_bus)
+        @matches = {}
+        @pending_step_matches = []
+        @failed_results = []
+        @failed_test_cases = []
+        @passed_test_cases = []
+        @counts = ConsoleCounts.new(config)
+        @issues = ConsoleIssues.new(config)
+        config.on_event :step_activated, &method(:on_step_activated)
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
       end
 
-      def before_test_case(_test_case)
+      def on_step_activated(event)
+        @matches[event.test_step.source] = event.step_match
+      end
+
+      def on_test_case_started(_event)
         unless @profile_information_printed
-          print_profile_information
+          do_print_profile_information(config.profiles) unless config.skip_profile_information? || config.profiles.nil? || config.profiles.empty?
           @profile_information_printed = true
         end
         @previous_step_keyword = nil
       end
 
-      def after_test_step(test_step, result)
+      def on_test_step_finished(event)
+        test_step = event.test_step
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         progress(result.to_sym) if !HookQueryVisitor.new(test_step).hook? || result.failed?
-        collect_snippet_data(test_step, result) unless HookQueryVisitor.new(test_step).hook?
+
+        return if HookQueryVisitor.new(test_step).hook?
+        collect_snippet_data(test_step, result)
+        @pending_step_matches << @matches[test_step.source] if result.pending?
+        @failed_results << result if result.failed?
       end
 
-      def after_test_case(_test_case, result)
+      def on_test_case_finished(event)
+        test_case = event.test_case
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        @failed_test_cases << test_case if result.failed?
+        @passed_test_cases << test_case if result.passed?
         @total_duration += DurationExtractor.new(result).result_duration
       end
 
-      def done
+      def on_test_run_finished(_event)
         @io.puts
         @io.puts
         print_summary
@@ -44,11 +77,18 @@ module Cucumber
       private
 
       def print_summary
-        print_steps(:pending)
-        print_steps(:failed)
-        print_statistics(@total_duration, @options)
-        print_snippets(@options)
-        print_passing_wip(@options)
+        print_elements(@pending_step_matches, :pending, 'steps')
+        print_elements(@failed_results, :failed, 'steps')
+        print_statistics(@total_duration, @config, @counts, @issues)
+        snippet_text_proc = lambda { |step_keyword, step_name, multiline_arg|
+          snippet_text(step_keyword, step_name, multiline_arg)
+        }
+        do_print_snippets(snippet_text_proc) if config.snippets? && summary.test_steps.total(:undefined) > 0
+        return unless config.wip?
+        messages = @passed_test_cases.map do |test_case|
+          linebreaks("#{test_case.location.on_line(test_case.location.line)}:in `#{test_case.name}'", ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+        end
+        do_print_passing_wip(messages)
       end
 
       CHARS = {
@@ -68,6 +108,8 @@ module Cucumber
       def table_header_cell?(status)
         status == :skipped_param
       end
+
+      TestCaseData = Struct.new(:name, :location)
     end
   end
 end

data/lib/cucumber/formatter/rerun.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/formatter/io'
 
 module Cucumber
@@ -5,28 +6,24 @@ module Cucumber
     class Rerun
       include Formatter::Io
 
-      def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io)
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        @config = config
         @failures = {}
-        @options = options
-      end
-
-      def after_test_case(test_case, result)
-        return if result.ok?(@options[:strict])
-        @failures[test_case.location.file] ||= []
-        @failures[test_case.location.file] << test_case.location.line
-      end
-
-      def done
-        return if @failures.empty?
-        @io.print file_failures.join(' ')
-      end
-
-      [:before_test_case, :before_test_step, :after_test_step].each do |method|
-        define_method(method) { |*| }
+        config.on_event :test_case_finished do |event|
+          test_case, result = *event.attributes
+          next if result.ok?(@config.strict)
+          @failures[test_case.location.file] ||= []
+          @failures[test_case.location.file] << test_case.location.line
+        end
+        config.on_event :test_run_finished do
+          next if @failures.empty?
+          @io.print file_failures.join('\n')
+        end
       end
 
       private
+
       def file_failures
         @failures.map { |file, lines| [file, lines].join(':') }
       end

data/lib/cucumber/formatter/stepdefs.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/formatter/usage'
 
 module Cucumber

data/lib/cucumber/formatter/steps.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format steps</tt>
@@ -9,7 +10,7 @@ module Cucumber
         @step_definition_files = collect_steps(runtime)
       end
 
-      def after_features(features)
+      def after_features(_features)
         print_summary
       end
 

data/lib/cucumber/formatter/summary.rb

@@ -1,35 +1,58 @@
+# frozen_string_literal: true
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
+require 'cucumber/core/test/result'
+
 module Cucumber
   module Formatter
-    module Summary
 
-      def scenario_summary(runtime, &block)
-        scenarios_proc = lambda{|status| runtime.scenarios(status)}
-        dump_count(runtime.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
-      end
+    # Summary formatter, outputting only feature / scenario titles
+    class Summary
+      include Io
+      include Console
+
+      def initialize(config)
+        @config, @io = config, ensure_io(config.out_stream)
+        @counts = ConsoleCounts.new(@config)
+        @issues = ConsoleIssues.new(@config)
+        @start_time = Time.now
 
-      def step_summary(runtime, &block)
-        steps_proc = lambda{|status| runtime.steps(status)}
-        dump_count(runtime.steps.length, "step") + dump_status_counts(steps_proc, &block)
+        @config.on_event :test_case_started do |event|
+          print_feature event.test_case
+          print_test_case event.test_case
+        end
+
+        @config.on_event :test_case_finished do |event|
+          print_result event.result
+        end
+
+        @config.on_event :test_run_finished do |event|
+          duration = Time.now - @start_time
+          @io.puts
+          print_statistics(duration, @config, @counts, @issues)
+        end
       end
 
       private
 
-      def dump_status_counts(find_elements_proc)
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
-          elements = find_elements_proc.call(status)
-          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
-        end.compact
-        if counts.any?
-          " (#{counts.join(', ')})"
-        else
-          ""
-        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
       end
 
-      def dump_count(count, what, state=nil)
-        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      def print_test_case(test_case)
+        @io.print "  #{test_case.name} "
       end
 
+      def print_result(result)
+        @io.puts format_string(result, result.to_sym)
+      end
     end
   end
 end
+

data/lib/cucumber/formatter/unicode.rb

@@ -1,3 +1,4 @@
+# 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'
@@ -14,7 +15,7 @@ if Cucumber::WINDOWS
       Cucumber::CODEPAGE = "cp#{$1.to_i}"
     end
   else
-    Cucumber::CODEPAGE = "cp1252"
+    Cucumber::CODEPAGE = 'cp1252'
     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
 

data/lib/cucumber/formatter/usage.rb

@@ -1,33 +1,45 @@
+# 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)
-        @options = options
+      def initialize(config)
+        super
         @stepdef_to_match = Hash.new { |h, stepdef_key| h[stepdef_key] = [] }
         @total_duration = 0
         @matches = {}
-        runtime.configuration.on_event :step_match do |event|
-          @matches[event.test_step.source] = event.step_match
+        config.on_event :step_activated do |event|
+          test_step, step_match = *event.attributes
+          @matches[test_step.source] = step_match
         end
+        config.on_event :step_definition_registered, &method(:on_step_definition_registered)
+      end
+
+      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 after_test_step(test_step, result)
-        return if HookQueryVisitor.new(test_step).hook?
+      def on_step_match(event)
+        @matches[event.test_step.source] = event.step_match
+        super
+      end
 
+      def on_test_step_finished(event)
+        return if HookQueryVisitor.new(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.regexp_source, step_definition.location)
+        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
 
@@ -45,14 +57,13 @@ module Cucumber
       private
 
       def print_summary
-        add_unused_stepdefs
         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 {|a,b| a.regexp_source <=> b.regexp_source}
+               else
+                 @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+               end
 
         keys.each do |stepdef_key|
           print_step_definition(stepdef_key)
@@ -60,7 +71,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
@@ -68,9 +79,9 @@ 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('%.7f', 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.location}".indent(indent)
           @io.print(format_string(line_comment, :comment))
@@ -80,10 +91,10 @@ 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('%.7f', 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[:location]}".indent(indent)
             @io.print(format_string(line_comment, :comment))
@@ -125,12 +136,6 @@ module Cucumber
         end
       end
 
-      def add_unused_stepdefs
-        @runtime.unmatched_step_definitions.each do |step_definition|
-          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.location)
-          @stepdef_to_match[stepdef_key] = []
-        end
-      end
     end
   end
 end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gherkin/token_scanner'
 require 'gherkin/parser'
 require 'gherkin/dialect'

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Cucumber
 module Gherkin
   module Formatter
@@ -83,7 +84,7 @@ module Gherkin
           ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
         end
       end
-      
+
       def reset
         "\e[0m"
       end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Cucumber
 module Gherkin
   module Formatter
@@ -9,7 +10,7 @@ module Gherkin
       #
       # This is used in the pretty formatter.
       def escape_cell(s)
-        s.gsub(/\\(?!\|)/, "\\\\\\\\").gsub(/\n/, "\\n").gsub(/\|/, "\\|")
+        s.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
       end
     end
   end

data/lib/cucumber/gherkin/i18n.rb

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

data/lib/cucumber/gherkin/steps_parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gherkin/token_scanner'
 require 'gherkin/token_matcher'
 require 'gherkin/parser'

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

@@ -1,9 +1,12 @@
+# 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 +14,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 +36,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 +53,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,34 +77,35 @@ 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
 
-      # 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)
-        Cucumber.deprecate(
-          "\n         Please follow the upgrade instructions at https://cucumber.io/blog/2017/09/21/upgrading-to-cucumber-3",
-          "Transform",
-          "3.0.0"
+      def ParameterType(options)
+        type = options[:type] || Object
+        use_for_snippets = true if options[:use_for_snippets].nil?
+        prefer_for_regexp_match = false if options[:prefer_for_regexp_match].nil?
+
+        parameter_type = CucumberExpressions::ParameterType.new(
+          options[:name],
+          options[:regexp],
+          type,
+          options[:transformer],
+          use_for_snippets,
+          prefer_for_regexp_match
         )
-        RbDsl.register_rb_transform(regexp, proc)
+        Dsl.define_parameter_type(parameter_type)
       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
@@ -115,10 +125,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)

data/lib/cucumber/glue/hook.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'cucumber/glue/invoke_in_world'
+
+module Cucumber
+  module Glue
+    # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
+    class Hook
+      attr_reader :tag_expressions, :location
+
+      def initialize(registry, tag_expressions, proc)
+        @registry = registry
+        @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)
+      end
+
+      def invoke(pseudo_method, arguments, &block)
+        check_arity = false
+        InvokeInWorld.cucumber_instance_exec_in(
+          @registry.current_world,
+          check_arity,
+          pseudo_method,
+          *[arguments, block].flatten.compact,
+          &@proc
+        )
+      end
+
+      private
+
+      def warn_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.")
+          end
+        end
+      end
+    end
+  end
+end