autoload :Checksum, File.expand_path("bundler/checksum", __dir__)

autoload :CLI, File.expand_path("bundler/cli", __dir__)

autoload :CIDetector, File.expand_path("bundler/ci_detector", __dir__)

autoload :Definition, File.expand_path("bundler/definition", __dir__)

autoload :Dependency, File.expand_path("bundler/dependency", __dir__)

autoload :Deprecate, File.expand_path("bundler/deprecate", __dir__)

end

end

# Automatically install dependencies if Bundler.settings[:auto_install] exists.

# This is set through config cmd `bundle config set --global auto_install 1`.

#

def settings

@settings ||= Settings.new(app_config_path)

rescue GemfileNotFound

end

# @return [Hash] Environment present before Bundler was activated

Bundler.reset_settings_and_root!

end

Bundler.settings.set_command_option_if_given :retry, options[:retry]

method_option :rubocop, type: :boolean, desc: "Add rubocop to the generated Rakefile and gemspec. Set a default with `bundle config set --global gem.rubocop true`."

method_option :changelog, type: :boolean, desc: "Generate changelog file. Set a default with `bundle config set --global gem.changelog true`."

method_option :test, type: :string, lazy_default: Bundler.settings["gem.test"] || "", aliases: "-t", banner: "Use the specified test framework for your library",

desc: "Generate a test directory for your library, either rspec, minitest or test-unit. Set a default with `bundle config set --global gem.test (rspec|minitest|test-unit)`."

method_option :ci, type: :string, lazy_default: Bundler.settings["gem.ci"] || "",

desc: "Generate CI configuration, either GitHub Actions, GitLab CI or CircleCI. Set a default with `bundle config set --global gem.ci (github|gitlab|circle)`"

method_option :linter, type: :string, lazy_default: Bundler.settings["gem.linter"] || "",

desc: "Add a linter and code formatter, either RuboCop or Standard. Set a default with `bundle config set --global gem.linter (rubocop|standard)`"

method_option :github_username, type: :string, default: Bundler.settings["gem.github_username"], banner: "Set your username on GitHub", desc: "Fill in GitHub username on README so that you don't have to do it manually. Set a default with `bundle config set --global gem.github_username <your_username>`."

return unless SharedHelpers.md5_available?

return unless latest

current = Gem::Version.new(VERSION)

deps = if groups.any?

Bundler.definition.dependencies_for(groups)

else

end

fund_info = deps.each_with_object([]) do |dep, arr|

validate_ext_name if @extension

validate_rust_builder_rubygems_version if @extension == "rust"

end

def run

end

def ask_and_set_test_framework

test_framework = options[:test] || Bundler.settings["gem.test"]

if test_framework.to_s.empty?

test_framework

end

def hint_text(setting)

if Bundler.settings["gem.#{setting}"] == false

"Your choice will only be applied to this gem."

end

def ask_and_set_ci

ci_template = options[:ci] || Bundler.settings["gem.ci"]

if ci_template.to_s.empty?

end

def ask_and_set_linter

linter_template = options[:linter] || Bundler.settings["gem.linter"]

linter_template = deprecated_rubocop_option if linter_template.nil?

"1.3"

end

def validate_rust_builder_rubygems_version

if Gem::Version.new(rust_builder_required_rubygems_version) > Gem.rubygems_version

Bundler.ui.error "Your RubyGems version (#{Gem.rubygems_version}) is too old to build Rust extension. Please update your RubyGems using `gem update --system` or any other way and try again."

require "set"

module Bundler

class CompactIndexClient

# NOTE: MD5 is here not because we expect a server to respond with it, but

# because we use it to generate the etag on first request during the upgrade

SUPPORTED_DIGESTS = { "sha-256" => :SHA256, "md5" => :MD5 }.freeze

DEBUG_MUTEX = Thread::Mutex.new

def self.debug

return unless ENV["DEBUG_COMPACT_INDEX"]

DEBUG_MUTEX.synchronize { warn("[#{self}] #{yield}") }

require_relative "compact_index_client/cache"

require_relative "compact_index_client/cache_file"

require_relative "compact_index_client/updater"

end

def names

end

def versions

end

def dependencies(names)

Bundler::CompactIndexClient.debug { "dependencies(#{names})" }

end

end

end

end

end

end

end

class Cache

attr_reader :directory

@directory = Pathname.new(directory).expand_path

end

def names

end

end

end

end

end

def info_path(name)

name = name.to_s

if /[^a-z0-9_-]/.match?(name)

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

else

end

end

def info_etag_path(name)

name = name.to_s

end

end

end

end

end

end

end

end

@resolved_bundler_version = nil

@locked_ruby_version = nil

@removed_platform = nil

if lockfile_exists?

end

def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false)

added = []

deleted = []

changed = []

changed << "* #{name} from `#{lockfile_source_name}` to `#{gemfile_source_name}`"

end

msg = String.new

msg << "#{reason.capitalize.strip}, but the lockfile can't be updated because frozen mode is set"

msg << "\n\nYou have added to the Gemfile:\n" << added.join("\n") if added.any?

end

def add_platform(platform)

end

def remove_platform(platform)

!@source_changes &&

!@dependency_changes &&

!@path_changes &&

!@local_changes &&

