cucumber 7.1.0 → 9.2.1

data/lib/cucumber/runtime/meta_message_builder.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/ci_environment'
+
+module Cucumber
+  class Runtime
+    # Builder to instantiate a Cucumber::Messages::Meta message filled-in with
+    # the runtime meta-data:
+    # - protocol version: the version of the Cucumber::Messages protocol
+    # - implementation: the name and version of the implementation (e.g. cucumber-ruby 8.0.0)
+    # - runtime: the name and version of the runtime (e.g. ruby 3.0.1)
+    # - os: the name and version of the operating system (e.g. linux 3.13.0-45-generic)
+    # - cpu: the name of the CPU (e.g. x86_64)
+    # - ci: information about the CI environment if any, including:
+    #   - name: the name of the CI environment (e.g. Jenkins)
+    #   - url: the URL of the CI environment (e.g. https://ci.example.com)
+    #   - build_number: the build number of the CI environment (e.g. 123)
+    #   - git: the git information of the CI environment if any
+    #     - remote: the remote of the git repository (e.g. git@github.com:cucumber/cucumber-ruby.git)
+    #     - revision: the revision of the git repository (e.g. abcdef)
+    #     - branch: the name of the git branch (e.g. main)
+    #     - tag: the name of the git tag (e.g. v1.0.0)
+    class MetaMessageBuilder
+      class << self
+        # Builds a Cucumber::Messages::Meta filled-in with the runtime meta-data
+        #
+        # @param [env] environment data from which the CI information will be
+        #  retrieved (default ENV). Can be used to mock the environment for
+        #  testing purpose.
+        #
+        # @return [Cucumber::Messages::Meta] the meta message
+        #
+        # @see Cucumber::Runtime::MetaMessageBuilder
+        #
+        # @example
+        # Cucumber::Runtime::MetaMessageBuilder.build_meta_message
+        #
+        def build_meta_message(env = ENV)
+          Cucumber::Messages::Meta.new(
+            protocol_version: protocol_version,
+            implementation: implementation,
+            runtime: runtime,
+            os: os,
+            cpu: cpu,
+            ci: ci(env)
+          )
+        end
+
+        private
+
+        def protocol_version
+          Cucumber::Messages::VERSION
+        end
+
+        def implementation
+          Cucumber::Messages::Product.new(
+            name: 'cucumber-ruby',
+            version: Cucumber::VERSION
+          )
+        end
+
+        def runtime
+          Cucumber::Messages::Product.new(
+            name: RUBY_ENGINE,
+            version: RUBY_VERSION
+          )
+        end
+
+        def os
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_os'],
+            version: Sys::Uname.uname.version
+          )
+        end
+
+        def cpu
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_cpu']
+          )
+        end
+
+        def ci(env)
+          ci_data = Cucumber::CiEnvironment.detect_ci_environment(env)
+          return nil unless ci_data
+
+          Cucumber::Messages::Ci.new(
+            name: ci_data[:name],
+            url: ci_data[:url],
+            build_number: ci_data[:buildNumber],
+            git: git_info(ci_data)
+          )
+        end
+
+        def git_info(ci_data)
+          return nil unless ci_data[:git]
+
+          Cucumber::Messages::Git.new(
+            remote: ci_data[:git][:remote],
+            revision: ci_data[:git][:revision],
+            branch: ci_data[:git][:branch],
+            tag: ci_data[:git][:tag]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -72,6 +72,7 @@ module Cucumber
       def invoke_dynamic_step(step_name, multiline_argument, _location = nil)
         matches = step_matches(step_name)
         raise UndefinedDynamicStep, step_name if matches.empty?
+
         matches.first.invoke(multiline_argument)
       end
 
@@ -109,6 +110,7 @@ module Cucumber
 
       def apply_before_hooks(test_case)
         return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:before, scenario)
         BeforeHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)
@@ -116,6 +118,7 @@ module Cucumber
 
       def apply_after_hooks(test_case)
         return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:after, scenario)
         AfterHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)

data/lib/cucumber/runtime/user_interface.rb

