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

data/lib/cucumber/glue/registry_and_more.rb

@@ -0,0 +1,221 @@
+# 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)
+        hook = add_hook(phase, Hook.new(@configuration.id_generator.new_id, self, tag_expressions, proc))
+        @configuration.notify :envelope, hook.to_envelope
+        hook
+      end
+
+      def define_parameter_type(parameter_type)
+        @configuration.notify :envelope, parameter_type_envelope(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(@configuration.id_generator.new_id, self, string_or_regexp, proc_or_sym, options)
+        @step_definitions << step_definition
+        @configuration.notify :step_definition_registered, step_definition
+        @configuration.notify :envelope, step_definition.to_envelope
+        step_definition
+      rescue Cucumber::CucumberExpressions::UndefinedParameterTypeError => e
+        # TODO: add a way to extract the parameter type directly from the error.
+        type_name = e.message.match(/^Undefined parameter type \{(.*)\}$/)[1]
+
+        @configuration.notify :envelope, Cucumber::Messages::Envelope.new(
+          undefined_parameter_type: Cucumber::Messages::UndefinedParameterType.new(
+            name: type_name,
+            expression: string_or_regexp
+          )
+        )
+      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 parameter_type_envelope(parameter_type)
+        # TODO: should me moved to Cucumber::Expression::ParameterType#to_envelope ?
+        # Note: that would mean that cucumber-expression would depend on cucumber-messages
+
+        Cucumber::Messages::Envelope.new(
+          parameter_type: Cucumber::Messages::ParameterType.new(
+            name: parameter_type.name,
+            regular_expressions: parameter_type.regexps.map(&:to_s),
+            prefer_for_regular_expression_match: parameter_type.prefer_for_regexp_match?,
+            use_for_snippets: parameter_type.use_for_snippets?
+          )
+        )
+      end
+
+      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

data/lib/cucumber/glue/snippet.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Glue
+    module Snippet
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)'].freeze
+
+      class Generator
+        def self.register_on(configuration)
+          configuration.snippet_generators << new
+        end
+
+        def initialize(cucumber_expression_generator)
+          @cucumber_expression_generator = cucumber_expression_generator
+        end
+
+        def call(code_keyword, step_name, multiline_arg, snippet_type)
+          snippet_class = typed_snippet_class(snippet_type)
+          snippet_class.new(@cucumber_expression_generator, code_keyword, step_name, multiline_arg).to_s
+        end
+
+        def typed_snippet_class(type)
+          SNIPPET_TYPES.fetch(type || :cucumber_expression)
+        end
+      end
+
+      class BaseSnippet
+        def initialize(cucumber_expression_generator, code_keyword, step_name, multiline_argument)
+          @number_of_arguments = 0
+          @code_keyword = code_keyword
+          @pattern = replace_and_count_capturing_groups(step_name)
+          @generated_expressions = cucumber_expression_generator.generate_expressions(step_name)
+          @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
+        end
+
+        def to_s
+          "#{step} #{do_block}"
+        end
+
+        def step
+          "#{code_keyword}#{typed_pattern}"
+        end
+
+        def self.cli_option_string(type, cucumber_expression_generator)
+          format('%<type>-7s: %<description>-28s e.g. %<example>s', type: type, description: description, example: example(cucumber_expression_generator))
+        end
+
+        private
+
+        attr_reader :code_keyword, :pattern, :generated_expressions, :multiline_argument, :number_of_arguments
+
+        def replace_and_count_capturing_groups(pattern)
+          modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
+
+          ARGUMENT_PATTERNS.each do |argument_pattern|
+            modified_pattern.gsub!(::Regexp.new(argument_pattern), argument_pattern)
+            @number_of_arguments += modified_pattern.scan(argument_pattern).length
+          end
+
+          modified_pattern
+        end
+
+        def do_block
+          do_block = String.new # rubocop:disable Style/EmptyLiteral
+          do_block << "do#{parameters}\n"
+          multiline_argument.append_comment_to(do_block)
+          do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
+          do_block << 'end'
+          do_block
+        end
+
+        def parameters
+          block_args = (0...number_of_arguments).map { |n| "arg#{n + 1}" }
+          multiline_argument.append_block_parameter_to(block_args)
+          block_args.empty? ? '' : " |#{block_args.join(', ')}|"
+        end
+
+        class << self
+          private
+
+          def example(cucumber_expression_generator)
+            new(cucumber_expression_generator, 'Given', 'I have 2 cukes', MultilineArgument::None.new).step
+          end
+        end
+      end
+
+      class CucumberExpression < BaseSnippet
+        def typed_pattern
+          "(\"#{generated_expressions[0].source}\")"
+        end
+
+        def to_s
+          header = generated_expressions.each_with_index.map do |expr, i|
+            prefix = i.zero? ? '' : '# '
+            "#{prefix}#{code_keyword}('#{expr.source}') do#{parameters(expr)}"
+          end.join("\n")
+
+          body = String.new # rubocop:disable Style/EmptyLiteral
+          multiline_argument.append_comment_to(body)
+          body << "  pending # Write code here that turns the phrase above into concrete actions\n"
+          body << 'end'
+
+          "#{header}\n#{body}"
+        end
+
+        def parameters(expr)
+          parameter_names = expr.parameter_names
+          multiline_argument.append_block_parameter_to(parameter_names)
+          parameter_names.empty? ? '' : " |#{parameter_names.join(', ')}|"
+        end
+
+        def self.description
+          'Cucumber Expressions'
+        end
+      end
+
+      class Regexp < BaseSnippet
+        def typed_pattern
+          "(/^#{pattern}$/)"
+        end
+
+        def self.description
+          'Snippets with parentheses'
+        end
+      end
+
+      class Classic < BaseSnippet
+        def typed_pattern
+          " /^#{pattern}$/"
+        end
+
+        def self.description
+          'Snippets without parentheses. Note that these cause a warning from modern versions of Ruby.'
+        end
+      end
+
+      class Percent < BaseSnippet
+        def typed_pattern
+          " %r{^#{pattern}$}"
+        end
+
+        def self.description
+          'Snippets with percent regexp'
+        end
+      end
+
+      SNIPPET_TYPES = {
+        cucumber_expression: CucumberExpression,
+        regexp: Regexp,
+        classic: Classic,
+        percent: Percent
+      }.freeze
+
+      module MultilineArgumentSnippet
+        def self.new(multiline_argument)
+          builder = Builder.new
+          multiline_argument.describe_to(builder)
+          builder.result
+        end
+
+        class Builder
+          def doc_string(*_args)
+            @result = DocString.new
+          end
+
+          def data_table(table, *_args)
+            @result = DataTable.new(table)
+          end
+
+          def result
+            @result || None.new
+          end
+        end
+
+        class DocString
+          def append_block_parameter_to(array)
+            array << 'string'
+          end
+
+          def append_comment_to(string); end
+        end
+
+        class DataTable
+          def initialize(table)
+            @table = table
+          end
+
+          def append_block_parameter_to(array)
+            array << 'table'
+          end
+
+          def append_comment_to(string)
+            string << "  # table is a #{Cucumber::MultilineArgument::DataTable}\n"
+          end
+        end
+
+        class None
+          def append_block_parameter_to(array); end
+
+          def append_comment_to(string); end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/glue/step_definition.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/glue/invoke_in_world'
+
+module Cucumber
+  module Glue
+    # A Step Definition holds a Regexp pattern and a Proc, and is
+    # typically created by calling {Dsl#register_rb_step_definition Given, When or Then}
+    # in the step_definitions Ruby files.
+    #
+    # Example:
+    #
+    #   Given /I have (\d+) cucumbers in my belly/ do
+    #     # some code here
+    #   end
+    #
+    class StepDefinition
+      class MissingProc < StandardError
+        def message
+          'Step definitions must always have a proc or symbol'
+        end
+      end
+
+      class << self
+        def new(id, registry, string_or_regexp, proc_or_sym, options)
+          raise MissingProc if proc_or_sym.nil?
+          super id, registry, registry.create_expression(string_or_regexp), create_proc(proc_or_sym, options)
+        end
+
+        private
+
+        def create_proc(proc_or_sym, options)
+          return proc_or_sym if proc_or_sym.is_a?(Proc)
+          raise ArgumentError unless proc_or_sym.is_a?(Symbol)
+          message = proc_or_sym
+          target_proc = parse_target_proc_from(options)
+          patch_location_onto lambda { |*args|
+            target = instance_exec(&target_proc)
+            target.send(message, *args)
+          }
+        end
+
+        def patch_location_onto(block)
+          location = Core::Test::Location.of_caller(5)
+          block.define_singleton_method(:source_location) { [location.file, location.line] }
+          block
+        end
+
+        def parse_target_proc_from(options)
+          return -> { self } unless options.key?(:on)
+          target = options[:on]
+          case target
+          when Proc
+            target
+          when Symbol
+            -> { send(target) }
+          else
+            -> { raise ArgumentError, 'Target must be a symbol or a proc' }
+          end
+        end
+      end
+
+      attr_reader :id, :expression, :registry
+
+      def initialize(id, registry, expression, proc)
+        raise 'No regexp' if expression.is_a?(Regexp)
+        @id = id
+        @registry = registry
+        @expression = expression
+        @proc = proc
+        # @registry.available_step_definition(regexp_source, location)
+      end
+
+      def to_envelope
+        Cucumber::Messages::Envelope.new(
+          step_definition: Cucumber::Messages::StepDefinition.new(
+            id: id,
+            pattern: Cucumber::Messages::StepDefinitionPattern.new(
+              source: expression.source.to_s,
+              type: expression_type
+            ),
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: location.file,
+              location: Cucumber::Messages::Location.new(
+                line: location.lines.first
+              )
+            )
+          )
+        )
+      end
+
+      def expression_type
+        return Cucumber::Messages::StepDefinitionPatternType::CUCUMBER_EXPRESSION if expression.is_a?(CucumberExpressions::CucumberExpression)
+        Cucumber::Messages::StepDefinitionPatternType::REGULAR_EXPRESSION
+      end
+
+      # @api private
+      def to_hash
+        type = expression.is_a?(CucumberExpressions::RegularExpression) ? 'regular expression' : 'cucumber expression'
+        regexp = expression.regexp
+        flags = ''
+        flags += 'm' if (regexp.options & Regexp::MULTILINE) != 0
+        flags += 'i' if (regexp.options & Regexp::IGNORECASE) != 0
+        flags += 'x' if (regexp.options & Regexp::EXTENDED) != 0
+        {
+          source: {
+            type: type,
+            expression: expression.source
+          },
+          regexp: {
+            source: regexp.source,
+            flags: flags
+          }
+        }
+      end
+
+      # @api private
+      def ==(other)
+        expression.source == other.expression.source
+      end
+
+      # @api private
+      def arguments_from(step_name)
+        args = @expression.match(step_name)
+        # @registry.invoked_step_definition(regexp_source, location) if args
+        args
+      end
+
+      # @api private
+      # TODO: inline this and step definition just be a value object
+      def invoke(args)
+        InvokeInWorld.cucumber_instance_exec_in(@registry.current_world, true, @expression.to_s, *args, &@proc)
+      rescue ArityMismatchError => e
+        e.backtrace.unshift(backtrace_line)
+        raise e
+      end
+
+      # @api private
+      def backtrace_line
+        "#{location}:in `#{@expression}'"
+      end
+
+      # @api private
+      def file_colon_line
+        case @proc
+        when Proc
+          location.to_s
+        when Symbol
+          ":#{@proc}"
+        end
+      end
+
+      # The source location where the step definition can be found
+      def location
+        @location ||= Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
+      end
+
+      # @api private
+      def file
+        @file ||= location.file
+      end
+    end
+  end
+end