cucumber 3.1.2 → 8.0.0

data/lib/cucumber/runtime.rb

@@ -1,16 +1,19 @@
-# -*- coding: utf-8 -*-
 # frozen_string_literal: true
 
 require 'fileutils'
-require 'multi_json'
 require 'cucumber/configuration'
+require 'cucumber/deprecate'
 require 'cucumber/load_path'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
 require 'cucumber/filters'
 require 'cucumber/formatter/fanout'
 require 'cucumber/gherkin/i18n'
+require 'cucumber/glue/registry_wrapper'
 require 'cucumber/step_match_search'
+require 'cucumber/messages'
+require 'cucumber/runtime/meta_message_builder'
+require 'sys/uname'
 
 module Cucumber
   module FixRuby21Bug9285
@@ -19,21 +22,22 @@ module Cucumber
     end
   end
 
-  class FileException < Exception
-    attr :path
+  class FileException < RuntimeError
+    attr_reader :path
 
     def initialize(original_exception, path)
-      super(original_exception)
       @path = path
+      super(original_exception)
     end
   end
 
   class FileNotFoundException < FileException
   end
 
-  class FeatureFolderNotFoundException < Exception
+  class FeatureFolderNotFoundException < RuntimeError
     def initialize(path)
       @path = path
+      super
     end
 
     def message
@@ -54,7 +58,6 @@ module Cucumber
     def initialize(configuration = Configuration.default)
       @configuration = Configuration.new(configuration)
       @support_code = SupportCode.new(self, @configuration)
-      @results = Formatter::LegacyApi::Results.new
     end
 
     # Allows you to take an existing runtime and change its configuration
@@ -63,17 +66,22 @@ module Cucumber
       @support_code.configure(@configuration)
     end
 
-    require 'cucumber/wire/plugin'
     def run!
+      @configuration.notify :envelope, Cucumber::Messages::Envelope.new(
+        meta: MetaMessageBuilder.build_meta_message
+      )
+
       load_step_definitions
-      install_wire_plugin
-      fire_after_configuration_hook
+      fire_install_plugin_hook
+      fire_before_all_hook unless dry_run?
       # TODO: can we remove this state?
       self.visitor = report
 
       receiver = Test::Runner.new(@configuration.event_bus)
-      compile features, receiver, filters
-      @configuration.notify :test_run_finished
+      compile features, receiver, filters, @configuration.event_bus
+      @configuration.notify :test_run_finished, !failure?
+
+      fire_after_all_hook unless dry_run?
     end
 
     def features_paths
@@ -84,14 +92,6 @@ module Cucumber
       @configuration.dry_run?
     end
 
-    def scenarios(status = nil)
-      @results.scenarios(status)
-    end
-
-    def steps(status = nil)
-      @results.steps(status)
-    end
-
     def unmatched_step_definitions
       @support_code.unmatched_step_definitions
     end
@@ -107,14 +107,29 @@ module Cucumber
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type = '', _line_offset = 0)
-      location = Core::Ast::Location.of_caller
-      Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
+      Core::Test::DocString.new(string_without_triple_quotes, content_type)
+    end
+
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed > 0
+      else
+        !summary_report.ok?(@configuration.strict)
+      end
     end
 
     private
 
-    def fire_after_configuration_hook #:nodoc
-      @support_code.fire_hook(:after_configuration, @configuration)
+    def fire_install_plugin_hook # :nodoc:
+      @support_code.fire_hook(:install_plugin, @configuration, registry_wrapper)
+    end
+
+    def fire_before_all_hook # :nodoc:
+      @support_code.fire_hook(:before_all)
+    end
+
+    def fire_after_all_hook # :nodoc:
+      @support_code.fire_hook(:after_all)
     end
 
     require 'cucumber/core/gherkin/document'
@@ -135,22 +150,20 @@ module Cucumber
     end
 
     class NormalisedEncodingFile
-      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
-      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ # :nodoc:
+      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ # :nodoc:
 
       def self.read(path)
         new(path).read
       end
 
       def initialize(path)
