cucumber 3.1.2 → 8.0.0

data/lib/cucumber/rake/task.rb

@@ -5,9 +5,7 @@ require 'cucumber/gherkin/formatter/ansi_escapes'
 begin
   # Support Rake > 0.8.7
   require 'rake/dsl_definition'
-  # rubocop:disable Lint/HandleExceptions
 rescue LoadError
-  # rubocop:enable Lint/HandleExceptions
 end
 
 module Cucumber
@@ -32,14 +30,15 @@ module Cucumber
       include Cucumber::Gherkin::Formatter::AnsiEscapes
       include ::Rake::DSL if defined?(::Rake::DSL)
 
-      class InProcessCucumberRunner #:nodoc:
+      class InProcessCucumberRunner # :nodoc:
         include ::Rake::DSL if defined?(::Rake::DSL)
 
         attr_reader :args
 
         def initialize(libs, cucumber_opts, feature_files)
-          raise 'libs must be an Array when running in-process' unless Array === libs
-          libs.reverse.each { |lib| $LOAD_PATH.unshift(lib) }
+          raise 'libs must be an Array when running in-process' unless libs.instance_of? Array
+
+          libs.reverse_each { |lib| $LOAD_PATH.unshift(lib) }
           @args = (
             cucumber_opts +
             feature_files
@@ -53,7 +52,7 @@ module Cucumber
         end
       end
 
-      class ForkedCucumberRunner #:nodoc:
+      class ForkedCucumberRunner # :nodoc:
         include ::Rake::DSL if defined?(::Rake::DSL)
 
         def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files)
@@ -65,11 +64,11 @@ module Cucumber
         end
 
         def load_path
-          [format('"%s"', @libs.join(File::PATH_SEPARATOR))]
+          [format('"%<path>s"', path: @libs.join(File::PATH_SEPARATOR))]
         end
 
         def quoted_binary(cucumber_bin)
-          [format('"%s"', cucumber_bin)]
+          [format('"%<path>s"', path: cucumber_bin)]
         end
 
         def use_bundler
@@ -98,9 +97,7 @@ module Cucumber
 
         def run
           sh cmd.join(' ') do |ok, res|
-            if !ok
-              exit res.exitstatus
-            end
+            exit res.exitstatus unless ok
           end
         end
       end
@@ -113,9 +110,18 @@ module Cucumber
 
       # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
       # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
-      attr_accessor :cucumber_opts
-      def cucumber_opts=(opts) #:nodoc:
-        @cucumber_opts = String === opts ? opts.split(' ') : opts
+      attr_reader :cucumber_opts
+
+      def cucumber_opts=(opts) # :nodoc:
+        unless opts.instance_of? String
+          @cucumber_opts = opts
+          return
+        end
+
+        @cucumber_opts = opts.split(' ')
+        return if @cucumber_opts.length <= 1
+
+        $stderr.puts 'WARNING: consider using an array rather than a space-delimited string with cucumber_opts to avoid undesired behavior.'
       end
 
       # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
@@ -134,38 +140,41 @@ module Cucumber
       # Note that this attribute has no effect if you don't run in forked mode.
       attr_accessor :bundler
 
+      # Name of the running task
+      attr_reader :task_name
+
       # Define Cucumber Rake task
       def initialize(task_name = 'cucumber', desc = 'Run Cucumber features')
-        @task_name, @desc = task_name, desc
+        @task_name = task_name
+        @desc = desc
         @fork = true
         @libs = ['lib']
-        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+        @rcov_opts = %w[--rails --exclude osx\/objc,gems\/]
         yield self if block_given?
         @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
         define_task
       end
 
-      def define_task #:nodoc:
+      def define_task # :nodoc:
         desc @desc
         task @task_name do
           runner.run
         end
       end
 
-      def runner(_task_args = nil) #:nodoc:
+      def runner(_task_args = nil) # :nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
-        if @fork
-          return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
-        end
+        return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files) if fork
+
         InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
       end
 
