honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/builder-3.2.4/test/test_namecollision.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-require 'helper'
-require 'builder/xchar'
-
-class TestNameCollisions < Builder::Test
-  module Collide
-    def xchr
-    end
-  end
-
-  def test_no_collision
-    assert_nothing_raised do
-      Builder.check_for_name_collision(Collide, :not_defined)
-    end
-  end
-
-  def test_collision
-    assert_raise RuntimeError do
-      Builder.check_for_name_collision(Collide, "xchr")
-    end
-  end
-
-  def test_collision_with_symbol
-    assert_raise RuntimeError do
-      Builder.check_for_name_collision(Collide, :xchr)
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/builder-3.2.4/test/test_xchar.rb

@@ -1,85 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-# encoding: us-ascii
-
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-#!/usr/bin/env ruby
-
-require 'helper'
-require 'builder/xchar'
-
-if String.method_defined?(:encode)
-  class String
-    ENCODING_BINARY = Encoding.find('BINARY')
-
-    # shim method for testing purposes
-    def to_xs(escape=true)
-      # raise NameError.new('to_xs') unless caller[0].index(__FILE__)
-
-      result = Builder::XChar.encode(self.dup)
-      if escape
-        result.gsub(/[^\u0000-\u007F]/) {|c| "&##{c.ord};"}
-      else
-        # really only useful for testing purposes
-        result.force_encoding(ENCODING_BINARY)
-      end
-    end
-  end
-end
-
-class TestXmlEscaping < Builder::Test
-  REPLACEMENT_CHAR = Builder::XChar::REPLACEMENT_CHAR.to_xs
-
-  def test_ascii
-    assert_equal 'abc', 'abc'.to_xs
-  end
-
-  def test_predefined
-    assert_equal '&amp;', '&'.to_xs              # ampersand
-    assert_equal '&lt;',  '<'.to_xs              # left angle bracket
-    assert_equal '&gt;',  '>'.to_xs              # right angle bracket
-  end
-
-  def test_invalid
-    assert_equal REPLACEMENT_CHAR, "\x00".to_xs               # null
-    assert_equal REPLACEMENT_CHAR, "\x0C".to_xs               # form feed
-    assert_equal REPLACEMENT_CHAR, "\xEF\xBF\xBF".to_xs       # U+FFFF
-  end
-
-  def test_iso_8859_1
-    assert_equal '&#231;', "\xE7".to_xs          # small c cedilla
-    assert_equal '&#169;', "\xA9".to_xs          # copyright symbol
-  end
-
-  def test_win_1252
-    assert_equal '&#8217;', "\x92".to_xs         # smart quote
-    assert_equal '&#8364;', "\x80".to_xs         # euro
-  end
-
-  def test_utf8
-    assert_equal '&#8217;', "\xE2\x80\x99".to_xs # right single quote
-    assert_equal '&#169;',  "\xC2\xA9".to_xs     # copy
-  end
-
-  def test_utf8_verbatim
-    assert_equal binary("\xE2\x80\x99"), "\xE2\x80\x99".to_xs(false)  # right single quote
-    assert_equal binary("\xC2\xA9"),  "\xC2\xA9".to_xs(false)         # copy
-    assert_equal binary("\xC2\xA9&amp;\xC2\xA9"),
-      "\xC2\xA9&\xC2\xA9".to_xs(false)                                # copy with ampersand
-  end
-
-  private
-
-  def binary(string)
-    string.dup.force_encoding(Encoding::BINARY)
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/bump-0.10.0/lib/bump/tasks.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "bump"
-
-namespace :bump do
-  run_bump = lambda do |bump, options|
-    output, status = Bump::Bump.run(bump, options)
-    puts output
-    abort unless status == 0
-  end
-
-  (Bump::Bump::BUMPS + ["current", "file", "show-next"]).each do |bump|
-    if bump == "current"
-      desc "Show current gem version"
-    elsif bump == "show-next"
-      desc "Show next #{Bump::Bump::BUMPS.join('|')} version."
-    elsif bump == "file"
-      desc "Show version file path"
-    else
-      desc "Bump #{bump} part of gem version"
-    end
-
-    task bump, :no_args do |_task, args|
-      if args.no_args
-        raise(
-          RakeArgumentsDeprecatedError,
-          "rake arguments are deprecated, use TAG=false to disable tagging"
-        )
-      end
-      options = {
-        tag: ENV['TAG'],
-        tag_prefix: ENV['TAG_PREFIX'],
-        commit: ENV['COMMIT'],
-        bundle: ENV['BUNDLE'],
-        increment: ENV['INCREMENT']
-      }
-      run_bump.call(bump, Bump::Bump.parse_cli_options!(options))
-    end
-  end
-
-  desc "Sets the version number using the VERSION environment variable"
-  task :set do
-    run_bump.call("set", version: ENV['VERSION'])
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/bump-0.10.0/lib/bump.rb

