cucumber 4.0.0.rc.1 → 4.0.0.rc.6

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gherkin/gherkin'
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -12,9 +12,10 @@ module Cucumber
 
       def parse(text)
         gherkin_document = nil
-        messages = ::Gherkin::Gherkin.from_source('dummy', feature_header + text, include_source: false, include_pickles: false)
+        messages = ::Gherkin.from_source('dummy', feature_header + text, gherkin_options)
+
         messages.each do |message|
-          gherkin_document = message.gherkinDocument.to_hash unless message.gherkinDocument.nil?
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
         end
 
         return if gherkin_document.nil?
@@ -23,6 +24,14 @@ module Cucumber
         end
       end
 
+      def gherkin_options
+        {
+          include_source: false,
+          include_gherkin_document: true,
+          include_pickles: false
+        }
+      end
+
       def feature_header
         dialect = ::Gherkin::Dialect.for('en')
         %(#{dialect.feature_keywords[0]}:

data/lib/cucumber/gherkin/steps_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gherkin/gherkin'
+require 'gherkin'
 require 'gherkin/dialect'
 
 module Cucumber
@@ -14,14 +14,24 @@ module Cucumber
       def parse(text)
         dialect = ::Gherkin::Dialect.for(@language)
         gherkin_document = nil
-        messages = ::Gherkin::Gherkin.from_source('dummy', feature_header(dialect) + text, default_dialect: @language, include_source: false, include_pickles: false)
+        messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
+
         messages.each do |message|
-          gherkin_document = message.gherkinDocument.to_hash unless message.gherkinDocument.nil?
+          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
         end
 
         @builder.steps(gherkin_document[:feature][:children][0][:scenario][:steps])
       end
 
+      def gherkin_options
+        {
+          default_dialect: @language,
+          include_source: false,
+          include_gherkin_document: true,
+          include_pickles: false
+        }
+      end
+
       def feature_header(dialect)
         %(#{dialect.feature_keywords[0]}:
             #{dialect.scenario_keywords[0]}:

data/lib/cucumber/glue/hook.rb

@@ -6,9 +6,10 @@ module Cucumber
   module Glue
     # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
     class Hook
-      attr_reader :tag_expressions, :location
+      attr_reader :id, :tag_expressions, :location
 
-      def initialize(registry, tag_expressions, proc)
+      def initialize(id, registry, tag_expressions, proc)
+        @id = id
         @registry = registry
         @tag_expressions = sanitize_tag_expressions(tag_expressions)
         @proc = proc
@@ -27,6 +28,21 @@ module Cucumber
         )
       end
 
+      def to_envelope
+        Cucumber::Messages::Envelope.new(
+          hook: Cucumber::Messages::Hook.new(
+            id: id,
+            tag_expression: tag_expressions.join(' '),
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: location.file,
+              location: Cucumber::Messages::Location.new(
+                line: location.lines.first
+              )
+            )
+          )
+        )
+      end
+
       private
 
       def sanitize_tag_expressions(tag_expressions)

data/lib/cucumber/glue/proto_world.rb

@@ -2,6 +2,7 @@
 
 require 'cucumber/gherkin/formatter/ansi_escapes'
 require 'cucumber/core/test/data_table'
+require 'cucumber/deprecate'
 
 module Cucumber
   module Glue
@@ -67,9 +68,8 @@ module Cucumber
       #     %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)
+      def table(text_or_table)
+        MultilineArgument::DataTable.from(text_or_table)
       end
 
       # Print a message to the output.
@@ -80,7 +80,16 @@ module Cucumber
       #
       #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
       def puts(*messages)
-        super
+        Cucumber.deprecate(
+          'Messages emitted with "puts" will no longer be caught by Cucumber ' \
+          'and sent to the formatter. If you want message to be in the formatted output, ' \
+          "please use log(message) instead.\n" \
+          'If you simply want it in the console, '\
+          'keep using "puts" (or Kernel.puts to avoid this message)',
+          'puts(message)',
+          '5.0.0'
+        )
+        messages.each { |message| log(message.to_s) }
       end
 
       # Pause the tests and ask the operator for input
@@ -89,7 +98,21 @@ module Cucumber
       end
 
       # Embed an image in the output
-      def embed(file, mime_type, label = 'Screenshot')
+      def embed(file, mime_type, _label = 'Screenshot')
+        Cucumber.deprecate(
+          'Please use attach(file, media_type) instead',
+          'embed(file, mime_type, label)',
+          '5.0.0'
+        )
+        attach(file, mime_type)
+      end
+
+      def log(message)
+        raise Cucumber::LogTypeInvalid unless message.is_a?(String)
+        attach(message.dup, 'text/x.cucumber.log+plain')
+      end
+
+      def attach(file, media_type)
         super
       end
 
@@ -146,23 +169,12 @@ module Cucumber
             runtime.invoke_dynamic_steps(steps_text, language, location)
           end
 
-          # rubocop:disable 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 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)
+          define_method(:attach) do |file, media_type|
+            runtime.attach(file, media_type)
           end
 
           # Prints the list of modules that are included in the World

data/lib/cucumber/glue/registry_and_more.rb

@@ -72,18 +72,33 @@ module Cucumber
       end
 
       def register_rb_hook(phase, tag_expressions, proc)