-      def cucumber_opts_with_profile #:nodoc:
-        Array(cucumber_opts).concat Array(@profile).flat_map { |p| ['--profile', p] }
+      def cucumber_opts_with_profile # :nodoc:
+        Array(cucumber_opts).concat(Array(@profile).flat_map { |p| ['--profile', p] })
       end
 
-      def feature_files #:nodoc:
-        make_command_line_safe(FileList[ ENV['FEATURE'] || [] ])
+      def feature_files # :nodoc:
+        make_command_line_safe(FileList[ENV['FEATURE'] || []])
       end
 
       def make_command_line_safe(list)

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -2,23 +2,27 @@
 
 require 'optparse'
 
-module Spec #:nodoc:
-  module Runner #:nodoc:
+module Spec # :nodoc:
+  module Runner # :nodoc:
     # Neuters RSpec's option parser.
     # (RSpec's option parser tries to parse ARGV, which
     # will fail when running cucumber)
-    class OptionParser < ::OptionParser #:nodoc:
+    class OptionParser < ::OptionParser # :nodoc:
       NEUTERED_RSPEC = Object.new
-      def NEUTERED_RSPEC.method_missing(_m, *_args); self; end
+      def NEUTERED_RSPEC.method_missing(_method, *_args) # rubocop:disable Style/MissingRespondToMissing
+        self || super
+      end
+
+      def self.method_added(method)
+        return if @__neutering_rspec
 
-      def self.method_added(m)
-        unless @__neutering_rspec
-          @__neutering_rspec = true
-          define_method(m) do |*a|
-            NEUTERED_RSPEC
-          end
-          @__neutering_rspec = false
+        @__neutering_rspec = true
+        define_method(method) do |*_a|
+          NEUTERED_RSPEC
         end
+        @__neutering_rspec = false
+
+        super
       end
     end
   end

data/lib/cucumber/rspec/doubles.rb

@@ -13,9 +13,7 @@ Before do
 end
 
 After do
-  begin
-    RSpec::Mocks.verify
-  ensure
-    RSpec::Mocks.teardown
-  end
+  RSpec::Mocks.verify
+ensure
+  RSpec::Mocks.teardown
 end

data/lib/cucumber/running_test_case.rb

@@ -15,45 +15,12 @@ module Cucumber
   # the passed / failed / undefined / skipped status of
   # the test case.
   #
-  # The test case might come from a regular Scenario or
-  # a Scenario outline. You can call the `#outline?`
-  # predicate to find out. If it's from an outline,
-  # you get a couple of extra methods.
   module RunningTestCase
     def self.new(test_case)
-      Builder.new(test_case).running_test_case
+      TestCase.new(test_case)
     end
 
-    class Builder
-      def initialize(test_case)
-        @test_case = test_case
-        test_case.describe_source_to(self)
-      end
-
-      def feature(feature)
-      end
-
-      def scenario(_scenario)
-        @factory = Scenario
-      end
-
-      def scenario_outline(_scenario)
-        @factory = ScenarioOutlineExample
-      end
-
-      def examples_table(examples_table)
-      end
-
-      def examples_table_row(row)
-      end
-
-      def running_test_case
-        @factory.new(@test_case)
-      end
-    end
-    private_constant :Builder
-
-    class Scenario < SimpleDelegator
+    class TestCase < SimpleDelegator
       def initialize(test_case, result = Core::Test::Result::Unknown.new)
         @test_case = test_case
         @result = result
@@ -66,6 +33,7 @@ module Cucumber
 
       def exception
         return unless @result.failed?
+
         @result.exception
       end
 
@@ -85,27 +53,9 @@ module Cucumber
         tags.map &:name
       end
 
-      def outline?
-        false
-      end
-
       def with_result(result)
         self.class.new(@test_case, result)
       end
     end
-
-    class ScenarioOutlineExample < Scenario
-      def outline?
-        true
-      end
-
-      def scenario_outline
-        self
-      end
-
-      def cell_values
-        source.last.values
-      end
-    end
   end
 end