@@ -1,312 +0,0 @@
-# frozen_string_literal: true
-
-module Bump
-  class InvalidIncrementError < StandardError; end
-  class InvalidOptionError < StandardError; end
-  class InvalidVersionError < StandardError; end
-  class UnfoundVersionError < StandardError; end
-  class TooManyVersionFilesError < StandardError; end
-  class UnfoundVersionFileError < StandardError; end
-  class RakeArgumentsDeprecatedError < StandardError; end
-
-  class <<self
-    attr_accessor :tag_by_default, :replace_in_default, :changelog
-  end
-
-  class Bump
-    BUMPS         = ["major", "minor", "patch", "pre"].freeze
-    PRERELEASE    = ["alpha", "beta", "rc", nil].freeze
-    OPTIONS       = BUMPS | ["set", "current", "file"]
-    VERSION_REGEX = /(\d+\.\d+\.\d+(?:-(?:#{PRERELEASE.compact.join('|')}))?)/.freeze
-
-    class << self
-      def defaults
-        {
-          tag: ::Bump.tag_by_default,
-          tag_prefix: 'v',
-          commit: true,
-          changelog: ::Bump.changelog || false, # TODO: default to true with opt-out once it gets more stable
-          bundle: File.exist?("Gemfile"),
-          replace_in: ::Bump.replace_in_default || []
-        }
-      end
-
-      def run(bump, options = {})
-        options = defaults.merge(options)
-        options[:commit] = false unless File.directory?(".git")
-
-        case bump
-        when *BUMPS
-          bump_part(bump, options)
-        when "set"
-          raise InvalidVersionError unless options[:version]
-
-          bump_set(options[:version], options)
-        when "current"
-          [current, 0]
-        when "show-next"
-          increment = options[:increment]
-          raise InvalidIncrementError unless BUMPS.include?(increment)
-
-          [next_version(increment), 0]
-        when "file"
-          [file, 0]
-        else
-          raise InvalidOptionError
-        end
-      rescue InvalidIncrementError
-        ["Invalid increment. Choose between #{BUMPS.join(',')}.", 1]
-      rescue InvalidOptionError
-        ["Invalid option. Choose between #{OPTIONS.join(',')}.", 1]
-      rescue InvalidVersionError
-        ["Invalid version number given.", 1]
-      rescue UnfoundVersionError
-        ["Unable to find your gem version", 1]
-      rescue UnfoundVersionFileError
-        ["Unable to find a file with the gem version", 1]
-      rescue TooManyVersionFilesError
-        ["More than one version file found (#{$!.message})", 1]
-      end
-
-      def current
-        current_info.first
-      end
-
-      def next_version(increment, current = Bump.current)
-        current, prerelease = current.split('-')
-        major, minor, patch, *other = current.split('.')
-        case increment
-        when "major"
-          major = major.succ
-          minor = 0
-          patch = 0
-          prerelease = nil
-        when "minor"
-          minor = minor.succ
-          patch = 0
-          prerelease = nil
-        when "patch"
-          patch = patch.succ
-        when "pre"
-          prerelease.strip! if prerelease.respond_to? :strip
-          prerelease = PRERELEASE[PRERELEASE.index(prerelease).succ % PRERELEASE.length]
-        else
-          raise InvalidIncrementError
-        end
-        version = [major, minor, patch, *other].compact.join('.')
-        [version, prerelease].compact.join('-')
-      end
-
-      def file
-        current_info.last
-      end
-
-      def parse_cli_options!(options)
-        options.each do |key, value|
-          options[key] = parse_cli_options_value(value)
-        end
-        options.delete_if { |_key, value| value.nil? }
-      end
-
-      private
-
-      def parse_cli_options_value(value)
-        case value
-        when "true" then true
-        when "false" then false
-        when "nil" then nil
-        else
-          value
-        end
-      end
-
-      def bump(file, current, next_version, options)
-        # bump in files that need to change
-        [file, *options[:replace_in]].each do |f|
-          return ["Unable to find version #{current} in #{f}", 1] unless replace f, current, next_version
-
-          git_add f if options[:commit]
-        end
-
-        # bundle if needed
-        if options[:bundle] && Dir.glob('*.gemspec').any? && under_version_control?("Gemfile.lock")
-          bundler_with_clean_env do
-            return ["Bundle error", 1] unless system("bundle")
-
-            git_add "Gemfile.lock" if options[:commit]
-          end
-        end
-
-        # changelog if needed
-        if options[:changelog]
-          log = Dir["CHANGELOG.md"].first
-          return ["Did not find CHANGELOG.md", 1] unless log
-
-          error = bump_changelog(log, next_version)
-          return [error, 1] if error
-
-          open_changelog(log) if options[:changelog] == :editor
-
-          git_add log if options[:commit]
-        end
-
-        # commit staged changes
-        commit next_version, options if options[:commit]
-
-        # tell user the result
-        [next_version, 0]
-      end
-
-      def open_changelog(log)
-        editor = ENV['EDITOR'] || "vi"
-        system "#{editor} #{log}"
-      end
-
-      def bundler_with_clean_env(&block)
-        if defined?(Bundler)
-          if Bundler.respond_to?(:with_unbundled_env)
-            Bundler.with_unbundled_env(&block)
-          else
-            Bundler.with_clean_env(&block)
-          end
-        else
-          yield
-        end
-      end
-
-      def bump_part(increment, options)
-        current, file = current_info
-        next_version = next_version(increment, current)
-        bump(file, current, next_version, options)
-      end
-
-      def bump_set(next_version, options)
-        current, file = current_info
-        bump(file, current, next_version, options)
-      end
-
-      def bump_changelog(file, current)
-        parts = File.read(file).split(/(^##+.*)/) # headlines and their content
-        prev_index = parts.index { |p| p =~ /(^##+.*(\d+\.\d+\.\d+(\.[a-z]+)?).*)/ } # position of previous version
-        return "Unable to find previous version in CHANGELOG.md" unless prev_index
-
-        # reuse the same style by just swapping the numbers
-        new_heading = parts[prev_index].sub($2, current)
-        # add current date if previous heading used that
-        new_heading.sub!(/\d\d\d\d-\d\d-\d\d/, Time.now.strftime('%Y-%m-%d'))
-
-        if prev_index < 2
-          # previous version is first '##' element (no '## Next' present), add line feed after version to avoid
-          # '## v1.0.1## v1.0.0'
-          parts.insert prev_index - 1, new_heading + "\n"
-        else
-          # put our new heading underneath the "Next" heading, which should be above the last version
-          parts.insert prev_index - 1, "\n" + new_heading
-        end
-
-        File.write file, parts.join("")
-        nil
-      end
-
-      def commit_message(version, options)
-        tag = "#{options[:tag_prefix]}#{version}"
-        options[:commit_message] ? "#{tag} #{options[:commit_message]}" : tag
-      end
-
-      def commit(version, options)
-        tag = "#{options[:tag_prefix]}#{version}"
-        system("git", "commit", "-m", commit_message(version, options))
-        system("git", "tag", "-a", "-m", "Bump to #{tag}", tag) if options[:tag]
-      end
-
-      def git_add(file)
-        system("git", "add", "--update", file)
-      end
-
-      def replace(file, old, new)
-        content = File.read(file)
-        return unless content.sub!(old, new)
-
-        File.write(file, content)
-      end
-
-      def current_info
-        version, file = (
-          version_from_version ||
-          version_from_version_rb ||
-          version_from_gemspec ||
-          version_from_lib_rb ||
-          version_from_chef ||
-          raise(UnfoundVersionFileError)
-        )
-        raise UnfoundVersionError unless version
-
-        [version, file]
-      end
-
-      def version_from_gemspec
-        return unless file = find_version_file("*.gemspec")
-
-        content = File.read(file)
-        version = (
-          content[/\.version\s*=\s*["']#{VERSION_REGEX}["']/, 1] ||
-          File.read(file)[/Gem::Specification.new.+ ["']#{VERSION_REGEX}["']/, 1]
-        )
-        return unless version
-
-        [version, file]
-      end
-
-      def version_from_version_rb
-        files = Dir.glob("lib/**/version.rb")
-        files.detect do |file|
-          if version_and_file = extract_version_from_file(file)
-            return version_and_file
-          end
-        end
-      end
-
-      def version_from_version
-        return unless file = find_version_file("VERSION")
-
-        extract_version_from_file(file)
-      end
-
-      def version_from_lib_rb
-        files = Dir.glob("lib/**/*.rb")
-        file = files.detect do |f|
-          File.read(f) =~ /^\s+VERSION = ['"](#{VERSION_REGEX})['"]/i
-        end
-        [Regexp.last_match(1), file] if file
-      end
-
-      def version_from_chef
-        file = find_version_file("metadata.rb")
-        return unless file && File.read(file) =~ /^version\s+(['"])(#{VERSION_REGEX})['"]/
-
-        [Regexp.last_match(2), file]
-      end
-
-      def extract_version_from_file(file)
-        return unless version = File.read(file)[VERSION_REGEX]
-
-        [version, file]
-      end
-
-      def find_version_file(pattern)
-        files = Dir.glob(pattern)
-        case files.size
-        when 0 then nil
-        when 1 then files.first
-        else
-          raise TooManyVersionFilesError, files.join(", ")
-        end
-      end
-
-      def under_version_control?(file)
-        @all_files ||= `git ls-files`.split(/\r?\n/)
-        @all_files.include?(file)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/ext/byebug/extconf.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "mkmf"
-
-makefile_config = RbConfig::MAKEFILE_CONFIG
-
-makefile_config["CC"] = ENV["CC"] if ENV["CC"]
-
-makefile_config["CFLAGS"] << " -gdwarf-2 -g3 -O0" if ENV["debug"]
-
-dir_config("ruby")
-with_cflags(makefile_config["CFLAGS"]) { create_makefile("byebug/byebug") }

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/attacher.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Main Container for all of Byebug's code
-#
-module Byebug
-  #
-  # Starts byebug, and stops at the first line of user's code.
-  #
-  def self.attach
-    unless started?
-      self.mode = :attached
-
-      start
-      run_init_script
-    end
-
-    current_context.step_out(3, true)
-  end
-
-  def self.spawn(host = "localhost", port = nil)
-    require_relative "core"
-
-    self.wait_connection = true
-    start_server(host, port || PORT)
-  end
-end
-
-#
-# Adds a `byebug` method to the Kernel module.
-#
-# Dropping a `byebug` call anywhere in your code, you get a debug prompt.
-#
-module Kernel
-  def byebug
-    require_relative "core"
-
-    Byebug.attach unless Byebug.mode == :off
-  end
-
-  def remote_byebug(host = "localhost", port = nil)
-    Byebug.spawn(host, port)
-
-    Byebug.attach
-  end
-
-  alias debugger byebug
-end

data/vendor/bundle/ruby/3.2.0/gems/byebug-11.1.3/lib/byebug/breakpoint.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Byebug
-  #
-  # Implements breakpoints
-  #
-  class Breakpoint
-    #
-    # First breakpoint, in order of creation
-    #
-    def self.first
-      Byebug.breakpoints.first
-    end
-
-    #
-    # Last breakpoint, in order of creation
-    #
-    def self.last
-      Byebug.breakpoints.last
-    end
-
-    #
-    # Adds a new breakpoint
-    #
-    # @param [String] file
-    # @param [Fixnum] line
-    # @param [String] expr
-    #
-    def self.add(file, line, expr = nil)
-      breakpoint = Breakpoint.new(file, line, expr)
-      Byebug.breakpoints << breakpoint
-      breakpoint
-    end
-
-    #
-    # Removes a breakpoint
-    #
-    # @param id [integer] breakpoint number
-    #
-    def self.remove(id)
-      Byebug.breakpoints.reject! { |b| b.id == id }
-    end
-
-    #
-    # Returns an array of line numbers in file named +filename+ where
-    # breakpoints could be set. The list will contain an entry for each
-    # distinct line event call so it is possible (and possibly useful) for a
-    # line number appear more than once.
-    #
-    # @param filename [String] File name to inspect for possible breakpoints
-    #
-    def self.potential_lines(filename)
-      name = "#{Time.new.to_i}_#{rand(2**31)}"
-      iseq = RubyVM::InstructionSequence.compile(File.read(filename), name)
-
-      if iseq.respond_to?(:each_child)
-        potential_lines_with_trace_points(iseq, {})
-      else
-        potential_lines_without_trace_points(iseq, {})
-      end
-    end
-
-    def self.potential_lines_with_trace_points(iseq, lines)
-      iseq.trace_points.each { |(line, _)| lines[line] = true }
-      iseq.each_child do |child|
-        potential_lines_with_trace_points(child, lines)
-      end
-
-      lines.keys.sort
-    end
-
-    private_class_method :potential_lines_with_trace_points
-
-    def self.potential_lines_without_trace_points(iseq, lines)
-      iseq.disasm.each_line do |line|
-        res = /^\d+ (?<insn>\w+)\s+.+\(\s*(?<lineno>\d+)\)$/.match(line)
-        next unless res && res[:insn] == "trace"
-
-        lines[res[:lineno].to_i] = true
-      end
-
-      lines.keys
-    end
-
-    private_class_method :potential_lines_without_trace_points
-
-    #
-    # Returns true if a breakpoint could be set in line number +lineno+ in file
-    # name +filename.
-    #
-    def self.potential_line?(filename, lineno)
-      potential_lines(filename).member?(lineno)
-    end
-
-    #
-    # True if there's no breakpoints
-    #
-    def self.none?
-      Byebug.breakpoints.empty?
-    end
-
-    #
-    # Prints all information associated to the breakpoint
-    #
-    def inspect
-      meths = %w[id pos source expr hit_condition hit_count hit_value enabled?]
-      values = meths.map { |field| "#{field}: #{send(field)}" }.join(", ")
-      "#<Byebug::Breakpoint #{values}>"
-    end
-  end
-end