honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/gherkin/formatter/ansi_escapes.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module Gherkin
-    module Formatter
-      # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
-      # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
-      # tweak the familiar POSIX command <tt>ls</tt> with
-      # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
-      #
-      # The colours that you can change are:
-      #
-      # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
-      # <tt>pending</tt>::       defaults to <tt>yellow</tt>
-      # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
-      # <tt>executing</tt>::     defaults to <tt>grey</tt>
-      # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
-      # <tt>failed</tt>::        defaults to <tt>red</tt>
-      # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
-      # <tt>passed</tt>::        defaults to <tt>green</tt>
-      # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
-      # <tt>outline</tt>::       defaults to <tt>cyan</tt>
-      # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
-      # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
-      # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
-      # <tt>comment</tt>::       defaults to <tt>grey</tt>
-      # <tt>tag</tt>::           defaults to <tt>cyan</tt>
-      #
-      # For instance, if your shell has a black background and a green font (like the
-      # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
-      # steps to be white instead of green. Examples:
-      #
-      #   export GHERKIN_COLORS="passed=white"
-      #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
-      #
-      # (If you're on Windows, use SET instead of export).
-      # To see what colours and effects are available, just run this in your shell:
-      #
-      #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
-      #
-      # Although not listed, you can also use <tt>grey</tt>
-      module AnsiEscapes
-        COLORS = {
-          'black'   => "\e[30m",
-          'red'     => "\e[31m",
-          'green'   => "\e[32m",
-          'yellow'  => "\e[33m",
-          'blue'    => "\e[34m",
-          'magenta' => "\e[35m",
-          'cyan'    => "\e[36m",
-          'white'   => "\e[37m",
-          'grey'    => "\e[90m",
-          'bold'    => "\e[1m"
-        }.freeze
-
-        ALIASES = Hash.new do |h, k|
-          "#{h[Regexp.last_match(1)]},bold" if k.to_s =~ /(.*)_arg/
-        end.merge(
-          'undefined' => 'yellow',
-          'pending'   => 'yellow',
-          'executing' => 'grey',
-          'failed'    => 'red',
-          'passed'    => 'green',
-          'outline'   => 'cyan',
-          'skipped'   => 'cyan',
-          'comments'  => 'grey',
-          'tag'       => 'cyan'
-        )
-
-        # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
-        ENV.fetch('GHERKIN_COLORS', '').split(':').each do |pair|
-          rule, colour = pair.split('=')
-          ALIASES[colour] = rule
-        end
-
-        ALIASES.each_key do |key|
-          define_method(key) do
-            ALIASES[key].split(',').map { |color| COLORS[color] }.join('')
-          end
-
-          define_method("#{key}_arg") do
-            ALIASES["#{key}_arg"].split(',').map { |color| COLORS[color] }.join('')
-          end
-        end
-
-        def reset
-          "\e[0m"
-        end
-
-        def up(n)
-          "\e[#{n}A"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/gherkin/formatter/escaping.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module Gherkin
-    module Formatter
-      module Escaping
-        # Escapes a pipes and backslashes:
-        #
-        # * | becomes \|
-        # * \ becomes \\
-        #
-        # This is used in the pretty formatter.
-        def escape_cell(sym)
-          sym.gsub(/\\(?!\|)/, '\\\\\\\\').gsub(/\n/, '\\n').gsub(/\|/, '\\|')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/gherkin/i18n.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module Gherkin
-    module I18n
-      class << self
-        def code_keyword_for(gherkin_keyword)
-          gherkin_keyword.gsub(/[\s',!]/, '').strip
-        end
-
-        def code_keywords_for(gherkin_keywords)
-          gherkin_keywords.reject { |kw| kw == '* ' }.map { |kw| code_keyword_for(kw) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/gherkin/steps_parser.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'gherkin'
-require 'gherkin/dialect'
-
-module Cucumber
-  module Gherkin
-    class StepsParser
-      def initialize(builder, language)
-        @builder = builder
-        @language = language
-      end
-
-      def parse(text)
-        dialect = ::Gherkin::Dialect.for(@language)
-        gherkin_document = nil
-        messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
-
-        messages.each do |message|
-          gherkin_document = message.gherkin_document.to_h 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]}:
-         )
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/glue/dsl.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/deprecate'
-
-module Cucumber
-  module Glue
-    # This module provides the methods the DSL you can use to define
-    # steps, hooks, transforms etc.
-    module Dsl
-      class << self
-        attr_writer :rb_language
-
-        def alias_adverb(adverb)
-          alias_method adverb, :register_rb_step_definition
-        end
-
-        def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
-          @rb_language.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
-        end
-
-        def register_rb_hook(phase, tag_names, proc, name: nil)
-          @rb_language.register_rb_hook(phase, tag_names, proc, name: name)
-        end
-
-        def define_parameter_type(parameter_type)
-          @rb_language.define_parameter_type(parameter_type)
-        end
-
-        def register_rb_step_definition(regexp, proc_or_sym, options = {})
-          @rb_language.register_rb_step_definition(regexp, proc_or_sym, options)
-        end
-      end
-
-      # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
-      # The +proc+ will be executed once before each scenario to create an
-      # Object that the scenario's steps will run within. Any +world_modules+
-      # will be mixed into this Object (via Object#extend).
-      #
-      # By default the +world modules+ are added to a global namespace. It is
-      # possible to create a namespaced World by using an hash, where the
-      # symbols are the namespaces.
-      #
-      # This method is typically called from one or more Ruby scripts under
-      # <tt>features/support</tt>. You can call this method as many times as you
-      # like (to register more modules), but if you try to register more than
-      # one Proc you will get an error.
-      #
-      # Cucumber will not yield anything to the +proc+. Examples:
-      #
-      #    World do
-      #      MyClass.new
-      #    end
-      #
-      #    World(MyModule)
-      #
-      #    World(my_module: MyModule)
-      #
-      def World(*world_modules, **namespaced_world_modules, &proc)
-        Dsl.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
-      end
-
-      # Registers a proc that will run before each Scenario. You can register as many
-      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def Before(*tag_expressions, name: nil, &proc)
-        Dsl.register_rb_hook('before', tag_expressions, proc, name: name)
-      end
-
-      # Registers a proc that will run after each Scenario. You can register as many
-      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def After(*tag_expressions, name: nil, &proc)
-        Dsl.register_rb_hook('after', tag_expressions, proc, name: name)
-      end
-
-      # Registers a proc that will be wrapped around each scenario. The proc
-      # should accept two arguments: two arguments: the scenario and a "block"
-      # argument (but passed as a regular argument, since blocks cannot accept
-      # blocks in 1.8), on which it should call the .call method. You can register
-      # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def Around(*tag_expressions, name: nil, &proc)
-        Dsl.register_rb_hook('around', tag_expressions, proc, name: name)
-      end
-
-      # Registers a proc that will run after each Step. You can register as
-      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def AfterStep(*tag_expressions, name: nil, &proc)
-        Dsl.register_rb_hook('after_step', tag_expressions, proc, name: name)
-      end
-
-      def ParameterType(options)
-        type = options[:type] || Object
-        use_for_snippets = if_nil(options[:use_for_snippets], true)
-        prefer_for_regexp_match = if_nil(options[:prefer_for_regexp_match], false)
-
-        parameter_type = CucumberExpressions::ParameterType.new(
-          options[:name],
-          options[:regexp],
-          type,
-          options[:transformer],
-          use_for_snippets,
-          prefer_for_regexp_match
-        )
-        Dsl.define_parameter_type(parameter_type)
-      end
-
-      def if_nil(value, default)
-        value.nil? ? default : value
-      end
-
-      # Registers a proc that will run after Cucumber is configured in order to install an external plugin.
-      def InstallPlugin(name: nil, &proc)
-        Dsl.register_rb_hook('install_plugin', [], proc, name: name)
-      end
-
-      # Registers a proc that will run before the execution of the scenarios.
-      # Use it for your final set-ups
-      def BeforeAll(name: nil, &proc)
-        Dsl.register_rb_hook('before_all', [], proc, name: name)
-      end
-
-      # Registers a proc that will run after the execution of the scenarios.
-      # Use it for your final clean-ups
-      def AfterAll(name: nil, &proc)
-        Dsl.register_rb_hook('after_all', [], proc, name: name)
-      end
-
-      # Registers a new Ruby StepDefinition. This method is aliased
-      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
-      # also to the i18n translations whenever a feature of a
-      # new language is loaded.
-      #
-      # If provided, the +symbol+ is sent to the <tt>World</tt> object
-      # as defined by #World. A new <tt>World</tt> object is created
-      # for each scenario and is shared across step definitions within
-      # that scenario. If the +options+ hash contains an <tt>:on</tt>
-      # key, the value for this is assumed to be a proc. This proc
-      # will be executed in the context of the <tt>World</tt> object
-      # and then sent the +symbol+.
-      #
-      # If no +symbol+ if provided then the +&proc+ gets executed in
-      # the context of the <tt>World</tt> object.
-      def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
-        proc_or_sym = symbol || proc
-        Dsl.register_rb_step_definition(regexp, proc_or_sym, options)
-      end
-    end
-  end
-end
-
-# rubocop:disable Style/MixinUsage
-# This "should" always be present, because it allows users to write `Before` and `After`
-# See. https://github.com/cucumber/cucumber-ruby/pull/1566#discussion_r683235396
-extend(Cucumber::Glue::Dsl)
-# rubocop:enable Style/MixinUsage

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/glue/hook.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/glue/invoke_in_world'
-
-module Cucumber
-  module Glue
-    # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
-    class Hook
-      attr_reader :id, :tag_expressions, :location, :name
-
-      def initialize(id, registry, tag_expressions, proc, name: nil)
-        @id = id
-        @registry = registry
-        @name = name
-        @tag_expressions = sanitize_tag_expressions(tag_expressions)
-        @proc = proc
-        @location = Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
-        fail_for_old_style_tag_expressions(@tag_expressions)
-      end
-
-      def invoke(pseudo_method, arguments, &block)
-        check_arity = false
-        InvokeInWorld.cucumber_instance_exec_in(
-          @registry.current_world,
-          check_arity,
-          pseudo_method,
-          *[arguments, block].flatten.compact,
-          &@proc
-        )
-      end
-
-      def to_envelope
-        Cucumber::Messages::Envelope.new(
-          hook: Cucumber::Messages::Hook.new(
-            id: id,
-            name: name,
-            tag_expression: tag_expressions.empty? ? nil : 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)
-        # TODO: remove when '~@no-clobber' has been changed to 'not @no-clobber' in aruba
-        tag_expressions.map { |tag_expression| tag_expression == '~@no-clobber' ? 'not @no-clobber' : tag_expression }
-      end
-
-      def fail_for_old_style_tag_expressions(tag_expressions)
-        tag_expressions.each do |tag_expression|
-          if tag_expression.include?('~')
-            raise("Found tagged hook with '#{tag_expression}'." \
-            "'~@tag' is no longer supported, use 'not @tag' instead.")
-          end
-
-          next unless tag_expression.include?(',')
-
-          warn("Found tagged hook with '#{tag_expression}'." \
-            "'@tag1,@tag2' is no longer supported, use '@tag or @tag2' instead.")
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/glue/invoke_in_world.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/platform'
-module Cucumber
-  module Glue
-    # Utility methods for executing step definitions with nice backtraces etc.
-    # TODO: add unit tests
-    # TODO: refactor for readability
-    class InvokeInWorld
-      def self.replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
-        return if Cucumber.use_full_backtrace
-
-        instance_exec_pos = backtrace.index(instance_exec_invocation_line)
-        return unless instance_exec_pos
-
-        replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
-        backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
-
-        depth = backtrace.count { |line| line == instance_exec_invocation_line }
-        end_pos = depth > 1 ? instance_exec_pos : -1
-
-        backtrace[replacement_line + 1..end_pos] = nil
-        backtrace.compact!
-      end
-
-      def self.cucumber_instance_exec_in(world, check_arity, pseudo_method, *args, &block)
-        cucumber_run_with_backtrace_filtering(pseudo_method) do
-          if check_arity && !cucumber_compatible_arity?(args, block)
-            world.instance_exec do
-              ari = block.arity
-              ari = ari.negative? ? "#{ari.abs - 1}+" : ari
-              s1 = ari == 1 ? '' : 's'
-              s2 = args.length == 1 ? '' : 's'
-              raise ArityMismatchError, "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
-            end
-          else
-            world.instance_exec(*args, &block)
-          end
-        end
-      end
-
-      def self.cucumber_compatible_arity?(args, block)
-        return true if block.arity == args.length
-        return true if block.arity.negative? && args.length >= (block.arity.abs - 1)
-
-        false
-      end
-
-      def self.cucumber_run_with_backtrace_filtering(pseudo_method)
-        yield
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
-        replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
-        raise e
-      end
-
-      INSTANCE_EXEC_OFFSET = -3
-    end
-
-    # Raised if the number of a StepDefinition's Regexp match groups
-    # is different from the number of Proc arguments.
-    class ArityMismatchError < StandardError
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/glue/proto_world.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/gherkin/formatter/ansi_escapes'
-require 'cucumber/core/test/data_table'
-require 'cucumber/deprecate'
-require 'mini_mime'
-
-module Cucumber
-  module Glue
-    # Defines the basic API methods available in all Cucumber step definitions.
-    #
-    # You can, and probably should, extend this API with your own methods that
-    # make sense in your domain. For more on that, see {Cucumber::Glue::Dsl#World}
-    module ProtoWorld
-      # Run a single Gherkin step
-      # @example Call another step
-      #   step "I am logged in"
-      # @example Call a step with quotes in the name
-      #   step %{the user "Dave" is logged in}
-      # @example Passing a table
-      #   step "the following users exist:", table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @example Passing a multiline string
-      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
-      # @param [String] name The name of the step
-      # @param [String, Cucumber::Test::DocString, Cucumber::Ast::Table] raw_multiline_arg
-      def step(name, raw_multiline_arg = nil)
-        super
-      end
-
-      # Run a snippet of Gherkin
-      # @example
-      #   steps %{
-      #     Given the user "Susan" exists
-      #     And I am logged in as "Susan"
-      #   }
-      # @param [String] steps_text The Gherkin snippet to run
-      def steps(steps_text)
-        super
-      end
-
-      # Parse Gherkin into a {Cucumber::Ast::Table} object.
-      #
-      # Useful in conjunction with the #step method.
-      # @example Create a table
-      #   users = table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @param [String] text_or_table The Gherkin string that represents the table
-      # Returns a Cucumber::MultilineArgument::DataTable for +text_or_table+, which can either
-      # be a String:
-      #
-      #   table(%{
-      #     | account | description | amount |
-      #     | INT-100 | Taxi        | 114    |
-      #     | CUC-101 | Peeler      | 22     |
-      #   })
-      #
-      # or a 2D Array:
-      #
-      #   table([
-      #     %w{ account description amount },
-      #     %w{ INT-100 Taxi        114    },
-      #     %w{ CUC-101 Peeler      22     }
-      #   ])
-      #
-      def table(text_or_table)
-        MultilineArgument::DataTable.from(text_or_table)
-      end
-
-      # Pause the tests and ask the operator for input
-      def ask(question, timeout_seconds = 60)
-        super
-      end
-
-      def log(*messages)
-        messages.each { |message| attach(message.to_s.dup, 'text/x.cucumber.log+plain') }
-      end
-
-      # Attach a file to the output
-      # @param file [string|io] the file to attach.
-      #   It can be a string containing the file content itself, the file path, or an IO ready to be read.
-      # @param media_type [string] the media type.
-      #   If file is a valid path, media_type can be omitted, it will then be inferred from the file name.
-      # @param filename [string] the name of the file you wish to specify.
-      #   This is only needed in situations where you want to rename a PDF download e.t.c. - In most situations
-      #   you should not need to pass a filename
-      def attach(file, media_type = nil, filename = nil)
-        return super unless File.file?(file)
-
-        content = File.read(file, mode: 'rb')
-        media_type = MiniMime.lookup_by_filename(file)&.content_type if media_type.nil?
-
-        super(content, media_type.to_s, filename)
-      rescue StandardError
-        super
-      end
-
-      # Mark the matched step as pending.
-      def pending(message = 'TODO')
-        raise Pending, message unless block_given?
-
-        yield
-      rescue Exception
-        raise Pending, message
-      end
-
-      # Skips this step and the remaining steps in the scenario
-      def skip_this_scenario(message = 'Scenario skipped')
-        raise Core::Test::Result::Skipped, message
-      end
-
-      # Prints the list of modules that are included in the World
-      def inspect
-        super
-      end
-
-      # see {#inspect}
-      def to_s
-        inspect
-      end
-
-      # Dynamically generate the API module, closuring the dependencies
-      def self.for(runtime, language)
-        Module.new do
-          def self.extended(object)
-            # wrap the dynamically generated module so that we can document the methods
-            # for yardoc, which doesn't like define_method.
-            object.extend(ProtoWorld)
-          end
-
-          # TODO: pass these in when building the module, instead of mutating them later
-          # Extend the World with user-defined modules
-          def add_modules!(world_modules, namespaced_world_modules)
-            add_world_modules!(world_modules) if world_modules.any?
-            add_namespaced_modules!(namespaced_world_modules) if namespaced_world_modules.any?
-          end
-
-          define_method(:step) do |name, raw_multiline_arg = nil|
-            location = Core::Test::Location.of_caller
-            runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
-          end
-
-          define_method(:steps) do |steps_text|
-            location = Core::Test::Location.of_caller
-            runtime.invoke_dynamic_steps(steps_text, language, location)
-          end
-
-          define_method(:ask) do |question, timeout_seconds = 60|
-            runtime.ask(question, timeout_seconds)
-          end
-
-          define_method(:attach) do |file, media_type, filename|
-            runtime.attach(file, media_type, filename)
-          end
-
-          # Prints the list of modules that are included in the World
-          def inspect
-            modules = [self.class]
-            (class << self; self; end).instance_eval do
-              modules += included_modules
-            end
-            modules << stringify_namespaced_modules
-            format('#<%<modules>s:0x%<object_id>x>', modules: modules.join('+'), object_id: object_id)
-          end
-
-          private
-
-          def add_world_modules!(modules)
-            modules.each do |world_module|
-              extend(world_module)
-            end
-          end
-
-          def add_namespaced_modules!(modules)
-            @__namespaced_modules = modules
-            modules.each do |namespace, world_modules|
-              world_modules.each do |world_module|
-                variable_name = "@__#{namespace}_world"
-                inner_world = instance_variable_get(variable_name) || Object.new
-
-                instance_variable_set(
-                  variable_name,
-                  inner_world.extend(world_module)
-                )
-
-                self.class.send(:define_method, namespace) do
-                  instance_variable_get(variable_name)
-                end
-              end
-            end
-          end
-
-          def stringify_namespaced_modules
-            return '' if @__namespaced_modules.nil?
-
-            @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
-          end
-        end
-      end
-
-      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
-    end
-  end
-end