-        begin
-          @file = File.new(path)
-          set_encoding
-        rescue Errno::EACCES => e
-          raise FileNotFoundException.new(e, File.expand_path(path))
-        rescue Errno::ENOENT
-          raise FeatureFolderNotFoundException.new(path)
-        end
+        @file = File.new(path)
+        set_encoding
+      rescue Errno::EACCES => e
+        raise FileNotFoundException.new(e, File.expand_path(path))
+      rescue Errno::ENOENT
+        raise FeatureFolderNotFoundException, path
       end
 
       def read
@@ -162,7 +175,7 @@ module Cucumber
       def set_encoding
         @file.each do |line|
           if ENCODING_PATTERN =~ line
-            @file.set_encoding $1
+            @file.set_encoding Regexp.last_match(1)
             break
           end
           break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
@@ -171,16 +184,17 @@ module Cucumber
       end
     end
 
-    require 'cucumber/formatter/legacy_api/adapter'
-    require 'cucumber/formatter/legacy_api/runtime_facade'
-    require 'cucumber/formatter/legacy_api/results'
     require 'cucumber/formatter/ignore_missing_messages'
     require 'cucumber/formatter/fail_fast'
+    require 'cucumber/formatter/publish_banner_printer'
     require 'cucumber/core/report/summary'
+
     def report
       return @report if @report
+
       reports = [summary_report] + formatters
       reports << fail_fast_report if @configuration.fail_fast?
+      reports << publish_banner_printer unless @configuration.publish_quiet?
       @report ||= Formatter::Fanout.new(reports)
     end
 
@@ -192,52 +206,36 @@ module Cucumber
       @fail_fast_report ||= Formatter::FailFast.new(@configuration)
     end
 
+    def publish_banner_printer
+      @publish_banner_printer ||= Formatter::PublishBannerPrinter.new(@configuration)
+    end
+
     def formatters
       @formatters ||=
-        @configuration.formatter_factories do |factory, formatter_options, path_or_io, options|
-          create_formatter(factory, formatter_options, path_or_io, options)
+        @configuration.formatter_factories do |factory, formatter_options, path_or_io|
+          create_formatter(factory, formatter_options, path_or_io)
         end
     end
 
-    def create_formatter(factory, formatter_options, path_or_io, cli_options)
-      if !legacy_formatter?(factory)
-        if accept_options?(factory)
-          return factory.new(@configuration, formatter_options) if path_or_io.nil?
-          return factory.new(@configuration.with_options(out_stream: path_or_io),
-                             formatter_options)
-        else
-          return factory.new(@configuration) if path_or_io.nil?
-          return factory.new(@configuration.with_options(out_stream: path_or_io))
-        end
+    def create_formatter(factory, formatter_options, path_or_io)
+      if accept_options?(factory)
+        return factory.new(@configuration, formatter_options) if path_or_io.nil?
+
+        factory.new(@configuration.with_options(out_stream: path_or_io),
+                    formatter_options)
+      else
+        return factory.new(@configuration) if path_or_io.nil?
+
+        factory.new(@configuration.with_options(out_stream: path_or_io))
       end
-      results = Formatter::LegacyApi::Results.new
-      runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
-      formatter = factory.new(runtime_facade, path_or_io, cli_options)
-      Formatter::LegacyApi::Adapter.new(
-        Formatter::IgnoreMissingMessages.new(formatter),
-        results, @configuration
-      )
     end
 
     def accept_options?(factory)
       factory.instance_method(:initialize).arity > 1
     end
 
-    def legacy_formatter?(factory)
-      factory.instance_method(:initialize).arity > 2
-    end
-
-    def failure?
-      if @configuration.wip?
-        summary_report.test_cases.total_passed > 0
-      else
-        !summary_report.ok?(@configuration.strict)
-      end
-    end
-    public :failure?
-
     require 'cucumber/core/test/filters'
-    def filters
+    def filters # rubocop:disable Metrics/AbcSize
       tag_expressions = @configuration.tag_expressions
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
@@ -250,14 +248,18 @@ module Cucumber
         # TODO: can we just use Glue::RegistryAndMore's step definitions directly?
         step_match_search = StepMatchSearch.new(@support_code.registry.method(:step_matches), @configuration)
         filters << Filters::ActivateSteps.new(step_match_search, @configuration)
