honeybadger 5.4.0 → 5.4.1

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module StepMatchSearch
-    def self.new(search, configuration)
-      CachesStepMatch.new(
-        AssertUnambiguousMatch.new(
-          configuration.guess? ? AttemptToGuessAmbiguousMatch.new(search) : search,
-          configuration
-        )
-      )
-    end
-
-    class AssertUnambiguousMatch
-      def initialize(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
-
-    class AttemptToGuessAmbiguousMatch
-      def initialize(search)
-        @search = search
-      end
-
-      def call(step_name)
-        best_matches(step_name, @search.call(step_name))
-      end
-
-      private
-
-      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 }
-
-        if no_groups.any?
-          longest_regexp_length = no_groups.map(&:text_length).max
-          no_groups.select { |step_match| step_match.text_length == longest_regexp_length }
-        elsif top_groups.any?
-          shortest_capture_length = top_groups.map { |step_match| step_match.args.inject(0) { |sum, c| sum + c.to_s.length } }.min
-          top_groups.select { |step_match| step_match.args.inject(0) { |sum, c| sum + c.to_s.length } == shortest_capture_length }
-        else
-          top_groups
-        end
-      end
-    end
-
-    require 'delegate'
-    class CachesStepMatch < SimpleDelegator
-      def call(step_name) # :nodoc:
-        @match_cache ||= {}
-
-        matches = @match_cache[step_name]
-        return matches if matches
-
-        @match_cache[step_name] = super(step_name)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/term/ansicolor.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module Term
-    # 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 = [
-        [:clear,         0],
-        [:reset,         0], # synonym for :clear
-        [:bold,          1],
-        [:dark,          2],
-        [:italic,        3], # not widely implemented
-        [:underline,     4],
-        [:underscore,    4], # synonym for :underline
-        [:blink,         5],
-        [:rapid_blink,   6], # not widely implemented
-        [:negative,      7], # no reverse because of String#reverse
-        [:concealed,     8],
-        [:strikethrough, 9], # not widely implemented
-        [:black,         30],
-        [:red,           31],
-        [:green,         32],
-        [:yellow,        33],
-        [:blue,          34],
-        [:magenta,       35],
-        [:cyan,          36],
-        [:white,         37],
-        [:grey,          90],
-        [:on_black,      40],
-        [:on_red,        41],
-        [:on_green,      42],
-        [:on_yellow,     43],
-        [:on_blue,       44],
-        [:on_magenta,    45],
-        [:on_cyan,       46],
-        [:on_white,      47]
-      ].freeze
-
-      ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
-      # :startdoc:
-
-      # Regular expression that is used to scan for ANSI-sequences while
-      # uncoloring strings.
-      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/.freeze
-
-      @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
-
-      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(text = nil)
-        if block_given?
-          uncolorize(yield)
-        elsif text
-          uncolorize(text)
-        elsif respond_to?(:to_str)
-          uncolorize(to_str)
-        else
-          ''
-        end
-      end
-
-      # 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/vendor/bundle/ruby/3.2.0/gems/cucumber-9.1.0/lib/cucumber/term/banner.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-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

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  class Unit
-    def initialize(step_collection)
-      @step_collection = step_collection
-    end
-
-    def step_count
-      @step_collection.length
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/encoding'
-require 'cucumber/platform'
-require 'cucumber/runtime'
-require 'cucumber/cli/main'
-require 'cucumber/step_definitions'
-require 'cucumber/term/ansicolor'
-
-module Cucumber
-  class << self
-    attr_accessor :wants_to_quit, :use_legacy_autoloader
-
-    def logger
-      return @log if @log
-
-      @log = Logger.new($stdout)
-      @log.level = Logger::INFO
-      @log
-    end
-
-    def logger=(logger)
-      @log = logger
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['SIMPLECOV']
-  begin
-    # Suppress warnings in order not to pollute stdout which tests expectations rely on
-    $VERBOSE = nil if defined?(JRUBY_VERSION)
-
-    require 'simplecov'
-
-    SimpleCov.root(File.expand_path("#{File.dirname(__FILE__)}/.."))
-    SimpleCov.start do
-      add_filter 'iso-8859-1_steps.rb'
-      add_filter '.-ruby-core/'
-      add_filter '/spec/'
-      add_filter '/features/'
-    end
-  rescue LoadError
-    warn('Unable to load simplecov')
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/lib/cucumber/ci_environment/variable_expression.rb

