cucumber 3.0.0.pre.2 → 4.0.0.rc.5

data/lib/cucumber/glue/snippet.rb

@@ -3,8 +3,7 @@
 module Cucumber
   module Glue
     module Snippet
-
-      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)'].freeze
 
       class Generator
         def self.register_on(configuration)
@@ -26,7 +25,6 @@ module Cucumber
       end
 
       class BaseSnippet
-
         def initialize(cucumber_expression_generator, code_keyword, step_name, multiline_argument)
           @number_of_arguments = 0
           @code_keyword = code_keyword
@@ -44,7 +42,7 @@ module Cucumber
         end
 
         def self.cli_option_string(type, cucumber_expression_generator)
-          format('%-7s: %-28s e.g. %s', type, description, example(cucumber_expression_generator))
+          format('%<type>-7s: %<description>-28s e.g. %<example>s', type: type, description: description, example: example(cucumber_expression_generator))
         end
 
         private
@@ -63,7 +61,7 @@ module Cucumber
         end
 
         def do_block
-          do_block = String.new
+          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"
@@ -72,15 +70,18 @@ module Cucumber
         end
 
         def parameters
-          block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
+          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(", ")}|"
+          block_args.empty? ? '' : " |#{block_args.join(', ')}|"
         end
 
-        def self.example(cucumber_expression_generator)
-          new(cucumber_expression_generator, 'Given', 'I have 2 cukes', MultilineArgument::None.new).step
-        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
@@ -90,11 +91,11 @@ module Cucumber
 
         def to_s
           header = generated_expressions.each_with_index.map do |expr, i|
-            prefix = i == 0 ? '' : '# '
-            "#{prefix}#{code_keyword}(\"#{expr.source}\") do#{parameters(expr)}"
+            prefix = i.zero? ? '' : '# '
+            "#{prefix}#{code_keyword}('#{expr.source}') do#{parameters(expr)}"
           end.join("\n")
 
-          body = String.new
+          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'
@@ -105,7 +106,7 @@ module Cucumber
         def parameters(expr)
           parameter_names = expr.parameter_names
           multiline_argument.append_block_parameter_to(parameter_names)
-          parameter_names.empty? ? '' : " |#{parameter_names.join(", ")}|"
+          parameter_names.empty? ? '' : " |#{parameter_names.join(', ')}|"
         end
 
         def self.description
@@ -144,14 +145,13 @@ module Cucumber
       end
 
       SNIPPET_TYPES = {
-        :cucumber_expression => CucumberExpression,
-        :regexp => Regexp,
-        :classic => Classic,
-        :percent => Percent
-      }
+        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)
@@ -177,8 +177,7 @@ module Cucumber
             array << 'string'
           end
 
-          def append_comment_to(string)
-          end
+          def append_comment_to(string); end
         end
 
         class DataTable
@@ -196,11 +195,9 @@ module Cucumber
         end
 
         class None
-          def append_block_parameter_to(array)
-          end
+          def append_block_parameter_to(array); end
 
-          def append_comment_to(string)
-          end
+          def append_comment_to(string); end
         end
       end
     end

data/lib/cucumber/glue/step_definition.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
+
 require 'cucumber/step_match'
-require 'cucumber/step_argument'
 require 'cucumber/core_ext/string'
 require 'cucumber/glue/invoke_in_world'
 
@@ -17,7 +17,6 @@ module Cucumber
     #   end
     #
     class StepDefinition
-
       class MissingProc < StandardError
         def message
           'Step definitions must always have a proc or symbol'
@@ -25,9 +24,9 @@ module Cucumber
       end
 
       class << self
-        def new(registry, string_or_regexp, proc_or_sym, options)
+        def new(id, 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)
+          super id, registry, registry.create_expression(string_or_regexp), create_proc(proc_or_sym, options)
         end
 
         private
@@ -44,34 +43,60 @@ module Cucumber
         end
 
         def patch_location_onto(block)
-          location = Core::Ast::Location.of_caller(5)
+          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 lambda { self } unless options.key?(:on)
+          return -> { self } unless options.key?(:on)
           target = options[:on]
           case target
           when Proc
             target
           when Symbol
-            lambda { self.send(target) }
+            -> { send(target) }
           else
-            lambda { raise ArgumentError, 'Target must be a symbol or a proc' }
+            -> { raise ArgumentError, 'Target must be a symbol or a proc' }
           end
         end
       end
 
-      attr_reader :expression
+      attr_reader :id, :expression, :registry
 
-      def initialize(registry, expression, proc)
+      def initialize(id, registry, expression, proc)
         raise 'No regexp' if expression.is_a?(Regexp)
-        @registry, @expression, @proc = registry, expression, proc
+        @id = id
+        @registry = registry
+        @expression = expression
+        @proc = proc
         # @registry.available_step_definition(regexp_source, location)
       end
 
-      # @api private
+      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
@@ -91,35 +116,33 @@ module Cucumber
         }
       end
 
-      # @api private
-      def ==(step_definition)
-        expression.source == step_definition.expression.source
+      # @api private
+      def ==(other)
+        expression.source == other.expression.source
       end
 
-      # @api private
+      # @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
+      # @api private
       # TODO: inline this and step definition just be a value object
       def invoke(args)
