"source_code_uri" => "https://.com/rubygems/rubygems/tree/master/bundler",

}

s.files = Dir.glob("lib/bundler{.rb,/**/*}", File::FNM_DOTMATCH).reject {|f| File.directory?(f) }

raise InvalidOption, "Please specify gems to add." if gems.empty?

version.to_a.each do |v|

end

end

end

definition.specs.each do |spec|

bundles_for_gem(spec).each do |bundle|

bad_paths = dylibs(bundle).select do |f|

end

if bad_paths.any?

broken_links[spec] ||= []

Bundler.ui.info hint_text("test")

result = Bundler.ui.ask "Enter a test framework. rspec/minitest/test-unit/(none):"

test_framework = result

else

test_framework = false

Bundler.ui.info hint_text("ci")

result = Bundler.ui.ask "Enter a CI service. /travis/gitlab/circle/(none):"

ci_template = result

else

ci_template = false

Bundler.ui.info hint_text("linter")

result = Bundler.ui.ask "Enter a linter. rubocop/standard/(none):"

linter_template = result

else

linter_template = false

end

def ensure_safe_gem_name(name, constant_array)

Bundler.ui.error "Invalid gem name #{name} Please give a name which does not start with numbers."

exit 1

end

end

def required_ruby_version

end

def rubocop_version

end

def standard_version

end

end

end

def info_path(name)

name = name.to_s

name += "-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}"

info_roots.last.join(name)

else

def initialize(fetcher)

@fetcher = fetcher

end

def update(local_path, remote_path, retrying = nil)

headers = {}

end

end

end

rescue Zlib::GzipFile::Error

raise Bundler::HTTPError

end

def etag_for(path)

# Convert to \r\n if the existing lock has them

# i.e., Windows with `git config core.autocrlf=true`

if @locked_bundler_version

locked_major = @locked_bundler_version.segments.first

if name.is_a?(Symbol)

raise GemfileError, %(You need to specify gem names as Strings. Use 'gem "#{name}"' instead)

end

raise GemfileError, %('#{name}' is not a valid gem name because it contains whitespace)

end

raise GemfileError, %(an empty gem name is not valid) if name.empty?

method = instance_method(method_name)

undef_method(method_name)

define_method(method_name) do |*args, &blk|

end

end

private

def validate_uri_scheme!(uri)

raise InvalidOption,

"The request uri `#{uri}` has an invalid scheme (`#{uri.scheme}`). " \

"Did you mean `http` or `https`?"

when Thor::Error

Bundler.ui.error error.message

when LoadError

Bundler.ui.error "\nCould not load OpenSSL. #{error.class}: #{error}\n#{error.backtrace.join("\n ")}"

when Interrupt

Bundler.ui.error "\nQuitting..."

gemfile.each_with_index do |line, index|

next unless !line.nil? && line.strip.start_with?(block_name)

gemfile[index] = nil

gemfile[index + 1] = nil

end

mode = Gem.win_platform? ? "wb:UTF-8" : "w"

require "erb"

File.write(binstub_path, content, :mode => mode, :perm => 0o777 & ~File.umask)

if Gem.win_platform? || options[:all_platforms]

mode = Gem.win_platform? ? "wb:UTF-8" : "w"

require "erb"

File.write("#{bin_path}/#{executable}", content, :mode => mode, :perm => 0o755)

if Gem.win_platform? || options[:all_platforms]

requested_path_gems = @definition.requested_specs.select {|s| s.source.is_a?(Source::Path) }

path_plugin_files = requested_path_gems.map do |spec|

end.flatten

Bundler.rubygems.load_plugin_files(path_plugin_files)

Bundler.rubygems.load_env_plugins

@state = nil

@specs = {}

raise LockfileError, "Your #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} contains merge conflicts.\n" \

"Run `git checkout HEAD -- #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}` first to get a clean lock."

end

@state = :ruby

elsif line == BUNDLED

@state = :bundled_with

@state = nil

elsif @state

send("parse_#{@state}", line)

class TCPSocketProbe

def replies?(mirror)

MirrorSockets.new(mirror).any? do |socket, address, timeout|

end

end

end

def glob_files_in_dir(glob, base_path)

end

end

end

at = if local?

path

elsif user_ref = options["ref"]

shortref_for_display(user_ref)

else

user_ref

end

def uri_hash

# Downcase the domain component of the URI

# and strip off a trailing slash, if one is present

input = Bundler::URI.parse(uri).normalize.to_s.sub(%r{/$}, "")

# Adds credentials to the URI

def configured_uri

remote = Bundler::URI(uri)

config_auth = Bundler.settings[remote.to_s] || Bundler.settings[remote.host]

remote.userinfo ||= config_auth

# Some gem authors put absolute paths in their gemspec

# and we have to save them from themselves

begin

rescue ArgumentError

end

end.compact

end

if installed?(spec) && !force

return nil # no post-install message

end

install_path = rubygems_dir

bin_path = Bundler.system_bindir

require_relative "../rubygems_gem_installer"

installer = Bundler::RubyGemsGemInstaller.at(

def normalize_uri(uri)

uri = uri.to_s

require_relative "../vendored_uri"

uri = Bundler::URI(uri)

raise ArgumentError, "The source must be an absolute URI. For example:\n" \

idx = @allow_local ? installed_specs.dup : Index.new

Dir["#{cache_path}/*.gem"].each do |gemfile|

s ||= Bundler.rubygems.spec_from_gem(gemfile)

s.source = self

idx << s

def warn_on_git_protocol(source)

return if Bundler.settings["git.allow_insecure"]

Bundler.ui.warn "The git source `#{source.uri}` uses the `git` protocol, " \

"which transmits data without encryption. Disable this warning with " \

"`bundle config set --local git.allow_insecure true`, or switch to the `https` " \

bundler_gem_version = Gem::Version.new(version)

end

def load_bundler!

creation_errors = []

@threads = Array.new(@size) do |i|

end

end.compact

add_interrupt_handler unless @threads.empty?

end

def check_ruby_version

unless required_version.satisfied_by? Gem.ruby_version

alert_error "Expected Ruby version #{required_version}, is #{Gem.ruby_version}"

Gem::Version.new("3.2.3")

elsif Gem.ruby_version > Gem::Version.new("2.7.a")

Gem::Version.new("3.1.2")

else

end

end

end

# frozen_string_literal: true

module Kernel

rubygems_path = "#{__dir__}/" # Frames to be skipped start with this path.

end

##

# Creates a self-signed certificate with an issuer and subject from +email+,

# a subject alternative name of +email+ and the given +extensions+ for the

# +key+.

when "rsa"

OpenSSL::PKey::RSA.new(RSA_DSA_KEY_LENGTH)

when "ec"

else

raise Gem::Security::Exception,

"#{algorithm} algorithm not found. RSA, DSA, and EC algorithms are supported."

# returning absolute paths to the matching files.

def self.glob_files_in_dir(glob, base_path)

end

##