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

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,142 @@
+# 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(registry, string_or_regexp, proc_or_sym, options)
+          raise MissingProc if proc_or_sym.nil?
+          super 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 :expression, :registry
+
+      def initialize(registry, expression, proc)
+        raise 'No regexp' if expression.is_a?(Regexp)
+        @registry = registry
+        @expression = expression
+        @proc = proc
+        # @registry.available_step_definition(regexp_source, location)
+      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

data/lib/cucumber/glue/world_factory.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  module Glue
+    class WorldFactory
+      def initialize(proc)
+        @proc = proc || -> { Object.new }
+      end
+
+      def create_world
+        @proc.call || raise_nil_world
+      end
+
+      def raise_nil_world
+        raise NilWorld
+      rescue NilWorld => e
+        e.backtrace.clear
+        e.backtrace.push(Glue.backtrace_line(@proc, 'World'))
+        raise e
+      end
+    end
+  end
+end

data/lib/cucumber/hooks.rb

@@ -1,35 +1,37 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'cucumber/core/test/location'
 require 'cucumber/core/test/around_hook'
 
 module Cucumber
-
-  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as 
+  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as
   # source for test steps
   module Hooks
-
     class << self
-      def before_hook(source, &block)
-        build_hook_step(source, block, BeforeHook, Core::Test::UnskippableAction)
+      def before_hook(location, &block)
+        build_hook_step(location, block, BeforeHook, Core::Test::UnskippableAction)
       end
 
-      def after_hook(source, &block)
-        build_hook_step(source, block, AfterHook, Core::Test::UnskippableAction)
+      def after_hook(location, &block)
+        build_hook_step(location, block, AfterHook, Core::Test::UnskippableAction)
       end
 
-      def after_step_hook(source, &block)
-        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
-        build_hook_step(source, block, AfterStepHook, Core::Test::Action)
+      def after_step_hook(test_step, location, &block)
+        raise ArgumentError if test_step.hook?
+        build_hook_step(location, block, AfterStepHook, Core::Test::Action)
       end
 
-      def around_hook(source, &block)
+      def around_hook(&block)
         Core::Test::AroundHook.new(&block)
       end
 
       private
 
-      def build_hook_step(source, block, hook_type, action_type)
-        action = action_type.new(&block)
+      def build_hook_step(location, block, hook_type, action_type)
+        action = action_type.new(location, &block)
         hook = hook_type.new(action.location)
-        Core::Test::Step.new(source + [hook], action)
+        Core::Test::HookStep.new(hook.text, location, action)
       end
     end
 
@@ -40,8 +42,12 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "After hook"
+      def text
+        'After hook'
+      end
+
+      def to_s
+        "#{text} at #{location}"
       end
 
       def match_locations?(queried_locations)
@@ -60,8 +66,12 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "Before hook"
+      def text
+        'Before hook'
+      end
+
+      def to_s
+        "#{text} at #{location}"
       end
 
       def match_locations?(queried_locations)
@@ -80,8 +90,12 @@ module Cucumber
         @location = location
       end
 
-      def name
-        "AfterStep hook"
+      def text
+        'AfterStep hook'
+      end
+
+      def to_s
+        "#{text} at #{location}"
       end
 
       def match_locations?(queried_locations)
@@ -92,6 +106,5 @@ module Cucumber
         visitor.after_step_hook(self, *args)
       end
     end
-
   end
 end