!@missing_lockfile_dep &&

def resolution_packages

@resolution_packages ||= begin

last_resolve = converge_locked_specs

packages = Resolver::Base.new(source_requirements, expanded_dependencies, last_resolve, @platforms, locked_specs: @originally_locked_specs, unlock: @gems_to_unlock, prerelease: gem_version_promoter.pre?)

packages = additional_base_requirements_to_prevent_downgrades(packages, last_resolve)

packages = additional_base_requirements_to_force_updates(packages)

end

def start_resolution

result = SpecSet.new(resolver.start)

@resolved_bundler_version = result.find {|spec| spec.name == "bundler" }&.version

SpecSet.new(result.for(dependencies, false, @platforms))

end

end

end

def current_platform_locked?

@platforms.any? do |bundle_platform|

MatchPlatform.platforms_match?(bundle_platform, local_platform)

end

def add_current_platform

add_platform(local_platform)

end

def change_reason

if unlocking?

unlock_targets = if @gems_to_unlock.any?

[

[@source_changes, "the list of sources changed"],

[@dependency_changes, "the dependencies in your gemfile changed"],

[@path_changes, "the gemspecs for path gems changed"],

[@local_changes, "the gemspecs for git local gems changed"],

[@missing_lockfile_dep, "your lock file is missing \"#{@missing_lockfile_dep}\""],

unlocked_definition

end

return if Bundler.frozen_bundle?

platforms.reverse_each do |platform|

next if local_platform == platform ||

@path_changes ||

@dependency_changes ||

remove_platform(platform)

end

end

def source_map

@source_map ||= SourceMap.new(sources, dependencies, @locked_specs)

end

end

end

def _local_specification

return unless @loaded_from && File.exist?(local_specification_path)

eval(File.read(local_specification_path), nil, local_specification_path).tap do |spec|

specs = Bundler.rubygems.find_name(name)

out << [" #{name}", "(#{specs.map(&:version).join(",")})"] unless specs.empty?

end

shebang = File.read(exe).lines.first

shebang.sub!(/^#!\s*/, "")

unless shebang.start_with?(Gem.ruby, "/usr/bin/env ruby")

require_relative "../worker"

module Bundler

class Fetcher

class CompactIndex < Base

def self.compact_index_request(method_name)

until remaining_gems.empty?

log_specs { "Looking up gems #{remaining_gems.inspect}" }

deps.each {|dep| gem_info << dep }

complete_gems.concat(deps.map(&:first)).uniq!

remaining_gems = next_gems - complete_gems

return nil

end

# Read info file checksums out of /versions, so we can know if gems are up to date

rescue CompactIndexClient::Updater::MismatchedChecksumError => e

Bundler.ui.debug(e.message)

nil

end

end

end

end

def bundle_worker(func = nil)

end

module_function :platform_specificity_match

sort_best_platform_match(matching, platform)

end

module_function :select_best_platform_match

end

def sort_best_platform_match(matching, platform)

exact = matching.select {|spec| spec.platform == platform }

# @param [Pathname] lockfile_path The lockfile in which to inject the new dependency.

# @return [Array]

def inject(gemfile_path, lockfile_path)

# temporarily unfreeze

Bundler.settings.temporary(deployment: false, frozen: false) do

Bundler.create_bundle_path

ProcessLock.lock do

if @definition.dependencies.empty?

Bundler.ui.warn "The Gemfile specifies no dependencies"

spec.source.install(

spec,

force: force,

build_args: Array(spec_settings),

previous_spec: previous_spec,

)

else

SharedHelpers.relative_path_to(full_path, from: Bundler.root.join(bundler_path))

end

end

def prevent_gem_activation

module Bundler

class LazySpecification

include MatchPlatform

include ForcePlatform

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-add\fR \- Add gem to the Gemfile and run bundle install

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-binstubs\fR \- Install the binstubs of the listed gems

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-cache\fR \- Package your needed \fB\.gem\fR files into your application

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-check\fR \- Verifies if dependencies are satisfied by installed gems

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-clean\fR \- Cleans up unused gems in your bundler directory

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-config\fR \- Set bundler configuration options

.SH "SYNOPSIS"

.P

This means that if you have a gem server named \fBmy\.gem\-host\.com\fR, you'll need to use the \fBBUNDLE_MY__GEM___HOST__COM\fR variable to configure credentials for it through ENV\.

.SH "CONFIGURE BUNDLER DIRECTORIES"

.IP "" 4

.nf

BUNDLE_USER_HOME : $HOME/\.bundle

## CONFIGURE BUNDLER DIRECTORIES

through environment variables. The default location for Bundler's home directory is

`~/.bundle`, which all directories inherit from by default. The following

outlines the available environment variables and their default values

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-console\fR \- Deprecated way to open an IRB session with the bundle pre\-loaded

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-doctor\fR \- Checks the bundle for common problems

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-exec\fR \- Execute a command in the context of the bundle

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-gem\fR \- Generate a project skeleton for creating a rubygem

.SH "SYNOPSIS"

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.IP "\(bu" 4

\fB\-\-ci\fR, \fB\-\-ci=github\fR, \fB\-\-ci=gitlab\fR, \fB\-\-ci=circle\fR: Specify the continuous integration service that Bundler should use when generating the project\. Acceptable values are \fBgithub\fR, \fBgitlab\fR and \fBcircle\fR\. A configuration file will be generated in the project directory\. Given no option is specified:

.IP

When Bundler is configured to generate CI files, this defaults to Bundler's global config setting \fBgem\.ci\fR\.

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.IP "\(bu" 4

\fB\-\-linter\fR, \fB\-\-linter=rubocop\fR, \fB\-\-linter=standard\fR: Specify the linter and code formatter that Bundler should add to the project's development dependencies\. Acceptable values are \fBrubocop\fR and \fBstandard\fR\. A configuration file will be generated in the project directory\. Given no option is specified:

.IP

When Bundler is configured to add a linter, this defaults to Bundler's global config setting \fBgem\.linter\fR\.

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.IP "\(bu" 4

\fB\-e\fR, \fB\-\-edit[=EDITOR]\fR: Open the resulting GEM_NAME\.gemspec in EDITOR, or the default editor if not specified\. The default is \fB$BUNDLER_EDITOR\fR, \fB$VISUAL\fR, or \fB$EDITOR\fR\.

.IP "" 0

.SH "SEE ALSO"

the answer will be saved in Bundler's global config for future `bundle gem`

use.

* `--ci`, `--ci=github`, `--ci=gitlab`, `--ci=circle`:

Specify the continuous integration service that Bundler should use when

generating the project. Acceptable values are `github`, `gitlab`

the answer will be saved in Bundler's global config for future `bundle gem`

use.

* `--linter`, `--linter=rubocop`, `--linter=standard`:

Specify the linter and code formatter that Bundler should add to the

project's development dependencies. Acceptable values are `rubocop` and

the answer will be saved in Bundler's global config for future `bundle gem`

use.

* `-e`, `--edit[=EDITOR]`:

Open the resulting GEM_NAME.gemspec in EDITOR, or the default editor if not

specified. The default is `$BUNDLER_EDITOR`, `$VISUAL`, or `$EDITOR`.

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-help\fR \- Displays detailed help for each subcommand

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-info\fR \- Show information for the given gem in your bundle

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-init\fR \- Generates a Gemfile into the current working directory

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-inject\fR \- Add named gem(s) with version requirements to Gemfile

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-install\fR \- Install the dependencies specified in your Gemfile

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-list\fR \- List all the gems in the bundle

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-lock\fR \- Creates / Updates a lockfile without installing

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-open\fR \- Opens the source directory for a gem in your bundle

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-outdated\fR \- List installed gems with newer versions available

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-platform\fR \- Displays platform compatibility information

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-plugin\fR \- Manage Bundler plugins

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-pristine\fR \- Restores installed gems to their pristine condition

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-remove\fR \- Removes gems from the Gemfile

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-show\fR \- Shows all the gems in your bundle, or the path to a gem

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-update\fR \- Update your gems to the latest available versions

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-version\fR \- Prints Bundler version information

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\-viz\fR \- Generates a visual dependency graph for your Gemfile

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBbundle\fR \- Ruby Dependency Management

.SH "SYNOPSIS"

.\" generated with nRonn/v0.11.1

.\" https://github.com/n-ronn/nronn/tree/0.11.1

.SH "NAME"

\fBGemfile\fR \- A format for describing gem dependencies for Ruby programs

.SH "SYNOPSIS"

def solve_versions(root:, logger:)

solver = PubGrub::VersionSolver.new(source: self, root: root, logger: logger)

result = solver.solve

rescue PubGrub::SolveFailure => e

incompatibility = e.incompatibility

results = filter_matching_specs(results, locked_requirement) if locked_requirement

results.group_by(&:version).reduce([]) do |groups, (version, specs)|

# If package is a top-level dependency,

# candidate is only valid if there are matching versions for all resolution platforms.

next groups if platform_specs.all?(&:empty?)

end

ruby_specs = select_best_platform_match(specs, Gem::Platform::RUBY)

groups

end

def requirement_to_range(requirement)

ranges = requirement.requirements.map do |(op, version)|

case op

when "~>"

end.compact

end

def [](name)

@base[name]

end

attr_reader :version

@version = Gem::Version.new(version)

end

def dependencies

@spec_group.to_specs(package.force_ruby_platform?)

end

def prerelease?

@version.prerelease?

end

end

def sort_obj

end

def <=>(other)

@prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore

end

def to_s

@name.delete("\0")

end

module Bundler

class Resolver

class SpecGroup

def initialize(specs)

@specs = specs

end

def dependencies

@dependencies ||= @specs.map do |spec|

__dependencies(spec) + metadata_dependencies(spec)

end

protected

def sorted_spec_names

end

private

def exemplary_spec

@specs.first

end

end

end

require "rubygems/specification"

class Specification

require_relative "match_metadata"

require_relative "match_platform"

!default_gem? && !File.directory?(full_gem_path)

end

private

def dependencies_to_gemfile(dependencies, group = nil)

end

end

module BetterPermissionError

def data

super

# cpu

([nil,"universal"].include?(@cpu) || [nil, "universal"].include?(other.cpu) || @cpu == other.cpu ||

# os

@os == other.os &&

write_build_info_file

run_post_build_hooks

generate_plugins

write_spec

spec

end

super

rescue Gem::FilePermissionError

# Ignore permission checks in RubyGems. Instead, go on, and try to write

end

end

def build_extensions

extension_cache_path = options[:bundler_extension_cache_path]

extension_dir = spec.extension_dir

end

def validate(spec)

rescue Gem::InvalidSpecificationException => e

error_message = "The gemspec at #{spec.loaded_from} is not valid. Please fix this gemspec.\n" \

"The validation error was '#{e.message}'\n"

[::Kernel.singleton_class, ::Kernel].each do |kernel_class|

redefine_method(kernel_class, :gem) do |dep, *reqs|

break

end

end

def all_specs

Gem::Specification.stubs.map do |stub|

StubSpecification.from_stub(stub)

end

end

def find_bundler(version)

find_name("bundler").find {|s| s.version.to_s == version }

end

end

def setup(*groups)

# Has to happen first

clean_load_path

configured_gem_home = ENV["GEM_HOME"]

configured_gem_path = ENV["GEM_PATH"]

Bundler.with_original_env do

Kernel.exec(

def autoswitching_applies?

ENV["BUNDLER_VERSION"].nil? &&

Bundler.rubygems.supports_bundler_trampolining? &&

SharedHelpers.in_bundle? &&

lockfile_version

end

!version.to_s.end_with?(".dev")

end

def updating?

"update".start_with?(ARGV.first || " ") && ARGV[1..-1].any? {|a| a.start_with?("--bundler") }

end

def initialize(root = nil)

@root = root

@local_config = load_config(local_config_file)

@env_config = ENV.to_h

@env_config.select! {|key, _value| key.start_with?("BUNDLE_") }

end

def set_local(key, value)

set_key(key, value, @local_config, local_config_file)

end

valid_file = file.exist? && !file.size.zero?

return {} unless valid_file

serializer_class.load(file.read).inject({}) do |config, (k, v)|

unless k.start_with?("#")

if k.include?("-")

Bundler.ui.warn "Your #{file} config includes `#{k}`, which contains the dash character (`-`).\n" \

YAMLSerializer

end

NORMALIZE_URI_OPTIONS_PATTERN =

/

\A

(\w+\.)? # optional prefix key

(https?.*?) # URI

\z

/ix

def self.key_for(key)

key.gsub!("-", "___")

key.upcase!

end

# TODO: duplicates Rubygems#normalize_uri

if Bundler::SharedHelpers.in_bundle?

require_relative "../bundler"

# try to auto_install first before we get to the `Bundler.ui.silence`, so user knows what is happening

Bundler.auto_install

require_relative "rubygems_integration"

require_relative "current_ruby"

module Bundler

autoload :WINDOWS, File.expand_path("constants", __dir__)

autoload :FREEBSD, File.expand_path("constants", __dir__)

autoload :NULL, File.expand_path("constants", __dir__)

module SharedHelpers

def root

gemfile = find_gemfile

raise GemfileNotFound, "Could not locate Gemfile" unless gemfile

@local = false

end

def self.from_lock(options)

new(options.merge("uri" => options.delete("remote")))

end

@options = options.dup

@glob = options["glob"] || DEFAULT_GLOB

@root_path = options["root_path"] || root

if options["path"]

@original_path = @path

end

def self.from_lock(options)

new(options.merge("path" => options.delete("remote")))

end

@checksum_store = Checksum::Store.new

Array(options["remotes"]).reverse_each {|r| add_remote(r) }

end

def caches

def self.from_lock(options)

options["remotes"] = Array(options.delete("remote")).reverse

end

def to_lock

out = String.new("GEM\n")

end

out << " specs:\n"

end

index = @allow_remote ? remote_specs.dup : Index.new

index.merge!(cached_specs) if @allow_cached

index.merge!(installed_specs) if @allow_local

index

end

end

def install(spec, options = {})

print_using_message "Using #{version_message(spec, options[:previous_spec])}"

return nil # no post-install message

end

spec.full_gem_path = installed_spec.full_gem_path

spec.loaded_from = installed_spec.loaded_from

spec.post_install_message

end

def installed_specs

@installed_specs ||= Index.build do |idx|

spec.source = self

if Bundler.rubygems.spec_missing_extensions?(spec, false)

Bundler.ui.debug "Source #{self} is ignoring #{spec} because it is missing extensions"

end

end

def cached_specs

@cached_specs ||= begin

idx = Index.new

private

# Checks if the requested spec exists in the global cache. If it does,

# we copy it to the download path, and if it does not, we download it.

#

platforms

end

def validate_deps(s)

s.runtime_dependencies.each do |dep|

next if dep.name == "bundler"

@specs.detect {|spec| spec.name == name && spec.match_platform(platform) }

end

def delete_by_name(name)

@specs.reject! {|spec| spec.name == name }

lookup.keys

end

private

def reset!

spec = specs.first

matching_specs = spec.source.specs.search([spec.name, spec.version])

platform_spec = GemHelpers.select_best_platform_match(matching_specs, platform).find do |s|

end

if platform_spec

specs_for_name = lookup[dep.name]

return [] unless specs_for_name

else

end

end

def tsort_each_child(s)

stub.full_require_paths

end

def load_paths

full_require_paths

end

# frozen_string_literal: true

begin

rescue LoadError

end

end

# frozen_string_literal: false

module Bundler

def self.bundler_major_version

@bundler_major_version ||= VERSION.split(".").first.to_i

indent, key, quote, val = match.captures

val = strip_comment(val)

depth = indent.size / 2

if quote.empty? && val.empty?

new_hash = {}

end

end

class << self

end

end

end

require "rbconfig"

module Gem

end

# Must be first since it unloads the prelude from 1.9.2

##

# Safely write a file in binary mode on all platforms.

def self.write_binary(path, data)

open_file(path, "wb") do |io|

io.write data

end

##

def self.open_file(path, flags, &block)

File.open(path, flags) do |io|

end

yield io

end

end

end

end

##

# Returns full path to the directory where gem's extensions are installed.

def extension_dir

end

##

# Full paths in the gem to add to <code>$LOAD_PATH</code> when this gem is

# activated.

end

def self.bundle_update_bundler_version

return unless "update".start_with?(ARGV.first || " ")

bundler_version = nil

update_index = nil

end

unless spec.extensions.empty? || options[:extensions] || options[:only_executables] || options[:only_plugins]

next

end

unless File.exist?(gem) || options[:only_executables] || options[:only_plugins]

require_relative "../remote_fetcher"

dep = Gem::Dependency.new spec.name, spec.version

found, _ = Gem::SpecFetcher.fetcher.spec_for_dependency dep

installer.install

end

end

end

end

# Return the configuration information for +key+.

def [](key)

end

# Set configuration option +key+ to +value+.

def []=(key, value)

end

def ==(other) # :nodoc:

require_relative "yaml_serializer"

content = Gem::YAMLSerializer.load(yaml)

if k.match?(/\A:(.*)\Z/)

k[1..-1].to_sym

elsif k.include?("__") || k.match?(%r{/\Z})

end

end

if v.is_a?(String)

if v.match?(/\A:(.*)\Z/)

v[1..-1].to_sym

else

v

end

nil

else

v

end

end

end

def set_config_file_name(args)

@config_file_name = ENV["GEMRC"]

need_config_file_name = false

dir_mode = options[:prog_mode] || (mode | 0o111)

unless dir_mode == mode

end

check_executable_overwrite filename

def generate_bin_script(filename, bindir)

bin_script_path = File.join bindir, formatted_program_filename(filename)

end

verbose bin_script_path

# they have the same version, or either one has no version

#

# Additionally, the platform will match if the local CPU is 'arm' and the

#

# Of note, this method is not commutative. Indeed the OS 'linux' has a

# special case: the version is the libc name, yet while "no version" stands

# cpu

([nil,"universal"].include?(@cpu) || [nil, "universal"].include?(other.cpu) || @cpu == other.cpu ||

# os

@os == other.os &&

OPS = { # :nodoc:

"=" => lambda {|v, r| v == r },

"!=" => lambda {|v, r| v != r },

">=" => lambda {|v, r| v >= r },

"<=" => lambda {|v, r| v <= r },

"~>" => lambda {|v, r| v >= r && v.release < r.bump },

end

@@attributes = @@default_value.keys.sort_by(&:to_s)

@@nil_attributes, @@non_nil_attributes = @@default_value.keys.partition do |k|

@@default_value[k].nil?

end

#

# Usage:

#

if requirements.uniq.size != requirements.size

warn "WARNING: duplicated #{gem} dependency #{requirements}"

end

end

private_class_method :clear_load_cache

def self.each_gemspec(dirs) # :nodoc:

dirs.each do |dir|

Gem::Util.glob_files_in_dir("*.gemspec", dir).each do |path|

next names if names.nonzero?

versions = b.version <=> a.version

next versions if versions.nonzero?

end

end

# You probably want to use one of the Enumerable methods instead.

def self.all

Gem::Deprecate.skip

_all

end

# Return the directories that Specification uses to find specs.

def self.dirs

end

##

private :add_dependency_with_type

##

# Adds this spec's require paths to LOAD_PATH, in the proper location.

@test_files.delete_if {|x| File.directory?(x) && !File.symlink?(x) }

end

def validate_metadata

Gem::SpecificationPolicy.new(self).validate_metadata

end

def validate(strict = false)

validate_required!

validate_optional(strict) if packaging || strict

validate_authors_field

validate_licenses_length

validate_duplicate_dependencies

end

def validate_optional(strict)

validate_licenses

end

##

# Implementation for Specification#validate_metadata

def validate_metadata

installed_stubs = installed_stubs(pattern)

installed_stubs.select! {|s| Gem::Platform.match_spec? s } if match_platform

stubs = installed_stubs + Gem::Specification.default_stubs(pattern)

Gem::Specification._resort!(stubs)

stubs

end

def stubbed?

data.is_a? StubLine

end

end

list = []

next unless dependency.matches_spec? spec

list << spec

default_specs, list = list.partition(&:default_gem?)

warn_cannot_uninstall_default_gems(default_specs - list)

list, other_repo_specs = list.partition do |spec|

@gem_home == spec.base_dir ||

remove_all list

elsif list.size > 1

gem_names << "All versions"

say

##

# Uninstalls gem +spec+

@spec = spec

unless dependencies_ok? spec

remove_plugins @spec

remove @spec

regenerate_plugins

Gem.post_uninstall_hooks.each do |hook|

# Removes installed executables and batch files (windows only) for +spec+.

def remove_executables(spec)

executables = spec.executables.clone

safe_delete { FileUtils.rm_r gemspec }

announce_deletion_of(spec)

end

##

# Regenerates plugin wrappers after removal.

def regenerate_plugins

latest = specification_record.latest_spec_for(@spec.name)

return if latest.nil?

private

def announce_deletion_of(spec)

name = spec.full_name

say "Successfully uninstalled #{name}"

indent, key, quote, val = match.captures

val = strip_comment(val)

depth = indent.size / 2

if quote.empty? && val.empty?

new_hash = {}

end

end

class << self

end

end

end

describe "#mkdir_p" do

it "creates a folder at the given path" do

install_gemfile <<-G

G

allow(Bundler).to receive(:root).and_return(bundled_app)

end

end

context "when ENV['BUNDLE_GEMFILE'] is set to an empty string" do

it "ignores it" do

gemfile bundled_app_gemfile, <<-G

G

bundle :install, env: { "BUNDLE_GEMFILE" => "" }

end

end

context "with --verbose" do

it "prints the running command" do

bundle "info bundler", verbose: true

expect(out).to start_with("Running `bundle info bundler --verbose` with bundler #{Bundler::VERSION}")

end

it "doesn't print defaults" do

expect(out).to start_with("Running `bundle install --verbose` with bundler #{Bundler::VERSION}")

end

it "doesn't print defaults" do

expect(out).to start_with("Running `bundle install --verbose` with bundler #{Bundler::VERSION}")

end

end

before do

gemfile <<-G

G

end

it "prints a message when there are outdated gems" do

run_command

end

end

it "prints a message when there are outdated gems" do

run_command

end

end

it "prints a simplified message when there are outdated gems" do

run_command

end

end

end

build_lib "foo", "1.0", path: lib_path("foo")

install_gemfile <<-G

gem "foo", :path => "#{lib_path("foo")}"

G

build_lib "foo", "1.0", path: lib_path("foo") do |s|

end

checksums = checksums_section_when_existing do |c|

c.no_checksum "foo", "1.0"

end

bundle :install, env: { "DEBUG" => "1" }

remote: #{lib_path("foo")}

specs:

foo (1.0)

GEM

specs:

PLATFORMS

#{lockfile_platforms}

end

gemfile <<-G

gem "ffi"

G

it "for a path gem with deps and no changes" do

build_lib "foo", "1.0", path: lib_path("foo") do |s|

s.add_development_dependency "net-ssh", "1.0"

end

checksums = checksums_section_when_existing do |c|

c.no_checksum "foo", "1.0"

end

install_gemfile <<-G

gem "foo", :path => "#{lib_path("foo")}"

G

remote: #{lib_path("foo")}

specs:

foo (1.0)

GEM

specs:

PLATFORMS

#{lockfile_platforms}

end

install_gemfile <<-G

gem "only_java", platform: :jruby

G

expect(out).to match(/using resolution from the lockfile/)

expect(lockfile).to eq <<~G

GEM

specs:

only_java (1.1-java)

end

install_gemfile <<-G

gem "foo"

G

expect(out).to match(/using resolution from the lockfile/)

expect(lockfile).to eq <<~G

GEM

specs:

foo (1.0)

context "eager unlock" do

let(:source_list) do

Bundler::SourceList.new.tap do |source_list|

end

end

before do

gemfile <<-G

gem 'isolated_owner'

gem 'shared_owner_a'

lockfile <<-L

GEM

specs:

isolated_dep (2.0.1)

isolated_owner (1.0.1)

it "handles syntax errors with a useful message" do

expect(Bundler).to receive(:read_file).with(source_root.join("Gemfile").to_s).and_return("}")

expect { subject.eval_gemfile("Gemfile") }.

end

it "distinguishes syntax errors from evaluation errors" do

it "will raise a Bundler::GemfileError" do

gemfile "gem 'foo', :path => /unquoted/string/syntax/error"

expect { Bundler::Dsl.evaluate(bundled_app_gemfile, nil, true) }.

end

end

context "when there is a Gemfile and a lockfile and print_gemfile is true" do

before do

lockfile <<-L

GEM

specs:

DEPENDENCIES

BUNDLED WITH

1.10.0

it "prints the Gemfile" do

expect(output).to include("Gemfile")

end

it "prints the lockfile" do

expect(output).to include("Gemfile.lock")

end

end

end

before do

f.write(gemspec)

end

context "when eval_gemfile is used" do

it "prints all gemfiles" do

eval_gemfile "other/Gemfile"

G

gemfile "eval_gemfile #{bundled_app("Gemfile-alt").to_s.dump}"

### Gemfile-alt

```ruby

eval_gemfile "other/Gemfile"

```

### other/Gemfile-other

```ruby

```

### Gemfile.lock

require "bundler/compact_index_client"

RSpec.describe Bundler::Fetcher::CompactIndex do

let(:display_uri) { Gem::URI("http://sampleuri.com") }

let(:remote) { double(:remote, cache_slug: "lsjdf", uri: display_uri) }

let(:gem_remote_fetcher) { nil }

let(:compact_index) { described_class.new(downloader, remote, display_uri, gem_remote_fetcher) }

before do

allow(compact_index).to receive(:log_specs) {}

end

describe "#specs_for_names" do

end

describe "#available?" do

it "returns true" do

expect(compact_index).to be_available

end

it "reports a relevant friendly error message" do

gemfile <<-G

G

bundle :install, env: { "DEBUG" => "true" }

before(:each) do

global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false", "BUNDLE_GEM__LINTER" => "false",

"BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__CHANGELOG" => "false"

bundle "gem #{app_name}"

prepare_gemspec(app_gemspec_path)

end

end

before do

# silence messages

allow(Bundler.ui).to receive(:confirm)

end

it "when there are uncommitted files" do

expect { Rake.application["release"].invoke }.

to raise_error("There are files that need to be committed first.")

end

it "when there is no git remote" do

expect { Rake.application["release"].invoke }.to raise_error(RuntimeError)

end

end

let(:repo) { build_git("foo", bare: true) }

before do

end

context "on releasing" do

mock_confirm_message "Tagged v#{app_version}."

mock_confirm_message "Pushed git commits and release tag."

end

it "calls rubygem_push with proper arguments" do

it "also works when releasing from an ambiguous reference" do

# Create a branch with the same name as the tag

expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)

end

it "also works with releasing from a branch not yet pushed" do

expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)

mock_build_message app_name, app_version

mock_confirm_message "Pushed git commits and release tag."

expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)

end

mock_confirm_message "Tag v#{app_version} has already been created."

expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)

Rake.application["release"].invoke

end

end

before do

# silence messages

allow(Bundler.ui).to receive(:confirm)

it "invokes install method with empty build_args" do

allow(spec_source).to receive(:install).with(

spec,

)

subject.install_from_spec

end

allow(Bundler.settings).to receive(:[]).with("build.dummy").and_return("--with-dummy-config=dummy")

expect(spec_source).to receive(:install).with(

spec,

)

subject.install_from_spec

end

allow(Bundler.settings).to receive(:[]).with("build.dummy").and_return("--with-dummy-config=dummy --with-another-dummy-config")

expect(spec_source).to receive(:install).with(

spec,

)

subject.install_from_spec

end

before do

allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)

path = lib_path(plugin_name)

index.register_plugin("new-plugin", path.to_s, [path.join("lib").to_s], commands, sources, hooks)

end

end

let(:result) do

end

it "returns the installed spec after installing" do

end

it "returns plugin dir in app .bundle path" do

end

end

end

it "returns plugin dir in global bundle path" do

end

end

end

RSpec.describe Bundler::Resolver::Candidate do

it "compares fine" do

end

end

end

subject { Bundler.rubygems.validate(spec) }

subject

end

context "with an invalid spec" do

before do

and_raise(Gem::InvalidSpecificationException.new("TODO is not an author"))

end

subject(:settings) { described_class.new(bundled_app) }

describe "#set_local" do

subject(:settings) { described_class.new(nil) }

end

end

end

let(:settings) { described_class.new(bundled_app(".bundle")) }

it "converts older keys without double underscore" do

end

it "converts older keys without trailing slashes and double underscore" do

RSpec.describe "bundle package" do

before do

gemfile <<-G

G

end

context "with --cache-path" do

it "caches gems at given path" do

bundle :cache, "cache-path" => "vendor/cache-foo"

end

end

it "caches gems at given path" do

bundle "config set cache_path vendor/cache-foo"

bundle :cache

end

end

context "with absolute --cache-path" do

it "caches gems at given path" do

end

end

end

shared_examples_for "when there are only gemsources" do

before :each do

gemfile <<-G

G

bundle :cache

end

it "copies the .gem file to vendor/cache" do

end

it "uses the cache as a source when installing gems" do

build_gem "omg", path: bundled_app("vendor/cache")

install_gemfile <<-G

gem "omg"

G

system_gems [], path: default_bundle_path

bundle "install --local"

end

it "does not reinstall gems from the cache if they exist on the system" do

end

install_gemfile <<-G

G

end

it "does not reinstall gems from the cache if they exist in the bundle" do

gemfile <<-G

G

end

bundle :install, local: true

end

it "creates a lockfile" do

gemfile <<-G

G

bundle "cache"

let(:default_json_version) { ruby "gem 'json'; require 'json'; puts JSON::VERSION" }

before :each do

build_gem "json", default_json_version, to_system: true, default: true

end

end

end

end

end

describe "when there are also git sources" do

before do

build_git "foo"

install_gemfile <<-G

git "#{lib_path("foo-1.0")}" do

gem 'foo'

end

G

end

system_gems []

bundle "install --local"

end

it "should not explode if the lockfile is not present" do

before :each do

build_repo2

install_gemfile <<-G

gem "actionpack"

G

bundle :cache

expect(cached_gem("actionpack-2.3.2")).to exist

expect(cached_gem("activesupport-2.3.2")).to exist

end

it "re-caches during install" do

bundle :install

expect(out).to include("Updating files in vendor/cache")

end

it "adds and removes when gems are updated" do

update_repo2 do

end

end

bundle "update", all: true

end

it "adds new gems and dependencies" do

install_gemfile <<-G

gem "rails"

G

expect(cached_gem("rails-2.3.2")).to exist

it "removes .gems for removed gems and dependencies" do

install_gemfile <<-G

G

expect(cached_gem("actionpack-2.3.2")).not_to exist

expect(cached_gem("activesupport-2.3.2")).not_to exist

end

it "removes .gems when gem changes to git source" do

install_gemfile <<-G

gem "actionpack"

G

expect(cached_gem("actionpack-2.3.2")).to exist

expect(cached_gem("activesupport-2.3.2")).to exist

end

it "doesn't remove gems that are for another platform" do

simulate_platform "java" do

install_gemfile <<-G

gem "platform_specific"

G

simulate_new_machine

install_gemfile <<-G

gem "platform_specific"

G

expect(cached_gem("platform_specific-1.0-java")).to exist

end

rubygems_version: "1.3.2"

simulate_new_machine

end

checksums = checksums_section do |c|

end

simulate_new_machine

lockfile <<-L

GEM

specs:

#{checksums}

L

bundle :install, raise_on_error: false

expect(exitstatus).to eq(37)

expect(err).to include("Bundler found mismatched checksums.")

bundle :install

end

simulate_new_machine

lockfile <<-L

GEM

specs:

L

end

it "handles directories and non .gem files in the cache" do

it "does not say that it is removing gems when it isn't actually doing so" do

install_gemfile <<-G

G

bundle "cache"

bundle "install"

it "does not warn about all if it doesn't have any git/path dependency" do

install_gemfile <<-G

G

bundle "cache"

expect(out).not_to match(/\-\-all/)

path: bundled_app("vendor/cache")

install_gemfile <<-G

gem "foo-bundler"

G

ref = git.ref_for("main", 11)

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

ref = git.ref_for("main", 11)

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

build_git "foo"

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

old_ref = git.ref_for("main", 11)

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

old_ref = git.ref_for("main", 11)

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

ref = git.ref_for("main", 11)

gemfile <<-G

gem "foo", :git => '#{lib_path("foo-invalid")}', :branch => :main

G

s.add_dependency "submodule"

end

install_gemfile <<-G

git "#{lib_path("has_submodule-1.0")}", :submodules => true do

gem "has_submodule"

end

update_git("foo") {|s| s.write "foo.gemspec", spec_lines.join("\n") }

install_gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

bundle "config set cache_all true"

build_git "foo"

gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

bundle "config set cache_all true"

ref = git.ref_for("main", 11)

gemfile <<-G

gem "foo", :git => '#{lib_path("foo-1.0")}'

G

bundle "config set cache_all true"

build_lib "foo", path: bundled_app("lib/foo")

install_gemfile <<-G

gem "foo", :path => '#{bundled_app("lib/foo")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib libname, path: libpath

install_gemfile <<-G

gem "#{libname}", :path => '#{libpath}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "bar"

install_gemfile <<-G

gem "bar", :path => '#{lib_path("bar-1.0")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "bar"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

gem "bar", :path => '#{lib_path("bar-1.0")}'

G

build_lib "foo"

install_gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

G

build_lib "baz"

gemfile <<-G

gem "foo", :path => '#{lib_path("foo-1.0")}'

gem "baz", :path => '#{lib_path("baz-1.0")}'

G

RSpec.describe "bundle cache with multiple platforms" do

before :each do

gemfile <<-G

platforms :mri, :rbx do

end

platforms :jruby do

lockfile <<-G

GEM

specs:

activesupport (2.3.5)

PLATFORMS

java

DEPENDENCIES

activesupport (2.3.5)

G

end

it "ensures that a successful bundle install does not delete gems for other platforms" do

bundle "install"

expect(bundled_app("vendor/cache/activesupport-2.3.5.gem")).to exist

end

it "ensures that a successful bundle update does not delete gems for other platforms" do

bundle "update", all: true

expect(bundled_app("vendor/cache/activesupport-2.3.5.gem")).to exist

end

end

build_git "foo", "2.0"

gemfile <<-G

gem "weakling", "~> 0.0.1"

G

end

end

end

describe "without version specified" do

it "version requirement becomes ~> major.minor.patch when resolved version is < 1.0" do

bundle "add 'bar'"

describe "with --source" do

it "adds dependency with specified source" do

expect(the_bundle).to include_gems "foo 2.0"

end

end

end

describe "with --github" do

bundle "add rake --github=ruby/rake"

expect(bundled_app_gemfile.read).to match(%r{gem "rake", "~> 13\.\d+", :github => "ruby\/rake"})

end

describe "with --github and --branch" do

bundle "add rake --github=ruby/rake --branch=master"

expect(bundled_app_gemfile.read).to match(%r{gem "rake", "~> 13\.\d+", :github => "ruby\/rake", :branch => "master"})

end

describe "with --github and --ref" do

bundle "add rake --github=ruby/rake --ref=5c60da8"

expect(bundled_app_gemfile.read).to match(%r{gem "rake", "~> 13\.\d+", :github => "ruby\/rake", :ref => "5c60da8"})

end

describe "with --github and --glob" do

bundle "add rake --github=ruby/rake --glob='./*.gemspec'"

expect(bundled_app_gemfile.read).to match(%r{gem "rake", "~> 13\.\d+", :github => "ruby\/rake", :glob => "\.\/\*\.gemspec"})