cucumber 2.99.0 → 3.0.0

data/lib/cucumber/glue/invoke_in_world.rb

@@ -0,0 +1,70 @@
+# 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)
+        if 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
+      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.new(
+                "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)
+        begin
+          yield
+        rescue Exception => e
+          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
+      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,220 @@
+# frozen_string_literal: true
+require 'cucumber/gherkin/formatter/ansi_escapes'
+require 'cucumber/core/ast/data_table'
+
+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::Ast::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, file=nil, line=0)
+        location = !file ? Core::Ast::Location.of_caller : Core::Ast::Location.new(file, line)
+        MultilineArgument::DataTable.from(text_or_table, location)
+      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)
+        super
+      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')
+        super
+      end
+
+      # Mark the matched step as pending.
+      def pending(message = 'TODO')
+        if block_given?
+          begin
+            yield
+          rescue Exception
+            raise Pending, message
+          end
+          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
+        else
+          raise Pending, message
+        end
+      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)
+        Module.new do
+          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::Ast::Location.of_caller
+            runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
+          end
+
+          define_method(:steps) do |steps_text|
+            location = Core::Ast::Location.of_caller
+            runtime.invoke_dynamic_steps(steps_text, language, location)
+          end
+
+          define_method(:puts) do |*messages|
+            # Even though they won't be output until later, converting the messages to
+            # strings right away will protect them from modifications to their original
+            # objects in the mean time
+            messages.collect! { |message| "#{message}" }
+
+            runtime.puts(*messages)
+          end
+
+          define_method(:ask) do |question, timeout_seconds=60|
+            runtime.ask(question, timeout_seconds)
+          end
+
+          define_method(:embed) do |file, mime_type, label='Screenshot'|
+            runtime.embed(file, mime_type, label)
+          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('#<%s:0x%x>', modules.join('+'), self.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

data/lib/cucumber/{rb_support/rb_language.rb → glue/registry_and_more.rb}

@@ -1,39 +1,45 @@
-require 'cucumber/core_ext/instance_exec'
-require 'cucumber/rb_support/rb_dsl'
-require 'cucumber/rb_support/rb_world'
-require 'cucumber/rb_support/rb_step_definition'
-require 'cucumber/rb_support/rb_hook'
-require 'cucumber/rb_support/rb_transform'
-require 'cucumber/rb_support/snippet'
+# frozen_string_literal: true
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/glue/dsl'
+require 'cucumber/glue/snippet'
+require 'cucumber/glue/hook'
+require 'cucumber/glue/proto_world'
+require 'cucumber/glue/step_definition'
+require 'cucumber/glue/world_factory'
 require 'cucumber/gherkin/i18n'
 require 'multi_test'
 require 'cucumber/step_match'
 require 'cucumber/step_definition_light'
+require 'cucumber/events/step_definition_registered'
 
 module Cucumber
-  module RbSupport
+  module Glue
     # Raised if a World block returns Nil.
     class NilWorld < StandardError
       def initialize
-        super("World procs should never return nil")
+        super('World procs should never return nil')
       end
     end
 
     # Raised if there are 2 or more World blocks.
     class MultipleWorld < StandardError
       def initialize(first_proc, second_proc)
-        message = "You can only pass a proc to #World once, but it's happening\n"
+        message = String.new
+        message << "You can only pass a proc to #World once, but it's happening\n"
         message << "in 2 places:\n\n"
-        message << RbSupport.backtrace_line(first_proc, 'World') << "\n"
-        message << RbSupport.backtrace_line(second_proc, 'World') << "\n\n"
-        message << "Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc\n"
+        message << Glue.backtrace_line(first_proc, 'World') << "\n"
+        message << Glue.backtrace_line(second_proc, 'World') << "\n\n"
+        message << "Use Ruby modules instead to extend your worlds. See the Cucumber::Glue::Dsl#World RDoc\n"
         message << "or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.\n\n"
         super(message)
       end
     end
 
-    # The Ruby implementation of the programming language API.
-    class RbLanguage
+    # TODO: This class has too many responsibilities, split off
+    class RegistryAndMore
       attr_reader :current_world,
                   :step_definitions
 
@@ -42,15 +48,17 @@ module Cucumber
         dialect.given_keywords + dialect.when_keywords + dialect.then_keywords + dialect.and_keywords + dialect.but_keywords
       end
       Cucumber::Gherkin::I18n.code_keywords_for(all_keywords.flatten.uniq.sort).each do |adverb|
-        RbDsl.alias_adverb(adverb.strip)
+        Glue::Dsl.alias_adverb(adverb.strip)
       end
 
       def initialize(runtime, configuration)
-        @runtime = runtime
+        @runtime, @configuration = runtime, configuration
         @step_definitions = []
-        RbDsl.rb_language = self
+        Glue::Dsl.rb_language = self
         @world_proc = @world_modules = nil
-        configuration.register_snippet_generator(Snippet::Generator.new)
+        @parameter_type_registry = CucumberExpressions::ParameterTypeRegistry.new
+        cucumber_expression_generator = CucumberExpressions::CucumberExpressionGenerator.new(@parameter_type_registry)
+        @configuration.register_snippet_generator(Snippet::Generator.new(cucumber_expression_generator))
       end
 
       def step_matches(name_to_match)
@@ -62,42 +70,48 @@ module Cucumber
         }
       end
 