-        begin
-          InvokeInWorld.cucumber_instance_exec_in(@registry.current_world, true, @expression.to_s, *args, &@proc)
-        rescue ArityMismatchError => e
-          e.backtrace.unshift(self.backtrace_line)
-          raise e
-        end
+        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
+      # @api private
       def backtrace_line
         "#{location}:in `#{@expression}'"
       end
 
-      # @api private
+      # @api private
       def file_colon_line
         case @proc
         when Proc
@@ -129,12 +152,12 @@ module Cucumber
         end
       end
 
-      # The source location where the step defintion can be found
+      # The source location where the step definition can be found
       def location
-        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
+        @location ||= Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
       end
 
-      # @api private
+      # @api private
       def file
         @file ||= location.file
       end

data/lib/cucumber/glue/world_factory.rb

@@ -1,6 +1,5 @@
 module Cucumber
   module Glue
-
     class WorldFactory
       def initialize(proc)
         @proc = proc || -> { Object.new }
@@ -11,13 +10,12 @@ module Cucumber
       end
 
       def raise_nil_world
-        raise NilWorld.new
+        raise NilWorld
       rescue NilWorld => e
         e.backtrace.clear
         e.backtrace.push(Glue.backtrace_line(@proc, 'World'))
         raise e
       end
     end
-
   end
-end
+end

data/lib/cucumber/hooks.rb

@@ -1,38 +1,37 @@
 # frozen_string_literal: true
+
 require 'pathname'
-require 'cucumber/core/ast/location'
+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
   # source for test steps
   module Hooks
-
     class << self
-      def before_hook(source, location, &block)
-        build_hook_step(source, location, block, BeforeHook, Core::Test::UnskippableAction)
+      def before_hook(id, location, &block)
+        build_hook_step(id, location, block, BeforeHook, Core::Test::UnskippableAction)
       end
 
-      def after_hook(source, location, &block)
-        build_hook_step(source, location, block, AfterHook, Core::Test::UnskippableAction)
+      def after_hook(id, location, &block)
+        build_hook_step(id, location, block, AfterHook, Core::Test::UnskippableAction)
       end
 
-      def after_step_hook(source, location, &block)
-        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
-        build_hook_step(source, location, block, AfterStepHook, Core::Test::Action)
+      def after_step_hook(id, test_step, location, &block)
+        raise ArgumentError if test_step.hook?
+        build_hook_step(id, 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, location, block, hook_type, action_type)
+      def build_hook_step(id, 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(id, hook.text, location, action)
       end
     end
 
@@ -43,10 +42,14 @@ module Cucumber
         @location = location
       end
 
-      def name
+      def text
         'After hook'
       end
 
+      def to_s
+        "#{text} at #{location}"
+      end
+
       def match_locations?(queried_locations)
         queried_locations.any? { |other_location| other_location.match?(location) }
       end
@@ -63,10 +66,14 @@ module Cucumber
         @location = location
       end
 
-      def name
+      def text
         'Before hook'
       end
 
+      def to_s
+        "#{text} at #{location}"
+      end
+
       def match_locations?(queried_locations)
         queried_locations.any? { |other_location| other_location.match?(location) }
       end
@@ -83,10 +90,14 @@ module Cucumber
         @location = location
       end
 
-      def name
+      def text
         'AfterStep hook'
       end
 
+      def to_s
+        "#{text} at #{location}"
+      end
+
       def match_locations?(queried_locations)
         queried_locations.any? { |other_location| other_location.match?(location) }
       end
@@ -95,6 +106,5 @@ module Cucumber
         visitor.after_step_hook(self, *args)
       end
     end
-
   end
 end

data/lib/cucumber/load_path.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module LoadPath
     def add_dirs(*dirs)

data/lib/cucumber/multiline_argument.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
+
 require 'delegate'
 require 'cucumber/multiline_argument/data_table'
 require 'cucumber/multiline_argument/doc_string'
 
 module Cucumber
   module MultilineArgument
-
     class << self
       def from_core(node)
         builder.wrap(node)
       end
 
-      def from(argument, location=nil)
-        location ||= Core::Ast::Location.of_caller
+      def from(argument, location = nil, content_type = nil)
+        location ||= Core::Test::Location.of_caller
         case argument
         when String
-          doc_string(argument, 'text/plain', location)
+          builder.doc_string(Core::Test::DocString.new(argument, content_type))
         when Array
           location = location.on_line(argument.first.line..argument.last.line)
-          data_table(argument.map{ |row| row.cells }, location)
+          builder.data_table(argument.map(&:cells), location)
         when DataTable, DocString, None
           argument
         when nil
@@ -28,14 +28,6 @@ module Cucumber
         end
       end
 
-      def doc_string(argument, content_type, location)
-        builder.doc_string(Core::Ast::DocString.new(argument, content_type, location))
-      end
-
-      def data_table(data, location)
-        builder.data_table(Core::Ast::DataTable.new(data, location))
-      end
-
       private
 
       def builder
@@ -60,11 +52,9 @@ module Cucumber
     end
 
     class None
-      def append_to(array)
-      end
+      def append_to(array); end
 
-      def describe_to(visitor)
-      end
+      def describe_to(visitor); end
     end
   end
 end