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

data/lib/cucumber/gherkin/i18n.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Gherkin
     module I18n

data/lib/cucumber/gherkin/steps_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-require 'gherkin/token_scanner'
-require 'gherkin/token_matcher'
-require 'gherkin/parser'
+
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -14,12 +13,23 @@ module Cucumber
 
       def parse(text)
         dialect = ::Gherkin::Dialect.for(@language)
-        token_matcher = ::Gherkin::TokenMatcher.new(@language)
-        token_scanner = ::Gherkin::TokenScanner.new(feature_header(dialect) + text)
-        parser = ::Gherkin::Parser.new
-        gherkin_document = parser.parse(token_scanner, token_matcher)
+        gherkin_document = nil
+        messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
+
+        messages.each do |message|
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+        end
+
+        @builder.steps(gherkin_document[:feature][:children][0][:scenario][:steps])
+      end
 
-        @builder.steps(gherkin_document[:feature][:children][0][:steps])
+      def gherkin_options
+        {
+          default_dialect: @language,
+          include_source: false,
+          include_gherkin_document: true,
+          include_pickles: false
+        }
       end
 
       def feature_header(dialect)

data/lib/cucumber/{rb_support/rb_dsl.rb → glue/dsl.rb}

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/deprecate'
+
 module Cucumber
-  module RbSupport
-    # This module defines the methods you can use to define pure Ruby
-    # Step Definitions and Hooks. This module is mixed into the toplevel
-    # object.
-    module RbDsl
+  module Glue
+    # This module provides the methods the DSL you can use to define
+    # steps, hooks, transforms etc.
+    module Dsl
       class << self
         attr_writer :rb_language
 
@@ -20,8 +23,8 @@ module Cucumber
           @rb_language.register_rb_hook(phase, tag_names, proc)
         end
 
-        def register_rb_transform(regexp, proc)
-          @rb_language.register_rb_transform(regexp, proc)
+        def define_parameter_type(parameter_type)
+          @rb_language.define_parameter_type(parameter_type)
         end
 
         def register_rb_step_definition(regexp, proc_or_sym, options = {})
@@ -54,19 +57,19 @@ module Cucumber
       #    World(my_module: MyModule)
       #
       def World(*world_modules, **namespaced_world_modules, &proc)
-        RbDsl.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
+        Dsl.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
       end
 
       # Registers a proc that will run before each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def Before(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('before', tag_expressions, proc)
+        Dsl.register_rb_hook('before', tag_expressions, proc)
       end
 
       # Registers a proc that will run after each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def After(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('after', tag_expressions, proc)
+        Dsl.register_rb_hook('after', tag_expressions, proc)
       end
 
       # Registers a proc that will be wrapped around each scenario. The proc
@@ -75,29 +78,39 @@ module Cucumber
       # blocks in 1.8), on which it should call the .call method. You can register
       # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def Around(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('around', tag_expressions, proc)
+        Dsl.register_rb_hook('around', tag_expressions, proc)
       end
 
       # Registers a proc that will run after each Step. You can register as
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
       def AfterStep(*tag_expressions, &proc)
-        RbDsl.register_rb_hook('after_step', tag_expressions, proc)
+        Dsl.register_rb_hook('after_step', tag_expressions, proc)
+      end
+
+      def ParameterType(options)
+        type = options[:type] || Object
+        use_for_snippets = if_nil(options[:use_for_snippets], true)
+        prefer_for_regexp_match = if_nil(options[:prefer_for_regexp_match], false)
+
+        parameter_type = CucumberExpressions::ParameterType.new(
+          options[:name],
+          options[:regexp],
+          type,
+          options[:transformer],
+          use_for_snippets,
+          prefer_for_regexp_match
+        )
+        Dsl.define_parameter_type(parameter_type)
       end
 
-      # Registers a proc that will be called with a step definition argument if it
-      # matches the pattern passed as the first argument to Transform. Alternatively, if
-      # the pattern contains captures then they will be yielded as arguments to the
-      # provided proc. The return value of the proc is consequently yielded to the
-      # step definition.
-      def Transform(regexp, &proc)
-        RbDsl.register_rb_transform(regexp, proc)
+      def if_nil(value, default)
+        value.nil? ? default : value
       end
 
       # Registers a proc that will run after Cucumber is configured. You can register as
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      # TODO: Deprecate this
       def AfterConfiguration(&proc)
-        RbDsl.register_rb_hook('after_configuration', [], proc)
+        Dsl.register_rb_hook('after_configuration', [], proc)
       end
 
       # Registers a new Ruby StepDefinition. This method is aliased
@@ -117,10 +130,11 @@ module Cucumber
       # the context of the <tt>World</tt> object.
       def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
         proc_or_sym = symbol || proc
-        RbDsl.register_rb_step_definition(regexp, proc_or_sym, options)
+        Dsl.register_rb_step_definition(regexp, proc_or_sym, options)
       end
     end
   end
 end
 
-extend(Cucumber::RbSupport::RbDsl)
+# TODO: can we avoid adding methods to the global namespace (Kernel)
+extend(Cucumber::Glue::Dsl) # rubocop:disable Style/MixinUsage

