cucumber 4.0.0.rc.3 → 4.0.1

data/lib/cucumber/formatter/pretty.rb

@@ -36,6 +36,7 @@ module Cucumber
         @config = config
         @options = config.to_hash
         @snippets_input = []
+        @undefined_parameter_types = []
         @total_duration = 0
         @exceptions = []
         @gherkin_sources = {}
@@ -54,6 +55,11 @@ module Cucumber
         @passed_test_cases = []
         @source_indent = 0
         @next_comment_to_be_printed = 0
+
+        bind_events(config)
+      end
+
+      def bind_events(config)
         config.on_event :gherkin_source_read, &method(:on_gherkin_source_read)
         config.on_event :step_activated, &method(:on_step_activated)
         config.on_event :test_case_started, &method(:on_test_case_started)
@@ -61,6 +67,7 @@ module Cucumber
         config.on_event :test_step_finished, &method(:on_test_step_finished)
         config.on_event :test_case_finished, &method(:on_test_case_finished)
         config.on_event :test_run_finished, &method(:on_test_run_finished)
+        config.on_event :undefined_parameter_type, &method(:collect_undefined_parameter_type_names)
       end
 
       def on_gherkin_source_read(event)
@@ -131,10 +138,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/progress.rb

@@ -21,6 +21,7 @@ module Cucumber
         @config = config
         @io = ensure_io(config.out_stream)
         @snippets_input = []
+        @undefined_parameter_types = []
         @total_duration = 0
         @matches = {}
         @pending_step_matches = []
@@ -36,6 +37,7 @@ module Cucumber
         config.on_event :test_step_finished, &method(:on_test_step_finished)
         config.on_event :test_case_finished, &method(:on_test_case_finished)
         config.on_event :test_run_finished, &method(:on_test_run_finished)
+        config.on_event :undefined_parameter_type, &method(:collect_undefined_parameter_type_names)
       end
 
       def on_step_activated(event)

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,20 @@ 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(*messages)
+        messages.each { |message| attach(message.to_s.dup, 'text/x.cucumber.log+plain') }
+      end
+
+      def attach(file, media_type)
         super
       end
 
@@ -146,23 +168,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,28 @@ 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 :undefined_parameter_type, type_name, string_or_regexp
       end
 
       def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
@@ -171,6 +181,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

@@ -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'