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

data/lib/cucumber/running_test_case.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Cucumber
+  # Represents the current status of a running test case.
+  #
+  # This wraps a `Cucumber::Core::Test::Case` and delegates
+  # many methods to that object.
+  #
+  # We decorete the core object with the current result.
+  # In the first Before hook of a scenario, this will be an
+  # instance of `Cucumber::Core::Test::Result::Unknown`
+  # but as the scenario runs, it will be updated to reflect
+  # the passed / failed / undefined / skipped status of
+  # the test case.
+  #
+  module RunningTestCase
+    def self.new(test_case)
+      TestCase.new(test_case)
+    end
+
+    class TestCase < SimpleDelegator
+      def initialize(test_case, result = Core::Test::Result::Unknown.new)
+        @test_case = test_case
+        @result = result
+        super test_case
+      end
+
+      def accept_hook?(hook)
+        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
+      end
+
+      def exception
+        return unless @result.failed?
+        @result.exception
+      end
+
+      def status
+        @result.to_sym
+      end
+
+      def failed?
+        @result.failed?
+      end
+
+      def passed?
+        !failed?
+      end
+
+      def source_tag_names
+        tags.map &:name
+      end
+
+      def with_result(result)
+        self.class.new(@test_case, result)
+      end
+    end
+  end
+end

data/lib/cucumber/runtime.rb

@@ -1,26 +1,25 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'multi_json'
-require 'multi_test'
-require 'gherkin/rubify'
-require 'gherkin/i18n'
 require 'cucumber/configuration'
 require 'cucumber/load_path'
-require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
 require 'cucumber/filters'
 require 'cucumber/formatter/fanout'
+require 'cucumber/gherkin/i18n'
+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)
@@ -31,8 +30,14 @@ module Cucumber
   class FileNotFoundException < FileException
   end
 
-  class FeatureFolderNotFoundException < FileException
-    include FixRuby21Bug9285 if Cucumber::RUBY_2_1
+  class FeatureFolderNotFoundException < RuntimeError
+    def initialize(path)
+      @path = path
+    end
+
+    def message
+      "No such file or directory - #{@path}"
+    end
   end
 
   require 'cucumber/core'
@@ -46,28 +51,27 @@ module Cucumber
     include Runtime::UserInterface
 
     def initialize(configuration = Configuration.default)
-      @configuration = Configuration.parse(configuration)
+      @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
     def configure(new_configuration)
-      @configuration = Configuration.parse(new_configuration)
+      @configuration = Configuration.new(new_configuration)
       @support_code.configure(@configuration)
     end
 
-    def load_programming_language(language)
-      @support_code.load_programming_language(language)
-    end
-
+    require 'cucumber/wire/plugin'
     def run!
       load_step_definitions
+      install_wire_plugin
       fire_after_configuration_hook
+      # TODO: can we remove this state?
       self.visitor = report
 
-      receiver = Test::Runner.new(report)
-      compile features, receiver, filters
+      receiver = Test::Runner.new(@configuration.event_bus)
+      compile features, receiver, filters, @configuration.event_bus
+      @configuration.notify :test_run_finished
     end
 
     def features_paths
@@ -78,44 +82,28 @@ module Cucumber
       @configuration.dry_run?
     end
 
-    def scenarios(status = nil)
-      @results.scenarios(status)
-    end
-
-    def steps(status = nil)
-      @results.steps(status)
-    end
-
-    def step_match(step_name, name_to_report=nil) #:nodoc:
-      @support_code.step_match(step_name, name_to_report)
-    end
-
     def unmatched_step_definitions
       @support_code.unmatched_step_definitions
     end
 
-    def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
-      @support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
-    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 unknown_programming_language?
-      @support_code.unknown_programming_language?
+    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)
+      location = Core::Test::Location.of_caller
+      Core::Test::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
-  private
+    private
 
-    def fire_after_configuration_hook #:nodoc
+    def fire_after_configuration_hook #:nodoc:
       @support_code.fire_hook(:after_configuration, @configuration)
     end
 
@@ -123,6 +111,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
@@ -144,18 +133,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
@@ -163,7 +150,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
@@ -172,61 +159,78 @@ 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'
     def report
-      @report ||= Formatter::Fanout.new([summary_report] + formatters)
+      return @report if @report
+      reports = [summary_report] + formatters
+      reports << fail_fast_report if @configuration.fail_fast?
+      @report ||= Formatter::Fanout.new(reports)
     end
 
     def summary_report
-      @summary_report ||= Core::Report::Summary.new
+      @summary_report ||= Core::Report::Summary.new(@configuration.event_bus)
+    end
+
+    def fail_fast_report
+      @fail_fast_report ||= Formatter::FailFast.new(@configuration)
     end
 
     def formatters
-      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
-        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, @support_code, @configuration)
-      }
+      @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, 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?
+        factory.new(@configuration.with_options(out_stream: path_or_io))
+      end
+    end
+
+    def accept_options?(factory)
+      factory.instance_method(:initialize).arity > 1
     end
 
     def failure?
       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_skipped > 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
       [].tap do |filters|
-        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
         filters << Filters::TagLimits.new(tag_limits) if tag_limits.any?
         filters << Cucumber::Core::Test::TagFilter.new(tag_expressions)
         filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
         filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
-        filters << Filters::Quit.new
-        filters << Filters::ActivateSteps.new(@support_code)
-        @configuration.filters.each do |filter|
-          filters << filter
-        end
+        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
+        # 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 { |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::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
@@ -238,10 +242,12 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
+    def install_wire_plugin
+      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,24 +1,27 @@
+# frozen_string_literal: true
+
 module Cucumber
   class Runtime
     class AfterHooks
-      def initialize(action_blocks)
-        @action_blocks = action_blocks
+      def initialize(hooks, scenario)
+        @hooks = hooks
+        @scenario = scenario
       end
 
       def apply_to(test_case)
         test_case.with_steps(
-          test_case.test_steps + after_hooks(test_case.source)
+          test_case.test_steps + after_hooks.reverse
         )
       end
 
       private
 
-      def after_hooks(source)
-        @action_blocks.map do |action_block|
-          Hooks.after_hook(source, &action_block)
+      def after_hooks
+        @hooks.map do |hook|
+          action = ->(result) { hook.invoke('After', @scenario.with_result(result)) }
+          Hooks.after_hook(hook.location, &action)
         end
       end
     end
   end
 end
-

data/lib/cucumber/runtime/before_hooks.rb

@@ -1,21 +1,27 @@
+# frozen_string_literal: true
+
+require 'cucumber/hooks'
+
 module Cucumber
   class Runtime
     class BeforeHooks
-      def initialize(action_blocks)
-        @action_blocks = action_blocks
+      def initialize(hooks, scenario)
+        @hooks = hooks
+        @scenario = scenario
       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)
-        @action_blocks.map do |action_block|
-          Hooks.before_hook(source, &action_block)
+      def before_hooks
+        @hooks.map do |hook|
+          action_block = ->(result) { hook.invoke('Before', @scenario.with_result(result)) }
+          Hooks.before_hook(hook.location, &action_block)
         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/ast/data_table'
+require 'cucumber/core/test/doc_string'
 
 module Cucumber
   class Runtime
@@ -11,54 +12,23 @@ module Cucumber
     class ForProgrammingLanguages
       extend Forwardable
 
+      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,
+                     :ask,
+                     :puts,
+                     :features_paths,
+                     :step_match
 
       def_delegators :@support_code,
-        :invoke_steps,
-        :invoke,
-        :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