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

data/lib/cucumber/constantize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/platform'
 module Cucumber
   module Constantize #:nodoc:
@@ -15,21 +17,18 @@ module Cucumber
         constant
       rescue NameError => e
         require underscore(camel_cased_word)
-        if try < 2
-          retry
-        else
-          raise e
-        end
+        retry if try < 2
+        raise e
       end
     end
 
     # Snagged from active_support
     def underscore(camel_cased_word)
-      camel_cased_word.to_s.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
+      camel_cased_word.to_s.gsub(/::/, '/')
+                      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                      .tr('-', '_')
+                      .downcase
     end
 
     private

data/lib/cucumber/core_ext/string.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class String #:nodoc:
   def indent(n)
     if n >= 0
       gsub(/^/, ' ' * n)
     else
-      gsub(/^ {0,#{-n}}/, "")
+      gsub(/^ {0,#{-n}}/, '')
     end
   end
 end

data/lib/cucumber/deprecate.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'cucumber/platform'
+require 'cucumber/gherkin/formatter/ansi_escapes'
+
+module Cucumber
+  module Deprecate
+    module ForUsers
+      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
+
+      def self.call(message, method, remove_after_version)
+        STDERR.puts AnsiEscapes.failed + "\nWARNING: ##{method} is deprecated" \
+        " and will be removed after version #{remove_after_version}. #{message}.\n" \
+        "(Called from #{caller(3..3).first})" + AnsiEscapes.reset
+      end
+    end
+
+    module ForDevelopers
+      def self.call(_message, _method, remove_after_version)
+        raise "This method is due for removal after version #{remove_after_version}" if Cucumber::VERSION > remove_after_version
+      end
+    end
+
+    STRATEGY = $PROGRAM_NAME =~ /rspec$/ ? ForDevelopers : ForUsers
+  end
+
+  def self.deprecate(*args)
+    Deprecate::STRATEGY.call(*args)
+  end
+end

data/lib/cucumber/encoding.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# See https://github.com/cucumber/cucumber/issues/693
+if defined? Encoding
+  Encoding.default_external = 'utf-8'
+  Encoding.default_internal = 'utf-8'
+end

data/lib/cucumber/errors.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 require 'cucumber/core/test/result'
 
 module Cucumber
   # Raised when there is no matching StepDefinition for a step.
   class Undefined < Core::Test::Result::Undefined
     def self.from(result, step_name)
-      if result.is_a?(self)
-        return result.with_message(with_prefix(result.message))
-      end
+      return result.with_message(with_prefix(result.message)) if result.is_a?(self)
 
       begin
-        raise self.new(with_prefix(step_name))
-      rescue => exception
-        return exception
+        raise new(with_prefix(step_name)) # rubocop:disable Style/RaiseArgs
+      rescue StandardError => e
+        return e
       end
     end
 
@@ -20,6 +20,14 @@ module Cucumber
     end
   end
 
+  # Raised when there is no matching StepDefinition for a step called
+  # from within another step definition.
+  class UndefinedDynamicStep < StandardError
+    def initialize(step_name)
+      super %(Undefined dynamic step: "#{step_name}")
+    end
+  end
+
   # Raised when a StepDefinition's block invokes World#pending
   class Pending < Core::Test::Result::Pending
   end
@@ -27,8 +35,9 @@ module Cucumber
   # Raised when a step matches 2 or more StepDefinitions
   class Ambiguous < StandardError
     def initialize(step_name, step_definitions, used_guess)
-      message = "Ambiguous match of \"#{step_name}\":\n\n"
-      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message = String.new # rubocop:disable Style/EmptyLiteral
+      message << "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map(&:backtrace_line).join("\n")
       message << "\n\n"
       message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
       super(message)

data/lib/cucumber/events.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+Dir[File.dirname(__FILE__) + '/events/*.rb'].map(&method(:require))
+
+module Cucumber
+  # Events tell you what's happening while Cucumber runs your features.
+  #
+  # They're designed to be read-only, appropriate for writing formatters and other
+  # output tools. If you need to be able to influence the result of a scenario, use a {RbSupport::RbDsl hook} instead.
+  #
+  # To subscribe to an event, use {Cucumber::Configuration#on_event}
+  #
+  # @example
+  #   AfterConfiguration do |config|
+  #     config.on_event :test_case_finished do |event|
+  #       puts event.result
+  #     end
+  #   end
+  #
+  module Events
+    def self.make_event_bus
+      Core::EventBus.new(registry)
+    end
+
+    def self.registry
+      Core::Events.build_registry(
+        TestCaseStarted,
+        TestCaseFinished,
+        TestStepFinished,
+        TestStepStarted,
+        StepDefinitionRegistered,
+        StepActivated,
+        TestRunFinished,
+        GherkinSourceRead,
+        GherkinSourceParsed,
+        TestRunStarted
+      )
+    end
+  end
+end

data/lib/cucumber/events/gherkin_source_parsed.rb

@@ -0,0 +1,11 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Fired after we've parsed the contents of a feature file
+    class GherkinSourceParsed < Core::Event.new(:gherkin_document)
+      # The Gherkin Ast
+      attr_reader :gherkin_document
+    end
+  end
+end

data/lib/cucumber/events/gherkin_source_read.rb

@@ -0,0 +1,14 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Fired after we've read in the contents of a feature file
+    class GherkinSourceRead < Core::Event.new(:path, :body)
+      # The path to the file
+      attr_reader :path
+
+      # The raw Gherkin source
+      attr_reader :body
+    end
+  end
+end

data/lib/cucumber/events/step_activated.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Event fired when a step is activated
+    class StepActivated < Core::Event.new(:test_step, :step_match)
+      # The test step that was matched.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # Information about the matching definition.
+      #
+      # @return [Cucumber::StepMatch]
+      attr_reader :step_match
+
+      # @private
+      def initialize(test_step, step_match)
+        @test_step = test_step
+        @step_match = step_match
+      end
+    end
+  end
+end

data/lib/cucumber/events/step_definition_registered.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Event fired after each step definition has been registered
+    class StepDefinitionRegistered < Core::Event.new(:step_definition)
+      # The step definition that was just registered.
+      #
+      # @return [RbSupport::RbStepDefinition]
+      attr_reader :step_definition
+
+      # _@private
+      def initialize(step_definition)
+        @step_definition = step_definition
+      end
+    end
+  end
+end

data/lib/cucumber/events/test_case_finished.rb

@@ -0,0 +1,14 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Signals that a {Cucumber::Core::Test::Case} has finished executing
+    class TestCaseFinished < Core::Events::TestCaseFinished
+      # @return [Cucumber::Core::Test::Case] that was executed
+      attr_reader :test_case
+
+      # @return [Cucumber::Core::Test::Result] the result of running the {Cucumber::Core::Test::Case}
+      attr_reader :result
+    end
+  end
+end

data/lib/cucumber/events/test_case_started.rb

@@ -0,0 +1,11 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Signals that a {Cucumber::Core::Test::Case} is about to be executed
+    class TestCaseStarted < Core::Events::TestCaseStarted
+      # @return [Cucumber::Core::Test::Case] the test case to be executed
+      attr_reader :test_case
+    end
+  end
+end

data/lib/cucumber/events/test_run_finished.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Event fired after all test cases have finished executing
+    class TestRunFinished < Core::Event.new
+    end
+  end
+end

data/lib/cucumber/events/test_run_started.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Event fired once all test cases have been filtered before
+    # the first one is executed.
+    class TestRunStarted < Core::Event.new(:test_cases)
+      # @return [Array<Cucumber::Core::Test::Case>] the test cases to be executed
+      attr_reader :test_cases
+    end
+  end
+end

data/lib/cucumber/events/test_step_finished.rb

@@ -0,0 +1,14 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Signals that a {Cucumber::Core::Test::Step} has finished executing
+    class TestStepFinished < Core::Events::TestStepFinished
+      # @return [Cucumber::Core::Test::Step] the test step that was executed
+      attr_reader :test_step
+
+      # @return [Cucumber::Core::Test::Result] the result of running the {Cucumber::Core::Test::Step}
+      attr_reader :result
+    end
+  end
+end

data/lib/cucumber/events/test_step_started.rb

@@ -0,0 +1,11 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Signals that a {Cucumber::Core::Test::Step} is about to be executed
+    class TestStepStarted < Core::Events::TestStepStarted
+      # @return [Cucumber::Core::Test::Step] the test step to be executed
+      attr_reader :test_step
+    end
+  end
+end

data/lib/cucumber/file_specs.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'cucumber'
-require 'cucumber/core/ast/location'
+require 'cucumber/core/test/location'
 
 module Cucumber
   class FileSpecs
@@ -7,7 +9,7 @@ module Cucumber
 
     def initialize(file_specs)
       Cucumber.logger.debug("Features:\n")
-      @file_specs = file_specs.map { |s| FileSpec.new(s) }
+      @file_specs = file_specs.map { |spec| FileSpec.new(spec) }
       Cucumber.logger.debug("\n")
     end
 
@@ -20,8 +22,8 @@ module Cucumber
     end
 
     class FileSpec
-      def initialize(s)
-        @file, @lines = *FILE_COLON_LINE_PATTERN.match(s).captures
+      def initialize(spec)
+        @file, @lines = *FILE_COLON_LINE_PATTERN.match(spec).captures
         Cucumber.logger.debug("  * #{@file}\n")
         @lines = String(@lines).split(':').map { |line| Integer(line) }
       end
@@ -29,8 +31,8 @@ module Cucumber
       attr_reader :file
 
       def locations
-        return [ Core::Ast::Location.new(@file) ] if @lines.empty?
-        @lines.map { |line| Core::Ast::Location.new(@file, line) }
+        return [Core::Test::Location.new(@file)] if @lines.empty?
+        @lines.map { |line| Core::Test::Location.new(@file, line) }
       end
     end
   end

data/lib/cucumber/filters.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require 'cucumber/filters/activate_steps'
 require 'cucumber/filters/apply_after_step_hooks'
 require 'cucumber/filters/apply_before_hooks'
 require 'cucumber/filters/apply_after_hooks'
 require 'cucumber/filters/apply_around_hooks'
+require 'cucumber/filters/broadcast_test_run_started_event'
 require 'cucumber/filters/prepare_world'
 require 'cucumber/filters/quit'
 require 'cucumber/filters/randomizer'
+require 'cucumber/filters/retry'
 require 'cucumber/filters/tag_limits'

data/lib/cucumber/filters/activate_steps.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
+
 require 'cucumber/core/filter'
+require 'cucumber/step_match'
+require 'cucumber/events'
+require 'cucumber/errors'
 
 module Cucumber
   module Filters
-    class ActivateSteps < Core::Filter.new(:step_definitions)
-
+    class ActivateSteps < Core::Filter.new(:step_match_search, :configuration)
       def test_case(test_case)
-        CaseFilter.new(test_case, step_definitions).test_case.describe_to receiver
+        CaseFilter.new(test_case, step_match_search, configuration).test_case.describe_to receiver
       end
 
       class CaseFilter
-        def initialize(test_case, step_definitions)
+        def initialize(test_case, step_match_search, configuration)
           @original_test_case = test_case
-          @step_definitions = step_definitions
+          @step_match_search = step_match_search
+          @configuration = configuration
         end
 
         def test_case
@@ -21,11 +26,47 @@ module Cucumber
         private
 
         def new_test_steps
-          @original_test_case.test_steps.map(&self.method(:attempt_to_activate))
+          @original_test_case.test_steps.map(&method(:attempt_to_activate))
         end
 
         def attempt_to_activate(test_step)
-          @step_definitions.find_match(test_step).activate(test_step)
+          find_match(test_step).activate(test_step)
+        end
+
+        def find_match(test_step)
+          FindMatch.new(@step_match_search, @configuration, test_step).result
+        end
+
+        class FindMatch
+          def initialize(step_match_search, configuration, test_step)
+            @step_match_search = step_match_search
+            @configuration = configuration
+            @test_step = test_step
+          end
+
+          def result
+            begin
+              return NoStepMatch.new(test_step, test_step.text) unless matches.any?
+            rescue Cucumber::Ambiguous => e
+              return AmbiguousStepMatch.new(e)
+            end
+            configuration.notify :step_activated, test_step, match
+            return SkippingStepMatch.new if configuration.dry_run?
+            match
+          end
+
+          private
+
+          attr_reader :step_match_search, :configuration, :test_step
+          private :step_match_search, :configuration, :test_step
+
+          def match
+            matches.first
+          end
+
+          def matches
+            step_match_search.call(test_step.text)
+          end
         end
       end
     end