cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/lib/cucumber/runtime.rb

@@ -1,5 +1,5 @@
-# -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require 'fileutils'
 require 'multi_json'
 require 'cucumber/configuration'
@@ -14,12 +14,12 @@ require 'cucumber/step_match_search'
 module Cucumber
   module FixRuby21Bug9285
     def message
-      String(super).gsub("@ rb_sysopen ", "")
+      String(super).gsub('@ rb_sysopen ', '')
     end
   end
 
-  class FileException < Exception
-    attr :path
+  class FileException < RuntimeError
+    attr_reader :path
 
     def initialize(original_exception, path)
       super(original_exception)
@@ -30,8 +30,14 @@ module Cucumber
   class FileNotFoundException < FileException
   end
 
-  class FeatureFolderNotFoundException < FileException
-    include FixRuby21Bug9285 if Cucumber::RUBY_2_1 || Cucumber::RUBY_2_2 || Cucumber::RUBY_2_3
+  class FeatureFolderNotFoundException < RuntimeError
+    def initialize(path)
+      @path = path
+    end
+
+    def message
+      "No such file or directory - #{@path}"
+    end
   end
 
   require 'cucumber/core'
@@ -47,7 +53,6 @@ module Cucumber
     def initialize(configuration = Configuration.default)
       @configuration = Configuration.new(configuration)
       @support_code = SupportCode.new(self, @configuration)
-      @results = Formatter::LegacyApi::Results.new
     end
 
     # Allows you to take an existing runtime and change its configuration
@@ -58,15 +63,14 @@ module Cucumber
 
     require 'cucumber/wire/plugin'
     def run!
+      load_step_definitions
       install_wire_plugin
-      load_support_files
       fire_after_configuration_hook
-      formatters
-      load_step_definitions
+      # TODO: can we remove this state?
       self.visitor = report
 
       receiver = Test::Runner.new(@configuration.event_bus)
-      compile features, receiver, filters
+      compile features, receiver, filters, @configuration.event_bus
       @configuration.notify :test_run_finished
     end
 
@@ -78,36 +82,27 @@ module Cucumber
       @configuration.dry_run?
     end
 
-    def scenarios(status = nil)
-      @results.scenarios(status)
-    end
-
-    def steps(status = nil)
-      @results.steps(status)
-    end
-
     def unmatched_step_definitions
       @support_code.unmatched_step_definitions
     end
 
-    def begin_scenario(scenario)
-      @support_code.fire_hook(:begin_scenario, scenario)
+    def begin_scenario(test_case)
+      @support_code.fire_hook(:begin_scenario, test_case)
     end
 
-    def end_scenario(scenario)
+    def end_scenario(_scenario)
       @support_code.fire_hook(:end_scenario)
     end
 
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
-    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      location = Core::Ast::Location.of_caller
-      Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
+    def doc_string(string_without_triple_quotes, content_type = '', _line_offset = 0)
+      Core::Test::DocString.new(string_without_triple_quotes, content_type)
     end
 
-  private
+    private
 
-    def fire_after_configuration_hook #:nodoc
+    def fire_after_configuration_hook #:nodoc:
       @support_code.fire_hook(:after_configuration, @configuration)
     end
 
@@ -115,6 +110,7 @@ module Cucumber
     def features
       @features ||= feature_files.map do |path|
         source = NormalisedEncodingFile.read(path)
+        @configuration.notify :gherkin_source_read, path, source
         Cucumber::Core::Gherkin::Document.new(path, source)
       end
     end
@@ -136,18 +132,16 @@ module Cucumber
       end
 
       def initialize(path)
-        begin
-          @file = File.new(path)
-          set_encoding
-        rescue Errno::EACCES => e
-          raise FileNotFoundException.new(e, File.expand_path(path))
-        rescue Errno::ENOENT => e
-          raise FeatureFolderNotFoundException.new(e, path)
-        end
+        @file = File.new(path)
+        set_encoding
+      rescue Errno::EACCES => e
+        raise FileNotFoundException.new(e, File.expand_path(path))
+      rescue Errno::ENOENT
+        raise FeatureFolderNotFoundException, path
       end
 
       def read
-        @file.read.encode("UTF-8")
+        @file.read.encode('UTF-8')
       end
 
       private
@@ -155,7 +149,7 @@ module Cucumber
       def set_encoding
         @file.each do |line|
           if ENCODING_PATTERN =~ line
-            @file.set_encoding $1
+            @file.set_encoding Regexp.last_match(1)
             break
           end
           break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