data/lib/cucumber/runtime/after_hooks.rb

@@ -3,23 +3,27 @@
 module Cucumber
   class Runtime
     class AfterHooks
-      def initialize(hooks, scenario)
+      def initialize(id_generator, hooks, scenario, event_bus)
         @hooks = hooks
         @scenario = scenario
+        @id_generator = id_generator
+        @event_bus = event_bus
       end
 
       def apply_to(test_case)
         test_case.with_steps(
-          test_case.test_steps + after_hooks(test_case.source).reverse
+          test_case.test_steps + after_hooks.reverse
         )
       end
 
       private
 
-      def after_hooks(source)
+      def after_hooks
         @hooks.map do |hook|
           action = ->(result) { hook.invoke('After', @scenario.with_result(result)) }
-          Hooks.after_hook(source, hook.location, &action)
+          hook_step = Hooks.after_hook(@id_generator.new_id, hook.location, &action)
+          @event_bus.hook_test_step_created(hook_step, hook)
+          hook_step
         end
       end
     end

data/lib/cucumber/runtime/before_hooks.rb

@@ -5,23 +5,27 @@ require 'cucumber/hooks'
 module Cucumber
   class Runtime
     class BeforeHooks
-      def initialize(hooks, scenario)
+      def initialize(id_generator, hooks, scenario, event_bus)
         @hooks = hooks
         @scenario = scenario
+        @id_generator = id_generator
+        @event_bus = event_bus
       end
 
       def apply_to(test_case)
         test_case.with_steps(
-          before_hooks(test_case.source) + test_case.test_steps
+          before_hooks + test_case.test_steps
         )
       end
 
       private
 
-      def before_hooks(source)
+      def before_hooks
         @hooks.map do |hook|
           action_block = ->(result) { hook.invoke('Before', @scenario.with_result(result)) }
-          Hooks.before_hook(source, hook.location, &action_block)
+          hook_step = Hooks.before_hook(@id_generator.new_id, hook.location, &action_block)
+          @event_bus.hook_test_step_created(hook_step, hook)
+          hook_step
         end
       end
     end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
-require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/test/doc_string'
 
 module Cucumber
   class Runtime
@@ -15,11 +15,13 @@ module Cucumber
       attr_reader :support_code
 
       def initialize(support_code, user_interface)
-        @support_code, @user_interface = support_code, user_interface
+        @support_code = support_code
+        @user_interface = user_interface
       end
 
       def_delegators :@user_interface,
                      :embed,
+                     :attach,
                      :ask,
                      :puts,
                      :features_paths,

data/lib/cucumber/runtime/meta_message_builder.rb