-        @configuration.filters.each do |filter|
-          filters << filter
-        end
+        @configuration.filters.each { |filter| filters << filter }
+
         unless configuration.dry_run?
           filters << Filters::ApplyAfterStepHooks.new(@support_code)
           filters << Filters::ApplyBeforeHooks.new(@support_code)
           filters << Filters::ApplyAfterHooks.new(@support_code)
           filters << Filters::ApplyAroundHooks.new(@support_code)
+        end
+
+        filters << Filters::BroadcastTestCaseReadyEvent.new(@configuration)
+
+        unless configuration.dry_run?
           filters << Filters::BroadcastTestRunStartedEvent.new(@configuration)
           filters << Filters::Quit.new
           filters << Filters::Retry.new(@configuration)
@@ -272,8 +274,8 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
-    def install_wire_plugin
-      Cucumber::Wire::Plugin.new(@configuration).install if @configuration.all_files_to_load.any? { |f| f =~ %r{\.wire$} }
+    def registry_wrapper
+      Cucumber::Glue::RegistryWrapper.new(@support_code.registry)
     end
 
     def log

data/lib/cucumber/step_definition_light.rb

@@ -9,11 +9,12 @@ module Cucumber
     attr_reader :regexp_source, :location
 
     def initialize(regexp_source, location)
-      @regexp_source, @location = regexp_source, location
+      @regexp_source = regexp_source
+      @location = location
     end
 
-    def eql?(o)
-      regexp_source == o.regexp_source && location == o.location
+    def eql?(other)
+      regexp_source == other.regexp_source && location == other.location
     end
 
     def hash

data/lib/cucumber/step_definitions.rb

@@ -8,8 +8,8 @@ module Cucumber
       @support_code.load_files_from_paths(configuration.autoload_code_paths)
     end
 
-    def to_json
-      @support_code.step_definitions.map(&:to_hash).to_json
+    def to_json(obj = nil)
+      @support_code.step_definitions.map(&:to_hash).to_json(obj)
     end
   end
 end

data/lib/cucumber/step_match.rb

@@ -4,12 +4,15 @@ require 'cucumber/multiline_argument'
 
 module Cucumber
   # Represents the match found between a Test Step and its activation
-  class StepMatch #:nodoc:
+  class StepMatch # :nodoc:
     attr_reader :step_definition, :step_arguments
 
     def initialize(step_definition, step_name, step_arguments)
       raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
-      @step_definition, @name_to_match, @step_arguments = step_definition, step_name, step_arguments
+
+      @step_definition = step_definition
+      @name_to_match = step_name
+      @step_arguments = step_arguments
     end
 
     def args
@@ -21,12 +24,12 @@ module Cucumber
 
     def activate(test_step)
       test_step.with_action(@step_definition.location) do
-        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+        invoke(MultilineArgument.from_core(test_step.multiline_arg))
       end
     end
 
     def invoke(multiline_arg)
-      all_args = deep_clone_args
+      all_args = args
       multiline_arg.append_to(all_args)
       @step_definition.invoke(all_args)
     end
@@ -46,7 +49,7 @@ module Cucumber
     #
     #   lambda { |param| "[#{param}]" }
     #
-    def format_args(format = lambda { |a| a }, &proc)
+    def format_args(format = ->(a) { a }, &proc)
       replace_arguments(@name_to_match, @step_arguments, format, &proc)
     end
 
@@ -75,7 +78,7 @@ module Cucumber
 
         replacement = if block_given?
                         yield(group.value)
-                      elsif Proc === format
+                      elsif Proc == format.class
                         format.call(group.value)
                       else
                         format % group.value
@@ -88,24 +91,18 @@ module Cucumber
       s
     end
 
-    def inspect #:nodoc:
+    def inspect # :nodoc:
       "#<#{self.class}: #{location}>"
     end
-
-    private
-
-    def deep_clone_args
-      Marshal.load( Marshal.dump( args ) )
-    end
   end
 
   class SkippingStepMatch
     def activate(test_step)
-      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+      test_step.with_action { raise Core::Test::Result::Skipped }
     end
   end
 
-  class NoStepMatch #:nodoc:
+  class NoStepMatch # :nodoc:
     attr_reader :step_definition, :name
 
     def initialize(step, name)
