cucumber 3.0.2 → 4.0.0

data/lib/cucumber/runtime/after_hooks.rb

@@ -1,24 +1,29 @@
 # frozen_string_literal: true
+
 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

@@ -1,26 +1,31 @@
 # frozen_string_literal: true
+
 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,6 +1,7 @@
 # frozen_string_literal: true
+
 require 'forwardable'
-require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/test/doc_string'
 
 module Cucumber
   class Runtime
@@ -14,19 +15,21 @@ 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,
-        :ask,
-        :puts,
-        :features_paths,
-        :step_match
+                     :embed,
+                     :attach,
+                     :ask,
+                     :puts,
+                     :features_paths,
+                     :step_match
 
       def_delegators :@support_code,
-        :invoke_dynamic_steps,
-        :invoke_dynamic_step
+                     :invoke_dynamic_steps,
+                     :invoke_dynamic_step
     end
   end
 end

data/lib/cucumber/runtime/step_hooks.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 module Cucumber
   class Runtime
     class StepHooks
-      def initialize(hooks)
+      def initialize(id_generator, hooks)
         @hooks = hooks
+        @id_generator = id_generator
       end
 
       def apply(test_steps)
@@ -13,10 +15,11 @@ module Cucumber
       end
 
       private
+
       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)
+          Hooks.after_step_hook(@id_generator.new_id, test_step, hook.location, &action)
         end
       end
     end

data/lib/cucumber/runtime/support_code.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'cucumber/constantize'
 require 'cucumber/runtime/for_programming_languages'
 require 'cucumber/runtime/step_hooks'
@@ -8,14 +9,10 @@ require 'cucumber/gherkin/steps_parser'
 require 'cucumber/step_match_search'
 
 module Cucumber
-
   class Runtime
-
     class SupportCode
-
       require 'forwardable'
       class StepInvoker
-
         def initialize(support_code)
           @support_code = support_code
         end
@@ -25,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
@@ -48,7 +41,7 @@ module Cucumber
 
       attr_reader :registry
 
-      def initialize(user_interface, configuration=Configuration.default)
+      def initialize(user_interface, configuration = Configuration.default)
         @configuration = configuration
         # TODO: needs a better name, or inlining its methods
         @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
@@ -65,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,7 +69,7 @@ module Cucumber
       # steps which are compiled into test steps before execution.
       #
       # These are commonly called nested steps.
-      def invoke_dynamic_step(step_name, multiline_argument, _location=nil)
+      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)
@@ -111,26 +104,28 @@ 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)
       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
@@ -150,7 +145,6 @@ module Cucumber
       def log
         Cucumber.logger
       end
-
     end
   end
 end

data/lib/cucumber/runtime/user_interface.rb

@@ -1,20 +1,12 @@
 # frozen_string_literal: true
+
 require 'timeout'
 
 module Cucumber
   class Runtime
-
     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
@@ -33,7 +25,7 @@ module Cucumber
         STDOUT.flush
         puts(question)
 
-        answer = if(Cucumber::JRUBY)
+        answer = if Cucumber::JRUBY
                    jruby_gets(timeout_seconds)
                  else
                    mri_gets(timeout_seconds)
@@ -48,20 +40,18 @@ 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)
@@ -74,6 +64,5 @@ module Cucumber
         answer
       end
     end
-
   end
 end

data/lib/cucumber/step_definition_light.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   # TODO: pointless, ancient, kill with fire.
   # Only used for keeping track of available and invoked step definitions
@@ -8,15 +9,16 @@ module Cucumber
     attr_reader :regexp_source, :location
 
     def initialize(regexp_source, location)
-      @regexp_source, @location = regexp_source, location
+      @regexp_source = regexp_source
+      @location = location
     end
 
-    def eql?(o)
-      regexp_source == o.regexp_source && location == o.location
+    def eql?(other)
+      regexp_source == other.regexp_source && location == other.location
     end
 
     def hash
-      regexp_source.hash + 31*location.to_s.hash
+      regexp_source.hash + 31 * location.to_s.hash
     end
   end
 end

data/lib/cucumber/step_definitions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   class StepDefinitions
     def initialize(configuration = Configuration.default)
@@ -7,8 +8,8 @@ module Cucumber
       @support_code.load_files_from_paths(configuration.autoload_code_paths)
     end
 
-    def to_json
-      @support_code.step_definitions.map(&:to_hash).to_json
+    def to_json(obj = nil)
+      @support_code.step_definitions.map(&:to_hash).to_json(obj)
     end
   end
 end

data/lib/cucumber/step_match.rb

@@ -1,24 +1,29 @@
 # frozen_string_literal: true
+
 require 'cucumber/multiline_argument'
 
 module Cucumber
-
   # Represents the match found between a Test Step and its activation
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
 
     def initialize(step_definition, step_name, step_arguments)
       raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
-      @step_definition, @name_to_match, @step_arguments = step_definition, step_name, step_arguments
+      @step_definition = step_definition
+      @name_to_match = step_name
+      @step_arguments = step_arguments
     end
 
     def args
-      @step_arguments.map(&:value)
+      current_world = @step_definition.registry.current_world
+      @step_arguments.map do |arg|
+        arg.value(current_world)
+      end
     end
 
     def activate(test_step)
       test_step.with_action(@step_definition.location) do
-        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+        invoke(MultilineArgument.from_core(test_step.multiline_arg))
       end
     end
 
@@ -43,7 +48,7 @@ module Cucumber
     #
     #   lambda { |param| "[#{param}]" }
     #
-    def format_args(format = lambda{|a| a}, &proc)
+    def format_args(format = ->(a) { a }, &proc)
       replace_arguments(@name_to_match, @step_arguments, format, &proc)
     end
 
@@ -63,7 +68,7 @@ module Cucumber
       @step_definition.expression.source.to_s.unpack('U*').length
     end
 
-    def replace_arguments(string, step_arguments, format, &proc)
+    def replace_arguments(string, step_arguments, format)
       s = string.dup
       offset = past_offset = 0
       step_arguments.each do |step_argument|
@@ -71,8 +76,8 @@ module Cucumber
         next if group.value.nil? || group.start < past_offset
 
         replacement = if block_given?
-                        proc.call(group.value)
-                      elsif Proc === format
+                        yield(group.value)
+                      elsif Proc == format.class
                         format.call(group.value)
                       else
                         format % group.value
@@ -90,14 +95,15 @@ module Cucumber
     end
 
     private
+
     def deep_clone_args
-      Marshal.load( Marshal.dump( args ) )
+      Marshal.load(Marshal.dump(args))
     end
   end
 
   class SkippingStepMatch
     def activate(test_step)
-      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+      test_step.with_action { raise Core::Test::Result::Skipped }
     end
   end
 
@@ -119,8 +125,7 @@ module Cucumber
     end
 
     def file_colon_line
-      raise "No file:line for #{@step}" unless @step.file_colon_line
-      @step.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
@@ -128,7 +133,7 @@ module Cucumber
     end
 
     def text_length
-      @step.text_length
+      @step.text.length
     end
 
     def step_arguments
@@ -137,20 +142,17 @@ module Cucumber
 
     def activate(test_step)
       # noop
-      return test_step
+      test_step
     end
   end
 
   class AmbiguousStepMatch
-
     def initialize(error)
       @error = error
     end
 
     def activate(test_step)
-      return test_step.with_action { raise @error }
+      test_step.with_action { raise @error }
     end
-
   end
-
 end