@@ -1,41 +0,0 @@
-module Cucumber
-  module CiEnvironment
-    module VariableExpression
-      def evaluate(expression, env)
-        return nil if expression.nil?
-        begin
-          expression.gsub(/\${(.*?)(?:(?<!\\)\/(.*)\/(.*))?}/) do
-            variable = $1
-            pattern = $2
-            replacement = $3
-
-            value = get_value(variable, env)
-            raise "Undefined variable #{variable}" if value.nil?
-            if pattern.nil?
-              value
-            else
-              regexp = Regexp.new(pattern.gsub('\/', '/'))
-              match = value.match(regexp)
-              raise "No match for variable #{variable}" if match.nil?
-              match[1..-1].each_with_index do |group, i|
-                replacement = replacement.gsub("\\#{i+1}", group)
-              end
-              replacement
-            end
-          end
-        rescue
-          nil
-        end
-      end
-
-      def get_value(variable, env)
-        if variable.index('*')
-          env.each do |name, value|
-            return value if Regexp.new(variable.gsub('*', '.*')) =~ name
-          end
-        end
-        env[variable]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/lib/cucumber/ci_environment.rb

@@ -1,80 +0,0 @@
-require 'uri'
-require 'json'
-require 'cucumber/ci_environment/variable_expression'
-
-module Cucumber
-  module CiEnvironment
-    extend VariableExpression
-    CI_ENVIRONMENTS_PATH = File.join(File.dirname(__FILE__), 'ci_environment/CiEnvironments.json')
-
-    def detect_ci_environment(env)
-      ci_environments = JSON.parse(IO.read(CI_ENVIRONMENTS_PATH))
-      ci_environments.each do |ci_environment|
-        detected = detect(ci_environment, env)
-        return detected unless detected.nil?
-      end
-
-      nil
-    end
-
-    def detect(ci_environment, env)
-      url = evaluate(ci_environment['url'], env)
-      return nil if url.nil?
-
-      result = {
-        name: ci_environment['name'],
-        url: url,
-        buildNumber: evaluate(ci_environment['buildNumber'], env),
-      }
-
-      detected_git = detect_git(ci_environment, env)
-      result[:git] = detected_git if detected_git
-      result
-    end
-
-    def detect_git(ci_environment, env)
-      revision = detect_revision(ci_environment, env)
-      return nil if revision.nil?
-
-      remote = evaluate(ci_environment['git']['remote'], env)
-      return nil if remote.nil?
-
-      git_info = {
-        remote: remove_userinfo_from_url(remote),
-        revision: revision,
-      }
-
-      tag = evaluate(ci_environment['git']['tag'], env)
-      branch = evaluate(ci_environment['git']['branch'], env)
-      git_info[:tag] = tag if tag
-      git_info[:branch] = branch if branch
-      git_info
-    end
-
-    def detect_revision(ci_environment, env)
-      if env['GITHUB_EVENT_NAME'] == 'pull_request'
-        raise StandardError('GITHUB_EVENT_PATH not set') unless env['GITHUB_EVENT_PATH']
-        event = JSON.parse(IO.read(env['GITHUB_EVENT_PATH']))
-        revision = event['pull_request']['head']['sha'] rescue nil
-        raise StandardError("Could not find .pull_request.head.sha in #{env['GITHUB_EVENT_PATH']}:\n#{JSON.pretty_generate(event)}") if revision.nil?
-        return revision
-      end
-
-      return evaluate(ci_environment['git']['revision'], env)
-    end
-
-    def remove_userinfo_from_url(value)
-      return nil if value.nil?
-
-      begin
-        uri = URI(value)
-        uri.userinfo = ''
-        uri.to_s
-      rescue StandardError
-        value
-      end
-    end
-
-    module_function :detect_ci_environment, :detect, :detect_git, :detect_revision, :remove_userinfo_from_url
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/spec/capture_warnings.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-# With thanks to @myronmarston
-# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
-
-module CaptureWarnings
-  def report_warnings(&block)
-    current_dir = Dir.pwd
-    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
-    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
-
-    if errors.any?
-      puts errors.join("\n")
-    end
-
-    if other_warnings.any?
-      puts "#{ other_warnings.count } warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
-      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
-    end
-
-    # Until they fix https://bugs.ruby-lang.org/issues/10661
-    if RUBY_VERSION == "2.2.0"
-      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
-    end
-
-    if project_warnings.any?
-      puts "#{ project_warnings.count } warnings detected"
-      print_warnings('cucumber-expressions', project_warnings)
-      fail "Please remove all cucumber-expressions warnings."
-    end
-
-    ensure_system_exit_if_required
-  end
-
-  def capture_error(&block)
-    old_stderr = STDERR.clone
-    pipe_r, pipe_w = IO.pipe
-    pipe_r.sync    = true
-    error          = String.new
-    reader = Thread.new do
-      begin
-        loop do
-          error << pipe_r.readpartial(1024)
-        end
-      rescue EOFError
-      end
-    end
-    STDERR.reopen(pipe_w)
-    block.call
-  ensure
-    capture_system_exit
-    STDERR.reopen(old_stderr)
-    pipe_w.close
-    reader.join
-    return error.split("\n")
-  end
-
-  def print_warnings(type, warnings)
-    puts
-    puts "-" * 30 + " #{type} warnings: " + "-" * 30
-    puts
-    puts warnings.join("\n")
-    puts
-    puts "-" * 75
-    puts
-  end
-
-  def ensure_system_exit_if_required
-    raise @system_exit if @system_exit
-  end
-
-  def capture_system_exit
-    @system_exit = $!
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/spec/cucumber/ci_environment/ci_environment_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/ci_environment'
-require 'json'
-
-describe 'detect_ci_environment' do
-  Dir.glob('../testdata/*.txt') do |test_data_file|
-    context "with #{File.basename(test_data_file, '.txt')}" do
-      subject { JSON.parse(ci_environment.to_json) }
-
-      let(:ci_environment) { Cucumber::CiEnvironment.detect_ci_environment(env) }
-      let(:env) { Hash[entries] }
-      let(:entries) { env_data.split(/\n/).map { |line| line.split(/=/) } }
-      let(:env_data) { IO.read(test_data_file) }
-
-      let(:expected_json) { File.read("#{test_data_file}.json") }
-
-      it { is_expected.to eq JSON.parse(expected_json) }
-    end
-  end
-
-  context 'with no CI environment' do
-    subject { JSON.parse(ci_environment.to_json) }
-    let(:ci_environment) { Cucumber::CiEnvironment.detect_ci_environment(env) }
-    let(:env) { {} }
-
-    it { is_expected.to be_nil }
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/spec/cucumber/ci_environment/evaluate_variable_expression_spec.rb