@@ -119,12 +116,12 @@ module Cucumber
 
     def location
       raise "No location for #{@step}" unless @step.location
+
       @step.location
     end
 
     def file_colon_line
-      raise "No file:line for #{@step}" unless @step.file_colon_line
-      @step.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
@@ -132,7 +129,7 @@ module Cucumber
     end
 
     def text_length
-      @step.text_length
+      @step.text.length
     end
 
     def step_arguments
@@ -141,7 +138,7 @@ module Cucumber
 
     def activate(test_step)
       # noop
-      return test_step
+      test_step
     end
   end
 
@@ -151,7 +148,7 @@ module Cucumber
     end
 
     def activate(test_step)
-      return test_step.with_action { raise @error }
+      test_step.with_action { raise @error }
     end
   end
 end

data/lib/cucumber/step_match_search.rb

@@ -13,12 +13,14 @@ module Cucumber
 
     class AssertUnambiguousMatch
       def initialize(search, configuration)
-        @search, @configuration = search, configuration
+        @search = search
+        @configuration = configuration
       end
 
       def call(step_name)
         result = @search.call(step_name)
         raise Cucumber::Ambiguous.new(step_name, result, @configuration.guess?) if result.length > 1
+
         result
       end
     end
@@ -34,7 +36,7 @@ module Cucumber
 
       private
 
-      def best_matches(_step_name, step_matches) #:nodoc:
+      def best_matches(_step_name, step_matches) # :nodoc:
         no_groups      = step_matches.select { |step_match| step_match.args.empty? }
         max_arg_length = step_matches.map { |step_match| step_match.args.length }.max
         top_groups     = step_matches.select { |step_match| step_match.args.length == max_arg_length }
@@ -53,7 +55,7 @@ module Cucumber
 
     require 'delegate'
     class CachesStepMatch < SimpleDelegator
-      def call(step_name) #:nodoc:
+      def call(step_name) # :nodoc:
         @match_cache ||= {}
 
         matches = @match_cache[step_name]

data/lib/cucumber/term/ansicolor.rb

@@ -2,8 +2,28 @@
 
 module Cucumber
   module Term
-    # The ANSIColor module can be used for namespacing and mixed into your own
-    # classes.
+    # This module allows to colorize text using ANSI escape sequences.
+    #
+    # Include the module in your class and use its methods to colorize text.
+    #
+    # Example:
+    #
+    #   require 'cucumber/term/ansicolor'
+    #
+    #   class MyFormatter
+    #     include Cucumber::Term::ANSIColor
+    #
+    #     def initialize(config)
+    #       $stdout.puts yellow("Initializing formatter")
+    #       $stdout.puts green("Coloring is active \o/") if Cucumber::Term::ANSIColor.coloring?
+    #       $stdout.puts grey("Feature path:") + blue(bold(config.feature_dirs))
+    #     end
+    #   end
+    #
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'cucumber/term/ansicolor'; puts Cucumber::Term::ANSIColor.attributes"
+    #
     module ANSIColor
       # :stopdoc:
       ATTRIBUTES = [
@@ -27,6 +47,7 @@ module Cucumber
         [:magenta,       35],
         [:cyan,          36],
         [:white,         37],
+        [:grey,          90],
         [:on_black,      40],
         [:on_red,        41],
         [:on_green,      42],
@@ -35,77 +56,80 @@ module Cucumber
         [:on_magenta,    45],
         [:on_cyan,       46],
         [:on_white,      47]
-      ]
+      ].freeze
 
       ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
       # :startdoc:
 
-      # Returns true, if the coloring function of this module
-      # is switched on, false otherwise.
-      def self.coloring?
-        @coloring
-      end
-
-      # Turns the coloring on or off globally, so you can easily do
-      # this for example:
-      #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
-      def self.coloring=(val)
-        @coloring = val
-      end
-      self.coloring = true
-
-      ATTRIBUTES.each do |c, v|
-        eval %Q{
-            def #{c}(string = nil)
-              result = String.new
-              result << "\e[#{v}m" if Cucumber::Term::ANSIColor.coloring?
-              if block_given?
-                result << yield
-              elsif string
-                result << string
-              elsif respond_to?(:to_str)
-                result << to_str
-              else
-                return result #only switch on
-              end
-              result << "\e[0m" if Cucumber::Term::ANSIColor.coloring?
-              result
-            end
-        }
-      end
-
       # Regular expression that is used to scan for ANSI-sequences while
       # uncoloring strings.
       COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
 
