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

data/lib/cucumber/glue/hook.rb

@@ -0,0 +1,51 @@
+# 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 :tag_expressions, :location
+
+      def initialize(registry, tag_expressions, proc)
+        @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
+
+      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,219 @@
+# frozen_string_literal: true
+
+require 'cucumber/gherkin/formatter/ansi_escapes'
+require 'cucumber/core/test/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::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, file = nil, line = 0)
+        location = !file ? Core::Test::Location.of_caller : Core::Test::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')
+        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
+
+          # rubocop:disable Style/UnneededInterpolation
+          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
+          # rubocop:enable Style/UnneededInterpolation
+
+          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('#<%<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

data/lib/cucumber/glue/registry_and_more.rb

@@ -0,0 +1,192 @@
+# 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 Glue
+    # Raised if a World block returns Nil.
+    class NilWorld < StandardError
+      def initialize
+        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 = String.new # rubocop:disable Style/EmptyLiteral
+        message << "You can only pass a proc to #World once, but it's happening\n"
+        message << "in 2 places:\n\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
+
+    # TODO: This class has too many responsibilities, split off
+    class RegistryAndMore
+      attr_reader :current_world,
+                  :step_definitions
+
+      all_keywords = ::Gherkin::DIALECTS.keys.map do |dialect_name|
+        dialect = ::Gherkin::Dialect.for(dialect_name)
+        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|
+        Glue::Dsl.alias_adverb(adverb.strip)
+      end
+
+      def initialize(runtime, configuration)
+        @runtime = runtime
+        @configuration = configuration
+        @step_definitions = []
+        Glue::Dsl.rb_language = self
+        @world_proc = @world_modules = nil
+        @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)
+        @step_definitions.each_with_object([]) do |step_definition, result|
+          if (arguments = step_definition.arguments_from(name_to_match))
+            result << StepMatch.new(step_definition, name_to_match, arguments)
+          end
+        end
+      end
+
+      def register_rb_hook(phase, tag_expressions, proc)
+        add_hook(phase, Hook.new(self, tag_expressions, proc))
+      end
+
+      def define_parameter_type(parameter_type)
+        @parameter_type_registry.define_parameter_type(parameter_type)
+      end
+
+      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, 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|
+          @namespaced_world_modules[namespace] << world_module unless @namespaced_world_modules[namespace].include?(world_module)
+        end
+      end
+
+      def load_code_file(code_file)
+        return unless File.extname(code_file) == '.rb'
+
+        # This will cause self.add_step_definition, self.add_hook, and self.define_parameter_type to be called from Glue::Dsl
+
+        if Cucumber.use_legacy_autoloader
+          load File.expand_path(code_file)
+        else
+          require File.expand_path(code_file)
+        end
+      end
+
+      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
+        @current_world = nil
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select { |hook| scenario.accept_hook?(hook) }
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        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, 'Expression must be a String or Regexp'
+      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, cucumber_expression_generator)
+        end
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new { |h, k| h[k] = [] }
+      end
+    end
+
+    def self.backtrace_line(proc, name)
+      location = Cucumber::Core::Test::Location.from_source_location(*proc.source_location)
+      "#{location}:in `#{name}'"
+    end
+  end
+end