@@ -1,38 +0,0 @@
-require 'cucumber/ci_environment'
-
-describe 'Cucumber::CiEnvironment::VariableExpression.evaluate' do
-  include Cucumber::CiEnvironment::VariableExpression
-
-  it 'returns nil when a variable is undefined' do
-    expression = "hello-${SOME_VAR}"
-    result = evaluate(expression, {})
-    expect(result).to eq(nil)
-  end
-
-  it 'gets a value without replacement' do
-    expression = "${SOME_VAR}"
-    result = evaluate(expression, { 'SOME_VAR' => 'some_value' })
-    expect(result).to eq('some_value')
-  end
-
-  it 'captures a group' do
-    expression = "${SOME_REF/refs\/heads\/(.*)/\\1}"
-    result = evaluate(expression, { 'SOME_REF' => 'refs/heads/main' })
-    expect(result).to eq('main')
-  end
-
-  it 'works with star wildcard in var' do
-    expression = "${GO_SCM_*_PR_BRANCH/.*:(.*)/\\1}"
-    result = evaluate(expression, { 'GO_SCM_MY_MATERIAL_PR_BRANCH' => 'ashwankthkumar:feature-1' })
-    expect(result).to eq('feature-1')
-  end
-
-  it 'evaluates a complex expression' do
-    expression = "hello-${VAR1}-${VAR2/(.*) (.*)/\\2-\\1}-world"
-    result = evaluate(expression, {
-      'VAR1' => 'amazing',
-      'VAR2' => 'gorgeous beautiful'
-    })
-    expect(result).to eq('hello-amazing-beautiful-gorgeous-world')
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/spec/cucumber/ci_environment/github_pull_request_integration_spec.rb

@@ -1,10 +0,0 @@
-describe 'GitHub' do
-  if (ENV['GITHUB_EVENT_NAME'] == 'pull_request')
-    it 'detects the correct revision for pull requests' do
-      ci_environment = Cucumber::CiEnvironment.detect_ci_environment(ENV)
-      expect(ci_environment).to be_truthy
-      puts ("Manually verify that the revision is correct");
-      p ci_environment
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-ci-environment-9.2.0/spec/cucumber/ci_environment/remove_userinfo_from_url_spec.rb

@@ -1,29 +0,0 @@
-require 'cucumber/ci_environment'
-
-describe 'remove_user_info_from_url' do
-  it 'returns nil for nil' do
-    expect(Cucumber::CiEnvironment.remove_userinfo_from_url(nil)).to be_nil
-  end
-
-  it 'returns empty string for empty string' do
-    expect(Cucumber::CiEnvironment.remove_userinfo_from_url('')).to eq('')
-  end
-
-  it 'leaves the data intact when no sensitive information is detected' do
-    expect(Cucumber::CiEnvironment.remove_userinfo_from_url('pretty safe')).to eq('pretty safe')
-  end
-
-  context 'with URLs' do
-    it 'leaves intact when no password is found' do
-      expect(Cucumber::CiEnvironment.remove_userinfo_from_url('https://example.com/git/repo.git')).to eq('https://example.com/git/repo.git')
-    end
-
-    it 'removes credentials when found' do
-      expect(Cucumber::CiEnvironment.remove_userinfo_from_url('http://login@example.com/git/repo.git')).to eq('http://example.com/git/repo.git')
-    end
-
-    it 'removes credentials and passwords when found' do
-      expect(Cucumber::CiEnvironment.remove_userinfo_from_url('ssh://login:password@example.com/git/repo.git')).to eq('ssh://example.com/git/repo.git')
-    end
-  end
-end