-      def self.included(klass)
-        if klass == String
+      @coloring = true
+
+      class << self
+        # Turns the coloring on or off globally, so you can easily do
+        # this for example:
+        #  Cucumber::Term::ANSIColor::coloring = $stdout.isatty
+        attr_accessor :coloring
+
+        # Returns true, if the coloring function of this module
+        # is switched on, false otherwise.
+        alias coloring? :coloring
+
+        def included(klass)
+          return unless klass == String
+
           ATTRIBUTES.delete(:clear)
           ATTRIBUTE_NAMES.delete(:clear)
         end
       end
 
-      # Returns an uncolored version of the string, that is all
+      ATTRIBUTES.each do |color_name, color_code|
+        define_method(color_name) do |text = nil, &block|
+          if block
+            colorize(block.call, color_code)
+          elsif text
+            colorize(text, color_code)
+          elsif respond_to?(:to_str)
+            colorize(to_str, color_code)
+          else
+            colorize(nil, color_code) # switch coloration on
+          end
+        end
+      end
+
+      # Returns an uncolored version of the string
       # ANSI-sequences are stripped from the string.
-      def uncolored(string = nil) # :yields:
+      def uncolored(text = nil)
         if block_given?
-          yield.gsub(COLORED_REGEXP, '')
-        elsif string
-          string.gsub(COLORED_REGEXP, '')
+          uncolorize(yield)
+        elsif text
+          uncolorize(text)
         elsif respond_to?(:to_str)
-          to_str.gsub(COLORED_REGEXP, '')
+          uncolorize(to_str)
         else
           ''
         end
       end
 
-      module_function
-
       # Returns an array of all Cucumber::Term::ANSIColor attributes as symbols.
       def attributes
         ATTRIBUTE_NAMES
       end
-      extend self
+
+      private
+
+      def colorize(text, color_code)
+        return String.new(text || '') unless Cucumber::Term::ANSIColor.coloring?
+        return "\e[#{color_code}m" unless text
+
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      def uncolorize(string)
+        string.gsub(COLORED_REGEXP, '')
+      end
     end
   end
 end

data/lib/cucumber/term/banner.rb

@@ -0,0 +1,57 @@
+require 'cucumber/term/ansicolor'
+
+module Cucumber
+  module Term
+    module Banner
+      def display_banner(lines, io, border_modifiers = nil)
+        BannerMaker.new.display_banner(lines, io, border_modifiers || %i[green bold])
+      end
+
+      class BannerMaker
+        include Term::ANSIColor
+
+        def display_banner(lines, io, border_modifiers)
+          lines = lines.split("\n") if lines.is_a? String
+          longest_line_length = lines.map { |line| line_length(line) }.max
+
+          io.puts apply_modifiers("┌#{'─' * (longest_line_length + 2)}┐", border_modifiers)
+          lines.map do |line|
+            padding = ' ' * (longest_line_length - line_length(line))
+            io.puts "#{apply_modifiers('│', border_modifiers)} #{display_line(line)}#{padding} #{apply_modifiers('│', border_modifiers)}"
+          end
+          io.puts apply_modifiers("└#{'─' * (longest_line_length + 2)}┘", border_modifiers)
+        end
+
+        private
+
+        def display_line(line)
+          line.is_a?(Array) ? line.map { |span| display_span(span) }.join : line
+        end
+
+        def display_span(span)
+          return apply_modifiers(span.shift, span) if span.is_a?(Array)
+
+          span
+        end
+
+        def apply_modifiers(str, modifiers)
+          display = str
+          modifiers.each { |modifier| display = send(modifier, display) }
+          display
+        end
+
+        def line_length(line)
+          if line.is_a?(Array)
+            line.map { |span| span_length(span) }.sum
+          else
+            line.length
+          end
+        end
+
+        def span_length(span)
+          span.is_a?(Array) ? span[0].length : span.length
+        end
+      end
+    end
+  end
+end