data/lib/cucumber/glue/hook.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'cucumber/glue/invoke_in_world'
+
+module Cucumber
+  module Glue
+    # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
+    class Hook
+      attr_reader :id, :tag_expressions, :location
+
+      def initialize(id, registry, tag_expressions, proc)
+        @id = id
+        @registry = registry
+        @tag_expressions = sanitize_tag_expressions(tag_expressions)
+        @proc = proc
+        @location = Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
+        fail_for_old_style_tag_expressions(@tag_expressions)
+      end
+
+      def invoke(pseudo_method, arguments, &block)
+        check_arity = false
+        InvokeInWorld.cucumber_instance_exec_in(
+          @registry.current_world,
+          check_arity,
+          pseudo_method,
+          *[arguments, block].flatten.compact,
+          &@proc
+        )
+      end
+
+      def to_envelope
+        Cucumber::Messages::Envelope.new(
+          hook: Cucumber::Messages::Hook.new(
+            id: id,
+            tag_expression: tag_expressions.join(' '),
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: location.file,
+              location: Cucumber::Messages::Location.new(
+                line: location.lines.first
+              )
+            )
+          )
+        )
+      end
+
+      private
+
+      def sanitize_tag_expressions(tag_expressions)
+        # TODO: remove when '~@no-clobber' has been changed to 'not @no-clobber' in aruba
+        tag_expressions.map { |tag_expression| tag_expression == '~@no-clobber' ? 'not @no-clobber' : tag_expression }
+      end
+
+      def fail_for_old_style_tag_expressions(tag_expressions)
+        tag_expressions.each do |tag_expression|
+          if tag_expression.include?('~')
+            raise("Found tagged hook with '#{tag_expression}'." \
+            "'~@tag' is no longer supported, use 'not @tag' instead.")
+          end
+
+          next unless tag_expression.include?(',')
+          warn("Found tagged hook with '#{tag_expression}'." \
+            "'@tag1,@tag2' is no longer supported, use '@tag or @tag2' instead.")
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/glue/invoke_in_world.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'cucumber/platform'
+module Cucumber
+  module Glue
+    # Utility methods for executing step definitions with nice backtraces etc.
+    # TODO: add unit tests
+    # TODO: refactor for readability
+    class InvokeInWorld
+      def self.replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
+        return if Cucumber.use_full_backtrace
+
+        instance_exec_pos = backtrace.index(instance_exec_invocation_line)
+        return unless instance_exec_pos
+        replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+        backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+
+        depth = backtrace.count { |line| line == instance_exec_invocation_line }
+        end_pos = depth > 1 ? instance_exec_pos : -1
+
+        backtrace[replacement_line + 1..end_pos] = nil
+        backtrace.compact!
+      end
+
+      def self.cucumber_instance_exec_in(world, check_arity, pseudo_method, *args, &block)
+        cucumber_run_with_backtrace_filtering(pseudo_method) do
+          if check_arity && !cucumber_compatible_arity?(args, block)
+            world.instance_exec do
+              ari = block.arity
+              ari = ari < 0 ? (ari.abs - 1).to_s + '+' : ari
+              s1 = ari == 1 ? '' : 's'
+              s2 = args.length == 1 ? '' : 's'
+              raise ArityMismatchError, "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
+            end
+          else
+            world.instance_exec(*args, &block)
+          end
+        end
+      end
+
+      def self.cucumber_compatible_arity?(args, block)
+        return true if block.arity == args.length
+        if block.arity < 0
+          return true if args.length >= (block.arity.abs - 1)
+        end
+        false
+      end
+
+      def self.cucumber_run_with_backtrace_filtering(pseudo_method)
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
+        replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+        raise e
+      end
+
+      INSTANCE_EXEC_OFFSET = -3
+    end
+
+    # Raised if the number of a StepDefinition's Regexp match groups
+    # is different from the number of Proc arguments.
+    class ArityMismatchError < StandardError
+    end
+  end
+end