-        add_hook(phase, Hook.new(self, 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(self, 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)
@@ -102,7 +117,14 @@ module Cucumber
 
       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.define_parameter_type to be called from Glue::Dsl
+
+        # 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)
@@ -164,6 +186,21 @@ module Cucumber
 
       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(
+            id: @configuration.id_generator.new_id,
+            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

data/lib/cucumber/glue/snippet.rb

@@ -92,7 +92,7 @@ module Cucumber
         def to_s
           header = generated_expressions.each_with_index.map do |expr, i|
             prefix = i.zero? ? '' : '# '
-            "#{prefix}#{code_keyword}(\"#{expr.source}\") do#{parameters(expr)}"
+            "#{prefix}#{code_keyword}('#{expr.source}') do#{parameters(expr)}"
           end.join("\n")
 
           body = String.new # rubocop:disable Style/EmptyLiteral
@@ -174,7 +174,7 @@ module Cucumber
 
         class DocString
           def append_block_parameter_to(array)
-            array << 'string'
+            array << 'doc_string'
           end
 
           def append_comment_to(string); end

data/lib/cucumber/glue/step_definition.rb

@@ -24,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
@@ -62,16 +62,40 @@ module Cucumber
         end
       end
 
-      attr_reader :expression, :registry
+      attr_reader :id, :expression, :registry
 
-      def initialize(registry, expression, proc)
+      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::StepDefinition::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::StepDefinition::StepDefinitionPattern::StepDefinitionPatternType::CUCUMBER_EXPRESSION if expression.is_a?(CucumberExpressions::CucumberExpression)
+        Cucumber::Messages::StepDefinition::StepDefinitionPattern::StepDefinitionPatternType::REGULAR_EXPRESSION
+      end
+
       # @api private
       def to_hash
         type = expression.is_a?(CucumberExpressions::RegularExpression) ? 'regular expression' : 'cucumber expression'

data/lib/cucumber/hooks.rb

@@ -9,17 +9,17 @@ module Cucumber
   # source for test steps
   module Hooks
     class << self
-      def before_hook(location, &block)
-        build_hook_step(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(location, &block)
-        build_hook_step(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(test_step, location, &block)
+      def after_step_hook(id, test_step, location, &block)
         raise ArgumentError if test_step.hook?
-        build_hook_step(location, block, AfterStepHook, Core::Test::Action)
+        build_hook_step(id, location, block, AfterStepHook, Core::Test::Action)
       end
 
       def around_hook(&block)
@@ -28,10 +28,10 @@ module Cucumber
 
       private
 
-      def build_hook_step(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::HookStep.new(hook.text, location, action)
+        Core::Test::HookStep.new(id, hook.text, location, action)
       end
     end
 

data/lib/cucumber/multiline_argument.rb

@@ -15,7 +15,7 @@ module Cucumber
         location ||= Core::Test::Location.of_caller
         case argument
         when String
-          builder.doc_string(Core::Test::DocString.new(argument, content_type, location))
+          builder.doc_string(Core::Test::DocString.new(argument, content_type))
         when Array
           location = location.on_line(argument.first.line..argument.last.line)
           builder.data_table(argument.map(&:cells), location)

data/lib/cucumber/multiline_argument/data_table.rb

@@ -36,12 +36,12 @@ module Cucumber
       end
 
       class << self
-        def from(data, location = Core::Test::Location.of_caller)
+        def from(data)
           case data
           when Array
-            from_array(data, location)
+            from_array(data)
           when String
-            parse(data, location)
+            parse(data)
           else
             raise ArgumentError, 'expected data to be a String or an Array.'
           end
@@ -49,15 +49,15 @@ module Cucumber
 
         private
 
-        def parse(text, location = Core::Test::Location.of_caller)
+        def parse(text)
           builder = Builder.new
           parser = Cucumber::Gherkin::DataTableParser.new(builder)
           parser.parse(text)
-          from_array(builder.rows, location)
+          from_array(builder.rows)
         end
 
-        def from_array(data, location = Core::Test::Location.of_caller)
-          new Core::Test::DataTable.new(data, location)
+        def from_array(data)
+          new Core::Test::DataTable.new(data)
         end
       end
 
@@ -111,7 +111,7 @@ module Cucumber
       # registered with #map_column! and #map_headers!.
       #
       def dup
-        self.class.new(Core::Test::DataTable.new(raw, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Test::DataTable.new(raw), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Returns a new, transposed table. Example:
@@ -126,7 +126,7 @@ module Cucumber
       #   | 4 | 2 |
       #
       def transpose
-        self.class.new(Core::Test::DataTable.new(raw.transpose, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Test::DataTable.new(raw.transpose), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -269,7 +269,7 @@ module Cucumber
 
       # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings = {}, &block)
-        self.class.new(Core::Test::DataTable.new(raw, location), @conversion_procs.dup, mappings, block)
+        self.class.new(Core::Test::DataTable.new(raw), @conversion_procs.dup, mappings, block)
       end
 
       # Change how #hashes converts column values. The +column_name+ argument identifies the column
@@ -294,7 +294,7 @@ module Cucumber
       def map_column(column_name, strict = true, &conversion_proc)
         conversion_procs = @conversion_procs.dup
         conversion_procs[column_name.to_s] = { strict: strict, proc: conversion_proc }
-        self.class.new(Core::Test::DataTable.new(raw, location), conversion_procs, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Test::DataTable.new(raw), conversion_procs, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Compares +other_table+ to self. If +other_table+ contains columns
@@ -352,7 +352,11 @@ module Cucumber
         end
       end
 
-      def to_hash(cells) #:nodoc:
+      def to_hash
+        cells_rows.map { |cells| cells.map(&:value) }
+      end
+
+      def cells_to_hash(cells) #:nodoc:
         hash = Hash.new do |hash_inner, key|
           hash_inner[key.to_s] if key.is_a?(Symbol)
         end
@@ -551,7 +555,7 @@ module Cucumber
         end
 
         def to_hash #:nodoc:
-          @to_hash ||= @table.to_hash(self)
+          @to_hash ||= @table.cells_to_hash(self)
         end
 
         def value(n) #:nodoc: