cucumber 4.0.0.rc.3 → 4.0.0.rc.4

data/lib/cucumber/formatter/pretty.rb

@@ -131,10 +131,9 @@ module Cucumber
         print_summary
       end
 
-      def puts(*messages)
-        messages.each do |message|
-          @test_step_output.push message
-        end
+      def attach(src, media_type)
+        return unless media_type == 'text/x.cucumber.log+plain'
+        @test_step_output.push src
       end
 
       private

data/lib/cucumber/formatter/query/hook_by_test_step.rb

@@ -0,0 +1,31 @@
+require 'cucumber/formatter/errors'
+
+module Cucumber
+  module Formatter
+    module Query
+      class HookByTestStep
+        def initialize(config)
+          @hook_id_by_test_step_id = {}
+
+          config.on_event :test_step_created, &method(:on_test_step_created)
+          config.on_event :hook_test_step_created, &method(:on_hook_test_step_created)
+        end
+
+        def hook_id(test_step)
+          return @hook_id_by_test_step_id[test_step.id] if @hook_id_by_test_step_id.key?(test_step.id)
+          raise TestStepUnknownError, "No hook found for #{test_step.id} }. Known: #{@hook_id_by_test_step_id.keys}"
+        end
+
+        private
+
+        def on_test_step_created(event)
+          @hook_id_by_test_step_id[event.test_step.id] = nil
+        end
+
+        def on_hook_test_step_created(event)
+          @hook_id_by_test_step_id[event.test_step.id] = event.hook.id
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/query/pickle_by_test.rb

@@ -0,0 +1,26 @@
+require 'cucumber/formatter/errors'
+
+module Cucumber
+  module Formatter
+    module Query
+      class PickleByTest
+        def initialize(config)
+          @pickle_id_by_test_case_id = {}
+          config.on_event :test_case_created, &method(:on_test_case_created)
+        end
+
+        def pickle_id(test_case)
+          return @pickle_id_by_test_case_id[test_case.id] if @pickle_id_by_test_case_id.key?(test_case.id)
+
+          raise TestCaseUnknownError, "No pickle found for #{test_case.id} }. Known: #{@pickle_id_by_test_case_id.keys}"
+        end
+
+        private
+
+        def on_test_case_created(event)
+          @pickle_id_by_test_case_id[event.test_case.id] = event.pickle.id
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/query/pickle_step_by_test_step.rb

@@ -0,0 +1,26 @@
+require 'cucumber/formatter/errors'
+
+module Cucumber
+  module Formatter
+    module Query
+      class PickleStepByTestStep
+        def initialize(config)
+          @pickle_id_step_by_test_step_id = {}
+          config.on_event :test_step_created, &method(:on_test_step_created)
+        end
+
+        def pickle_step_id(test_step)
+          return @pickle_id_step_by_test_step_id[test_step.id] if @pickle_id_step_by_test_step_id.key?(test_step.id)
+
+          raise TestStepUnknownError, "No pickle step found for #{test_step.id} }. Known: #{@pickle_id_step_by_test_step_id.keys}"
+        end
+
+        private
+
+        def on_test_step_created(event)
+          @pickle_id_step_by_test_step_id[event.test_step.id] = event.pickle_step.id
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/query/step_definitions_by_test_step.rb

@@ -0,0 +1,40 @@
+require 'cucumber/formatter/errors'
+
+module Cucumber
+  module Formatter
+    module Query
+      class StepDefinitionsByTestStep
+        def initialize(config)
+          @step_definition_ids_by_test_step_id = {}
+          @step_match_arguments_by_test_step_id = {}
+
+          config.on_event :test_step_created, &method(:on_test_step_created)
+          config.on_event :step_activated, &method(:on_step_activated)
+        end
+
+        def step_definition_ids(test_step)
+          return @step_definition_ids_by_test_step_id[test_step.id] if @step_definition_ids_by_test_step_id.key?(test_step.id)
+
+          raise TestStepUnknownError, "No step definition found for #{test_step.id} }. Known: #{@step_definition_ids_by_test_step_id.keys}"
+        end
+
+        def step_match_arguments(test_step)
+          return @step_match_arguments_by_test_step_id[test_step.id] if @step_match_arguments_by_test_step_id.key?(test_step.id)
+
+          raise TestStepUnknownError, "No step match arguments found for #{test_step.id} }. Known: #{@step_match_arguments_by_test_step_id.keys}"
+        end
+
+        private
+
+        def on_test_step_created(event)
+          @step_definition_ids_by_test_step_id[event.test_step.id] = []
+        end
+
+        def on_step_activated(event)
+          @step_definition_ids_by_test_step_id[event.test_step.id] << event.step_match.step_definition.id
+          @step_match_arguments_by_test_step_id[event.test_step.id] = event.step_match.step_arguments
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/query/test_case_started_by_test_case.rb

@@ -0,0 +1,40 @@
+require 'cucumber/formatter/errors'
+
+module Cucumber
+  module Formatter
+    module Query
+      class TestCaseStartedByTestCase
+        def initialize(config)
+          @config = config
+          config.on_event :test_case_created, &method(:on_test_case_created)
+          config.on_event :test_case_started, &method(:on_test_case_started)
+
+          @attempts_by_test_case_id = {}
+          @test_case_started_id_by_test_case_id = {}
+        end
+
+        def attempt_by_test_case(test_case)
+          raise TestCaseUnknownError, "No test case found for #{test_case.id} }. Known: #{@attempts_by_test_case_id.keys}" unless @attempts_by_test_case_id.key?(test_case.id)
+          @attempts_by_test_case_id[test_case.id]
+        end
+
+        def test_case_started_id_by_test_case(test_case)
+          raise TestCaseUnknownError, "No test case found for #{test_case.id} }. Known: #{@test_case_started_id_by_test_case_id.keys}" unless @test_case_started_id_by_test_case_id.key?(test_case.id)
+          @test_case_started_id_by_test_case_id[test_case.id]
+        end
+
+        private
+
+        def on_test_case_created(event)
+          @attempts_by_test_case_id[event.test_case.id] = 0
+          @test_case_started_id_by_test_case_id[event.test_case.id] = nil
+        end
+
+        def on_test_case_started(event)
+          @attempts_by_test_case_id[event.test_case.id] += 1
+          @test_case_started_id_by_test_case_id[event.test_case.id] = @config.id_generator.new_id
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -15,7 +15,7 @@ module Cucumber
         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?

data/lib/cucumber/gherkin/steps_parser.rb

@@ -17,7 +17,7 @@ module Cucumber
         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])

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 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)
+          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)
@@ -171,6 +186,20 @@ 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(
+            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/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::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'

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