@@ -21,8 +21,8 @@ module Cucumber
       # that makes a sound before invoking #ask.
       #
       def ask(question, timeout_seconds)
-        STDOUT.puts(question)
-        STDOUT.flush
+        $stdout.puts(question)
+        $stdout.flush
         puts(question)
 
         answer = if Cucumber::JRUBY
@@ -32,6 +32,7 @@ module Cucumber
                  end
 
         raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+
         puts(answer)
         answer
       end
@@ -40,15 +41,15 @@ module Cucumber
       # be a path to a file, or if it's an image it may also be a Base64 encoded image.
       # The embedded data may or may not be ignored, depending on what kind of formatter(s) are active.
       #
-      def attach(src, media_type)
-        @visitor.attach(src, media_type)
+      def attach(src, media_type, filename)
+        @visitor.attach(src, media_type, filename)
       end
 
       private
 
       def mri_gets(timeout_seconds)
         Timeout.timeout(timeout_seconds) do
-          STDIN.gets
+          $stdin.gets
         end
       rescue Timeout::Error
         nil
@@ -57,7 +58,7 @@ module Cucumber
       def jruby_gets(timeout_seconds)
         answer = nil
         t = java.lang.Thread.new do
-          answer = STDIN.gets
+          answer = $stdin.gets
         end
         t.start
         t.join(timeout_seconds * 1000)

data/lib/cucumber/runtime.rb

@@ -2,7 +2,6 @@
 
 require 'fileutils'
 require 'cucumber/configuration'
-require 'cucumber/create_meta'
 require 'cucumber/deprecate'
 require 'cucumber/load_path'
 require 'cucumber/formatter/duration'
@@ -13,6 +12,7 @@ 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
@@ -26,8 +26,8 @@ module Cucumber
     attr_reader :path
 
     def initialize(original_exception, path)
-      super(original_exception)
       @path = path
+      super(original_exception)
     end
   end
 
@@ -37,6 +37,7 @@ module Cucumber
   class FeatureFolderNotFoundException < RuntimeError
     def initialize(path)
       @path = path
+      super
     end
 
     def message
@@ -65,23 +66,20 @@ module Cucumber
       @support_code.configure(@configuration)
     end
 
-    require 'cucumber/wire/plugin'
     def run!
       @configuration.notify :envelope, Cucumber::Messages::Envelope.new(
-        meta: Cucumber::CreateMeta.create_meta('cucumber-ruby', Cucumber::VERSION)
+        meta: MetaMessageBuilder.build_meta_message
       )
 
       load_step_definitions
-      fire_after_configuration_hook
       fire_install_plugin_hook
-      install_wire_plugin
       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.event_bus
-      @configuration.notify :test_run_finished
+      @configuration.notify :test_run_finished, !failure?
 
       fire_after_all_hook unless dry_run?
     end
@@ -112,21 +110,25 @@ module Cucumber
       Core::Test::DocString.new(string_without_triple_quotes, content_type)
     end
 
-    private
-
-    def fire_after_configuration_hook #:nodoc:
-      @support_code.fire_hook(:after_configuration, @configuration)
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed.positive?
+      else
+        !summary_report.ok?(strict: @configuration.strict)
+      end
     end
 
-    def fire_install_plugin_hook #:nodoc:
+    private
+
+    def fire_install_plugin_hook # :nodoc:
       @support_code.fire_hook(:install_plugin, @configuration, registry_wrapper)
     end
 
-    def fire_before_all_hook #:nodoc:
+    def fire_before_all_hook # :nodoc:
       @support_code.fire_hook(:before_all)
     end
 
-    def fire_after_all_hook #:nodoc:
+    def fire_after_all_hook # :nodoc:
       @support_code.fire_hook(:after_all)
     end
 
@@ -148,8 +150,8 @@ 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*$/.freeze # :nodoc:
+      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/.freeze # :nodoc:
 
       def self.read(path)
         new(path).read
@@ -189,6 +191,7 @@ module Cucumber
 
     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?
@@ -217,10 +220,12 @@ module Cucumber
     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
     end