@@ -0,0 +1,106 @@
+require 'cucumber/messages'
+require 'cucumber/ci_environment'
+
+module Cucumber
+  class Runtime
+    # Builder to instanciate a Cucumber::Messages::Meta message filled-in with
+    # the runtime meta-data:
+    # - protocol version: the version of the Cucumber::Messages protocol
+    # - implementation: the name and version of the implementation (e.g. cucumber-ruby 8.0.0)
+    # - runtime: the name and version of the runtime (e.g. ruby 3.0.1)
+    # - os: the name and version of the operating system (e.g. linux 3.13.0-45-generic)
+    # - cpu: the name of the CPU (e.g. x86_64)
+    # - ci: informtion about the CI environment if any, including:
+    #   - name: the name of the CI environment (e.g. Jenkins)
+    #   - url: the URL of the CI environment (e.g. https://ci.example.com)
+    #   - build_number: the build number of the CI environment (e.g. 123)
+    #   - git: the git information of the CI environment if any
+    #     - remote: the remote of the git repository (e.g. git@github.com:cucumber/cucumber-ruby.git)
+    #     - revision: the revision of the git repository (e.g. abcdef)
+    #     - branch: the name of the git branch (e.g. main)
+    #     - tag: the name of the git tag (e.g. v1.0.0)
+    class MetaMessageBuilder
+      class << self
+        # Builds a Cucumber::Messages::Meta filled-in with the runtime meta-data
+        #
+        # @param [env] environment data from which the CI information will be
+        #  retrieved (default ENV). Can be used to mock the environment for
+        #  testing purpose.
+        #
+        # @return [Cucumber::Messages::Meta] the meta message
+        #
+        # @see Cucumber::Runtime::MetaMessageBuilder
+        #
+        # @example
+        # Cucumber::Runtime::MetaMessageBuilder.build_meta_message
+        #
+        def build_meta_message(env = ENV)
+          Cucumber::Messages::Meta.new(
+            protocol_version: protocol_version,
+            implementation: implementation,
+            runtime: runtime,
+            os: os,
+            cpu: cpu,
+            ci: ci(env)
+          )
+        end
+
+        private
+
+        def protocol_version
+          Cucumber::Messages::VERSION
+        end
+
+        def implementation
+          Cucumber::Messages::Product.new(
+            name: 'cucumber-ruby',
+            version: Cucumber::VERSION
+          )
+        end
+
+        def runtime
+          Cucumber::Messages::Product.new(
+            name: RUBY_ENGINE,
+            version: RUBY_VERSION
+          )
+        end
+
+        def os
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_os'],
+            version: Sys::Uname.uname.version
+          )
+        end
+
+        def cpu
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_cpu']
+          )
+        end
+
+        def ci(env)
+          ci_data = Cucumber::CiEnvironment.detect_ci_environment(env)
+          return nil unless ci_data
+
+          Cucumber::Messages::Ci.new(
+            name: ci_data[:name],
+            url: ci_data[:url],
+            build_number: ci_data[:buildNumber],
+            git: git_info(ci_data)
+          )
+        end
+
+        def git_info(ci_data)
+          return nil unless ci_data[:git]
+
+          Cucumber::Messages::Git.new(
+            remote: ci_data[:git][:remote],
+            revision: ci_data[:git][:revision],
+            branch: ci_data[:git][:branch],
+            tag: ci_data[:git][:tag]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/step_hooks.rb

@@ -3,8 +3,10 @@
 module Cucumber
   class Runtime
     class StepHooks
-      def initialize(hooks)
+      def initialize(id_generator, hooks, event_bus)
         @hooks = hooks
+        @id_generator = id_generator
+        @event_bus = event_bus
       end
 
       def apply(test_steps)
@@ -18,7 +20,9 @@ module Cucumber
       def after_step_hooks(test_step)
         @hooks.map do |hook|
           action = ->(*args) { hook.invoke('AfterStep', [args, test_step]) }
-          Hooks.after_step_hook(test_step.source, hook.location, &action)
+          hook_step = Hooks.after_step_hook(@id_generator.new_id, test_step, hook.location, &action)
+          @event_bus.hook_test_step_created(hook_step, hook)
+          hook_step
         end
       end
     end

data/lib/cucumber/runtime/support_code.rb

@@ -22,19 +22,15 @@ module Cucumber
         end
 
         def step(step)
-          location = Core::Ast::Location.of_caller
+          location = Core::Test::Location.of_caller
           @support_code.invoke_dynamic_step(step[:text], multiline_arg(step, location))
         end
 
         def multiline_arg(step, location)
-          argument = step[:argument]
-
-          if argument
-            if argument[:type] == :DocString
-              MultilineArgument.from(argument[:content], location, argument[:content_type])
-            else
-              MultilineArgument::DataTable.from(argument[:rows].map { |row| row[:cells].map { |cell| cell[:value] } })
-            end
+          if !step[:doc_string].nil?
+            MultilineArgument.from(step[:doc_string][:content], location, step[:doc_string][:content_type])
+          elsif !step[:data_table].nil?
+            MultilineArgument::DataTable.from(step[:data_table][:rows].map { |row| row[:cells].map { |cell| cell[:value] } })
           else
             MultilineArgument.from(nil)
           end
@@ -62,8 +58,8 @@ module Cucumber
       #     Given I have 8 cukes in my belly
       #     Then I should not be thirsty
       #   })
-      def invoke_dynamic_steps(steps_text, i18n, _location)
-        parser = Cucumber::Gherkin::StepsParser.new(StepInvoker.new(self), i18n.iso_code)
+      def invoke_dynamic_steps(steps_text, iso_code, _location)
+        parser = Cucumber::Gherkin::StepsParser.new(StepInvoker.new(self), iso_code)
         parser.parse(steps_text)
       end
 
@@ -76,6 +72,7 @@ module Cucumber
       def invoke_dynamic_step(step_name, multiline_argument, _location = nil)
         matches = step_matches(step_name)
         raise UndefinedDynamicStep, step_name if matches.empty?
+
         matches.first.invoke(multiline_argument)
       end
 
@@ -108,26 +105,30 @@ module Cucumber
       def find_after_step_hooks(test_case)
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:after_step, scenario)
-        StepHooks.new hooks
+        StepHooks.new(@configuration.id_generator, hooks, @configuration.event_bus)
       end
 
       def apply_before_hooks(test_case)