@@ -164,9 +158,6 @@ module Cucumber
       end
     end
 
-    require 'cucumber/formatter/legacy_api/adapter'
-    require 'cucumber/formatter/legacy_api/runtime_facade'
-    require 'cucumber/formatter/legacy_api/results'
     require 'cucumber/formatter/ignore_missing_messages'
     require 'cucumber/formatter/fail_fast'
     require 'cucumber/core/report/summary'
@@ -186,25 +177,24 @@ module Cucumber
     end
 
     def formatters
-      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
-        create_formatter(factory, path_or_io, options)
-      }
+      @formatters ||=
+        @configuration.formatter_factories do |factory, formatter_options, path_or_io|
+          create_formatter(factory, formatter_options, path_or_io)
+        end
     end
 
-    def create_formatter(factory, path_or_io, options)
-      if !legacy_formatter?(factory)
+    def create_formatter(factory, formatter_options, path_or_io)
+      if accept_options?(factory)
+        return factory.new(@configuration, formatter_options) if path_or_io.nil?
+        factory.new(@configuration.with_options(out_stream: path_or_io),
+                    formatter_options)
+      else
         return factory.new(@configuration) if path_or_io.nil?
-        return factory.new(@configuration.with_options(out_stream: path_or_io))
+        factory.new(@configuration.with_options(out_stream: path_or_io))
       end
-      results = Formatter::LegacyApi::Results.new
-      runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
-      formatter = factory.new(runtime_facade, path_or_io, options)
-      Formatter::LegacyApi::Adapter.new(
-        Formatter::IgnoreMissingMessages.new(formatter),
-        results, @configuration)
     end
 
-    def legacy_formatter?(factory)
+    def accept_options?(factory)
       factory.instance_method(:initialize).arity > 1
     end
 
@@ -212,14 +202,13 @@ module Cucumber
       if @configuration.wip?
         summary_report.test_cases.total_passed > 0
       else
-        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
-          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_pending > 0))
+        !summary_report.ok?(@configuration.strict)
       end
     end
     public :failure?
 
     require 'cucumber/core/test/filters'
-    def filters
+    def filters # rubocop:disable Metrics/AbcSize
       tag_expressions = @configuration.tag_expressions
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
@@ -229,43 +218,36 @@ module Cucumber
         filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
         filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
         filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
-        filters << Filters::Quit.new
-        filters << Filters::Retry.new(@configuration)
-        # TODO: can we just use RbLanguages's step definitions directly?
-        step_match_search = StepMatchSearch.new(@support_code.ruby.method(:step_matches), @configuration)
+        # TODO: can we just use Glue::RegistryAndMore's step definitions directly?
+        step_match_search = StepMatchSearch.new(@support_code.registry.method(:step_matches), @configuration)
         filters << Filters::ActivateSteps.new(step_match_search, @configuration)
-        @configuration.filters.each do |filter|
-          filters << filter
-        end
+        @configuration.filters.each { |filter| filters << filter }
         unless configuration.dry_run?
           filters << Filters::ApplyAfterStepHooks.new(@support_code)
           filters << Filters::ApplyBeforeHooks.new(@support_code)
           filters << Filters::ApplyAfterHooks.new(@support_code)
           filters << Filters::ApplyAroundHooks.new(@support_code)
+          filters << Filters::BroadcastTestCaseReadyEvent.new(@configuration)
+          filters << Filters::BroadcastTestRunStartedEvent.new(@configuration)
+          filters << Filters::Quit.new
+          filters << Filters::Retry.new(@configuration)
           # need to do this last so it becomes the first test step
           filters << Filters::PrepareWorld.new(self)
         end
       end
     end
 
-    def load_support_files
-      files = @configuration.support_to_load
-      @support_code.load_files!(files)
-    end
-
     def load_step_definitions
-      files = @configuration.step_defs_to_load
+      files = @configuration.support_to_load + @configuration.step_defs_to_load
       @support_code.load_files!(files)
     end
 
     def install_wire_plugin
-      Cucumber::Wire::Plugin.new(@configuration).install if @configuration.all_files_to_load.any? {|f| f =~ %r{\.wire$} }
+      Cucumber::Wire::Plugin.new(@configuration, @support_code.registry).install if @configuration.all_files_to_load.any? { |f| f =~ /\.wire$/ }
     end
 
     def log
       Cucumber.logger
     end
-
   end
-
 end

data/lib/cucumber/runtime/after_hooks.rb

@@ -1,25 +1,30 @@
 # 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)