-      def begin_rb_scenario(scenario)
-        create_world
-        extend_world
-        connect_world(scenario)
-      end
-
       def register_rb_hook(phase, tag_expressions, proc)
-        add_hook(phase, RbHook.new(self, tag_expressions, proc))
+        add_hook(phase, Hook.new(self, tag_expressions, proc))
       end
 
-      def register_rb_transform(regexp, proc)
-        add_transform(RbTransform.new(self, regexp, proc))
+      def define_parameter_type(parameter_type)
+        @parameter_type_registry.define_parameter_type(parameter_type)
       end
 
-      def register_rb_step_definition(regexp, proc_or_sym, options)
-        step_definition = RbStepDefinition.new(self, regexp, proc_or_sym, options)
+      def register_rb_step_definition(string_or_regexp, proc_or_sym, options)
+        step_definition = StepDefinition.new(self, string_or_regexp, proc_or_sym, options)
         @step_definitions << step_definition
+        @configuration.notify :step_definition_registered, step_definition
         step_definition
       end
 
-      def build_rb_world_factory(world_modules, proc)
-        if(proc)
+      def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
+        if proc
           raise MultipleWorld.new(@world_proc, proc) if @world_proc
           @world_proc = proc
         end
         @world_modules ||= []
         @world_modules += world_modules
+
+        @namespaced_world_modules ||= Hash.new { |h, k| h[k] = [] }
+        namespaced_world_modules.each do |namespace, world_module|
+          unless @namespaced_world_modules[namespace].include?(world_module)
+            @namespaced_world_modules[namespace] << world_module
+          end
+        end
       end
 
       def load_code_file(code_file)
-        return unless File.extname(code_file) == ".rb"
-        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
+        return unless File.extname(code_file) == '.rb'
+        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.define_parameter_type to be called from Glue::Dsl
       end
 
-      def begin_scenario(scenario)
-        begin_rb_scenario(scenario)
+      def begin_scenario(test_case)
+        @current_world = WorldFactory.new(@world_proc).create_world
+        @current_world.extend(ProtoWorld.for(@runtime, test_case.language))
+        MultiTest.extend_with_best_assertion_library(@current_world)
+        @current_world.add_modules!(@world_modules || [],
+                                    @namespaced_world_modules || {})
       end
 
       def end_scenario
@@ -110,13 +124,6 @@ module Cucumber
         end
       end
 
-      def execute_transforms(args)
-        args.map do |arg|
-          matching_transform = transforms.detect {|transform| transform.match(arg) }
-          matching_transform ? matching_transform.invoke(arg) : arg
-        end
-      end
-
       def add_hook(phase, hook)
         hooks[phase.to_sym] << hook
         hook
@@ -126,11 +133,6 @@ module Cucumber
         @hooks = nil
       end
 
-      def add_transform(transform)
-        transforms.unshift transform
-        transform
-      end
-
       def hooks_for(phase, scenario) #:nodoc:
         hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
       end
@@ -147,6 +149,12 @@ module Cucumber
         invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
       end
 
+      def create_expression(string_or_regexp)
+        return CucumberExpressions::CucumberExpression.new(string_or_regexp, @parameter_type_registry) if string_or_regexp.is_a?(String)
+        return CucumberExpressions::RegularExpression.new(string_or_regexp, @parameter_type_registry) if string_or_regexp.is_a?(Regexp)
+        raise ArgumentError.new('Expression must be a String or Regexp')
+      end
+
       private
 
       def available_step_definition_hash
@@ -161,56 +169,18 @@ module Cucumber
         @hooks ||= Hash.new{|h,k| h[k] = []}
       end
 
-      def transforms
-        @transforms ||= []
-      end
-
-      def create_world
-        if(@world_proc)
-          @current_world = @world_proc.call
-          check_nil(@current_world, @world_proc)
-        else
-          @current_world = Object.new
-        end
-      end
-
-      def extend_world
-        @current_world.extend(RbWorld)
-        MultiTest.extend_with_best_assertion_library(@current_world)
-        (@world_modules || []).each do |mod|
-          @current_world.extend(mod)
-        end
-      end
-
-      def connect_world(scenario)
-        @current_world.__cucumber_runtime = @runtime
-        @current_world.__natural_language = scenario.language
-      end
-
-      def check_nil(o, proc)
-        if o.nil?
-          begin
-            raise NilWorld.new
-          rescue NilWorld => e
-            e.backtrace.clear
-            e.backtrace.push(RbSupport.backtrace_line(proc, "World"))
-            raise e
-          end
-        else
-          o
-        end
-      end
-
       def self.cli_snippet_type_options
+        registry = CucumberExpressions::ParameterTypeRegistry.new
+        cucumber_expression_generator = CucumberExpressions::CucumberExpressionGenerator.new(registry)
         Snippet::SNIPPET_TYPES.keys.sort_by(&:to_s).map do |type|
-          Snippet::SNIPPET_TYPES[type].cli_option_string(type)
+          Snippet::SNIPPET_TYPES[type].cli_option_string(type, cucumber_expression_generator)
         end
       end
     end
 
     def self.backtrace_line(proc, name)
       location = Cucumber::Core::Ast::Location.from_source_location(*proc.source_location)
-      "#{location.to_s}:in `#{name}'"
+      "#{location}:in `#{name}'"
     end
   end
 end