+        return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:before, scenario)
-        BeforeHooks.new(hooks, scenario).apply_to(test_case)
+        BeforeHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)
       end
 
       def apply_after_hooks(test_case)
+        return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:after, scenario)
-        AfterHooks.new(hooks, scenario).apply_to(test_case)
+        AfterHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)
       end
 
       def find_around_hooks(test_case)
         scenario = RunningTestCase.new(test_case)
 
         registry.hooks_for(:around, scenario).map do |hook|
-          Hooks.around_hook(test_case.source) do |run_scenario|
+          Hooks.around_hook do |run_scenario|
             hook.invoke('Around', scenario, &run_scenario)
           end
         end

data/lib/cucumber/runtime/user_interface.rb

@@ -7,14 +7,6 @@ module Cucumber
     module UserInterface
       attr_writer :visitor
 
-      # Output +messages+ alongside the formatted output.
-      # This is an alternative to using Kernel#puts - it will display
-      # nicer, and in all outputs (in case you use several formatters)
-      #
-      def puts(*messages)
-        @visitor.puts(*messages)
-      end
-
       # Suspends execution and prompts +question+ to the console (STDOUT).
       # An operator (manual tester) can then enter a line of text and hit
       # <ENTER>. The entered text is returned, and both +question+ and
@@ -29,8 +21,8 @@ module Cucumber
       # that makes a sound before invoking #ask.
       #
       def ask(question, timeout_seconds)
-        STDOUT.puts(question)
-        STDOUT.flush
+        $stdout.puts(question)
+        $stdout.flush
         puts(question)
 
         answer = if Cucumber::JRUBY
@@ -40,6 +32,7 @@ module Cucumber
                  end
 
         raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+
         puts(answer)
         answer
       end
@@ -48,26 +41,24 @@ module Cucumber
       # be a path to a file, or if it's an image it may also be a Base64 encoded image.
       # The embedded data may or may not be ignored, depending on what kind of formatter(s) are active.
       #
-      def embed(src, mime_type, label)
-        @visitor.embed(src, mime_type, label)
+      def attach(src, media_type)
+        @visitor.attach(src, media_type)
       end
 
       private
 
       def mri_gets(timeout_seconds)
-        begin
-          Timeout.timeout(timeout_seconds) do
-            STDIN.gets
-          end
-        rescue Timeout::Error
-          nil
+        Timeout.timeout(timeout_seconds) do
+          $stdin.gets
         end
+      rescue Timeout::Error
+        nil
       end
 
       def jruby_gets(timeout_seconds)
         answer = nil
         t = java.lang.Thread.new do
-          answer = STDIN.gets
+          answer = $stdin.gets
         end
         t.start
         t.join(timeout_seconds * 1000)