@@ -229,17 +234,8 @@ module Cucumber
       factory.instance_method(:initialize).arity > 1
     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 # rubocop:disable Metrics/AbcSize
+    def filters
       tag_expressions = @configuration.tag_expressions
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
@@ -278,18 +274,6 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
-    def install_wire_plugin
-      return if Cucumber::Wire::Plugin.installed?
-      return unless @configuration.all_files_to_load.any? { |f| f =~ /\.wire$/ }
-
-      Cucumber::Wire::Plugin.new(@configuration, registry_wrapper).install
-      Cucumber.deprecate(
-        'See https://github.com/cucumber/cucumber-ruby/blob/main/UPGRADING.md#upgrading-to-710 for more info',
-        ' built-in usage of the wire protocol',
-        '8.0.0'
-      )
-    end
-
     def registry_wrapper
       Cucumber::Glue::RegistryWrapper.new(@support_code.registry)
     end

data/lib/cucumber/step_match.rb

@@ -4,11 +4,12 @@ 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 = step_definition
       @name_to_match = step_name
       @step_arguments = step_arguments
@@ -77,7 +78,7 @@ module Cucumber
 
         replacement = if block_given?
                         yield(group.value)
-                      elsif Proc == format.class
+                      elsif format.instance_of?(Proc)
                         format.call(group.value)
                       else
                         format % group.value
@@ -90,7 +91,7 @@ module Cucumber
       s
     end
 
-    def inspect #:nodoc:
+    def inspect # :nodoc:
       "#<#{self.class}: #{location}>"
     end
   end
@@ -101,7 +102,7 @@ module Cucumber
     end
   end
 
-  class NoStepMatch #:nodoc:
+  class NoStepMatch # :nodoc:
     attr_reader :step_definition, :name
 
     def initialize(step, name)
@@ -115,6 +116,7 @@ module Cucumber
 
     def location
       raise "No location for #{@step}" unless @step.location
+
       @step.location
     end
 

data/lib/cucumber/step_match_search.rb

@@ -20,6 +20,7 @@ module Cucumber
       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
@@ -35,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 }
@@ -54,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],
@@ -40,72 +61,75 @@ module Cucumber
       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
+      # Regular expression that is used to scan for ANSI-sequences while
+      # uncoloring strings.
+      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/.freeze
 
-      # 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
+      @coloring = true
 
-      # rubocop:disable Security/Eval
-      ATTRIBUTES.each do |c, v|
-        eval <<-END_EVAL, binding, __FILE__, __LINE__ + 1
-            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_EVAL
-      end
-      # rubocop:enable Security/Eval
+      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
 
-      # Regular expression that is used to scan for ANSI-sequences while
-      # uncoloring strings.
-      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+        # Returns true, if the coloring function of this module
+        # is switched on, false otherwise.
+        alias coloring? :coloring
+
+        def included(klass)
+          return unless klass == String
 
-      def self.included(klass)
-        return unless klass == String
-        ATTRIBUTES.delete(:clear)
-        ATTRIBUTE_NAMES.delete(:clear)
+          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)
+      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
+
+      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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/term/ansicolor'
 
 module Cucumber
@@ -30,6 +32,7 @@ module Cucumber
 
         def display_span(span)
           return apply_modifiers(span.shift, span) if span.is_a?(Array)
+
           span
         end
 

data/lib/cucumber.rb

@@ -14,7 +14,8 @@ module Cucumber
 
     def logger
       return @log if @log
-      @log = Logger.new(STDOUT)
+
+      @log = Logger.new($stdout)
       @log.level = Logger::INFO
       @log
     end

data/lib/simplecov_setup.rb

@@ -7,7 +7,7 @@ if ENV['SIMPLECOV']
 
     require 'simplecov'
 
-    SimpleCov.root(File.expand_path(File.dirname(__FILE__) + '/..'))
+    SimpleCov.root(File.expand_path("#{File.dirname(__FILE__)}/.."))
     SimpleCov.start do
       add_filter 'iso-8859-1_steps.rb'
       add_filter '.-ruby-core/'