data/lib/cucumber/glue/proto_world.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'cucumber/gherkin/formatter/ansi_escapes'
+require 'cucumber/core/test/data_table'
+require 'cucumber/deprecate'
+
+module Cucumber
+  module Glue
+    # Defines the basic API methods availlable in all Cucumber step definitions.
+    #
+    # You can, and probably should, extend this API with your own methods that
+    # make sense in your domain. For more on that, see {Cucumber::Glue::Dsl#World}
+    module ProtoWorld
+      # Run a single Gherkin step
+      # @example Call another step
+      #   step "I am logged in"
+      # @example Call a step with quotes in the name
+      #   step %{the user "Dave" is logged in}
+      # @example Passing a table
+      #   step "the following users exist:", table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @example Passing a multiline string
+      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
+      # @param [String] name The name of the step
+      # @param [String,Cucumber::Test::DocString,Cucumber::Ast::Table] multiline_argument
+      def step(name, raw_multiline_arg = nil)
+        super
+      end
+
+      # Run a snippet of Gherkin
+      # @example
+      #   steps %{
+      #     Given the user "Susan" exists
+      #     And I am logged in as "Susan"
+      #   }
+      # @param [String] steps_text The Gherkin snippet to run
+      def steps(steps_text)
+        super
+      end
+
+      # Parse Gherkin into a {Cucumber::Ast::Table} object.
+      #
+      # Useful in conjunction with the #step method.
+      # @example Create a table
+      #   users = table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @param [String] text_or_table The Gherkin string that represents the table
+      # 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)
+        MultilineArgument::DataTable.from(text_or_table)
+      end
+
+      # Print a message to the output.
+      #
+      # @note Cucumber might surprise you with the behaviour of this method. Instead
+      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
+      #   the message until the current step has finished, and then display it.
+      #
+      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
+      def puts(*messages)
+        Cucumber.deprecate(
+          'Messages emitted with "puts" will no longer be caught by Cucumber ' \
+          'and sent to the formatter. If you want message to be in the formatted output, ' \
+          "please use log(message) instead.\n" \
+          'If you simply want it in the console, '\
+          'keep using "puts" (or Kernel.puts to avoid this message)',
+          'puts(message)',
+          '5.0.0'
+        )
+        messages.each { |message| log(message.to_s) }
+      end
+
+      # Pause the tests and ask the operator for input
+      def ask(question, timeout_seconds = 60)
+        super
+      end
+
+      # Embed an image in the output
+      def embed(file, mime_type, _label = 'Screenshot')
+        Cucumber.deprecate(
+          'Please use attach(file, media_type) instead',
+          'embed(file, mime_type, label)',
+          '5.0.0'
+        )
+        attach(file, mime_type)
+      end
+
+      def log(message)
+        raise Cucumber::LogTypeInvalid unless message.is_a?(String)
+        attach(message.dup, 'text/x.cucumber.log+plain')
+      end
+
+      def attach(file, media_type)
+        super
+      end
+
+      # Mark the matched step as pending.
+      def pending(message = 'TODO')
+        raise Pending, message unless block_given?
+
+        begin
+          yield
+        rescue Exception # rubocop:disable Lint/RescueException
+          raise Pending, message
+        end
+        raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
+      end
+
+      # Skips this step and the remaining steps in the scenario
+      def skip_this_scenario(message = 'Scenario skipped')
+        raise Core::Test::Result::Skipped, message
+      end
+
+      # Prints the list of modules that are included in the World
+      def inspect
+        super
+      end
+
+      # see {#inspect}
+      def to_s
+        inspect
+      end
+
+      # Dynamially generate the API module, closuring the dependencies
+      def self.for(runtime, language) # rubocop:disable Metrics/MethodLength
+        Module.new do # rubocop:disable Metrics/BlockLength
+          def self.extended(object)
+            # wrap the dynamically generated module so that we can document the methods
+            # for yardoc, which doesn't like define_method.
+            object.extend(ProtoWorld)
+          end
+
+          # TODO: pass these in when building the module, instead of mutating them later
+          # Extend the World with user-defined modules
+          def add_modules!(world_modules, namespaced_world_modules)
+            add_world_modules!(world_modules)
+            add_namespaced_modules!(namespaced_world_modules)
+          end
+
+          define_method(:step) do |name, raw_multiline_arg = nil|
+            location = Core::Test::Location.of_caller
+            runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
+          end
+
+          define_method(:steps) do |steps_text|
+            location = Core::Test::Location.of_caller
+            runtime.invoke_dynamic_steps(steps_text, language, location)
+          end
+
+          define_method(:ask) do |question, timeout_seconds = 60|
+            runtime.ask(question, timeout_seconds)
+          end
+
+          define_method(:attach) do |file, media_type|
+            runtime.attach(file, media_type)
+          end
+
+          # Prints the list of modules that are included in the World
+          def inspect
+            modules = [self.class]
+            (class << self; self; end).instance_eval do
+              modules += included_modules
+            end
+            modules << stringify_namespaced_modules
+            format('#<%<modules>s:0x%<object_id>x>', modules: modules.join('+'), object_id: object_id)
+          end
+
+          private
+
+          # @private
+          def add_world_modules!(modules)
+            modules.each do |world_module|
+              extend(world_module)
+            end
+          end
+
+          # @private
+          def add_namespaced_modules!(modules)
+            @__namespaced_modules = modules
+            modules.each do |namespace, world_modules|
+              world_modules.each do |world_module|
+                variable_name = "@__#{namespace}_world"
+
+                inner_world = if self.class.respond_to?(namespace)
+                                instance_variable_get(variable_name)
+                              else
+                                Object.new
+                              end
+                instance_variable_set(variable_name,
+                                      inner_world.extend(world_module))
+                self.class.send(:define_method, namespace) do
+                  instance_variable_get(variable_name)
+                end
+              end
+            end
+          end
+
+          # @private
+          def stringify_namespaced_modules
+            @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
+          end
+        end
+      end
+
+      # @private
+      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
+    end
+  end
+end