-        end          
+          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
   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,7 +1,7 @@
 # frozen_string_literal: true
+
 require 'forwardable'
-require 'cucumber/core/ast/doc_string'
-require 'cucumber/core/ast/data_table'
+require 'cucumber/core/test/doc_string'
 
 module Cucumber
   class Runtime
@@ -15,53 +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,
-        :load_programming_language
-
-      # Returns a Cucumber::MultilineArgument::DataTable for +text_or_table+, which can either
-      # be a String:
-      #
-      #   table(%{
-      #     | account | description | amount |
-      #     | INT-100 | Taxi        | 114    |
-      #     | CUC-101 | Peeler      | 22     |
-      #   })
-      #
-      # or a 2D Array:
-      #
-      #   table([
-      #     %w{ account description amount },
-      #     %w{ INT-100 Taxi        114    },
-      #     %w{ CUC-101 Peeler      22     }
-      #   ])
-      #
-      def table(text_or_table, file=nil, line=0)
-        if !file
-          location = Core::Ast::Location.of_caller
-        else
-          location = Core::Ast::Location.new(file, line)
-        end
-        MultilineArgument::DataTable.from(text_or_table, location)
-      end
-
-      # Returns a Cucumber::MultilineArgument::DocString for +body+.
-      #
-      def doc_string(body, content_type='', line_offset=0)
-        location = Core::Ast::Location.of_caller
-        MultilineArgument.doc_string(body, content_type, location)
-      end
+                     :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,22 +1,18 @@
 # frozen_string_literal: true
+
 require 'cucumber/constantize'
 require 'cucumber/runtime/for_programming_languages'
 require 'cucumber/runtime/step_hooks'
 require 'cucumber/runtime/before_hooks'
 require 'cucumber/runtime/after_hooks'
-require 'cucumber/events/step_match'
 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
@@ -26,17 +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)
-          if argument = step[:argument]
-            if argument[:type] == :DocString
-              MultilineArgument.doc_string(argument[:content], argument[:content_type], location)
-            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
@@ -45,11 +39,13 @@ module Cucumber
 
       include Constantize
 
-      attr_reader :ruby
-      def initialize(user_interface, configuration=Configuration.default)
+      attr_reader :registry
+
+      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)
-        @ruby = Cucumber::RbSupport::RbLanguage.new(@runtime_facade, @configuration)
+        @registry = Cucumber::Glue::RegistryAndMore.new(@runtime_facade, @configuration)
       end
 
       def configure(new_configuration)
@@ -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
 
@@ -73,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)
@@ -93,40 +89,43 @@ module Cucumber
       end
 
       def unmatched_step_definitions
-        @ruby.unmatched_step_definitions
+        registry.unmatched_step_definitions
       end
 
       def fire_hook(name, *args)
-        @ruby.send(name, *args)
+        # TODO: kill with fire
+        registry.send(name, *args)
       end
 
       def step_definitions
-        @ruby.step_definitions
+        registry.step_definitions
       end
 
       def find_after_step_hooks(test_case)
         scenario = RunningTestCase.new(test_case)
-        hooks = @ruby.hooks_for(:after_step, scenario)
-        StepHooks.new hooks
+        hooks = registry.hooks_for(:after_step, scenario)
+        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 = @ruby.hooks_for(:before, scenario)
-        BeforeHooks.new(hooks, scenario).apply_to(test_case)
+        hooks = registry.hooks_for(:before, scenario)
+        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 = @ruby.hooks_for(:after, scenario)
-        AfterHooks.new(hooks, scenario).apply_to(test_case)
+        hooks = registry.hooks_for(:after, scenario)
+        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)
 
-        @ruby.hooks_for(:around, scenario).map do |hook|
-          Hooks.around_hook(test_case.source) do |run_scenario|
+        registry.hooks_for(:around, scenario).map do |hook|
+          Hooks.around_hook do |run_scenario|
             hook.invoke('Around', scenario, &run_scenario)
           end
         end
@@ -135,18 +134,17 @@ module Cucumber
       private
 
       def step_matches(step_name)
-        StepMatchSearch.new(@ruby.method(:step_matches), @configuration).call(step_name)
+        StepMatchSearch.new(registry.method(:step_matches), @configuration).call(step_name)
       end
 
       def load_file(file)
         log.debug("  * #{file}\n")
-        @ruby.load_code_file(file)
+        registry.load_code_file(file)
       end
 
       def log
         Cucumber.logger
       end
-
     end
   end
 end