def frozen_bundle?

frozen = settings[:deployment]

frozen

end

"do in future versions. Instead please use `bundle config set cache_all true`, " \

"and stop using this flag" if ARGV.include?("--all")

require_relative "cli/cache"

Cache.new(options).run

end

: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 Actions, Travis CI, GitLab CI or CircleCI. Set a default with `bundle config set --global gem.ci (|travis|gitlab|circle)`"

def gem(name)

end

def self.without_groups_message(command)

command_in_past_tense = command == :install ? "installed" : "updated"

groups = Bundler.settings[:without]

group_list = [groups[0...-1].join(", "), groups[-1..-1]].

reject {|s| s.to_s.empty? }.join(" and ")

group_str = groups.size == 1 ? "group" : "groups"

end

def self.select_spec(name, regex_match = nil)

case specs.count

when 0

when 1

specs.first

else

use_git = Bundler.git_present? && options[:git]

git_author_name = use_git ? `git config user.name`.chomp : ""

git_user_email = use_git ? `git config user.email`.chomp : ""

config = {

:name => name,

:underscored_name => underscored_name,

templates.merge!("CHANGELOG.md.tt" => "CHANGELOG.md")

end

Bundler.ui.info "RuboCop enabled in config"

templates.merge!("rubocop.yml.tt" => ".rubocop.yml")

end

templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]

ci_template

end

def bundler_dependency_version

v = Gem::Version.new(Bundler::VERSION)

req = v.segments[0..1]

options[:local] = true if Bundler.app_cache.exist?

end

# When install is called with --no-deployment, disable deployment mode

gemfile_specs + dependency_specs

end

next unless gems.empty? || gems.include?(current_spec.name)

active_spec = retrieve_active_spec(definition, current_spec)

def checksum_for_file(path)

return nil unless path.file?

# because we need to preserve \n line endings on windows when calculating

# the checksum

SharedHelpers.filesystem_access(path, :read) do

end

end

end

@locked_platforms = []

end

@unlock[:gems] ||= []

@unlock[:sources] ||= []

@unlock[:ruby] ||= if @ruby_version && locked_ruby_version_object

end

end

def resolve_with_cache!

raise "Specs already loaded" if @specs

sources.cached!

gem_name, gem_version = extract_gem_info(e)

locked_gem = @locked_specs[gem_name].last

raise if locked_gem.nil? || locked_gem.version.to_s != gem_version || !@remote

end

unless specs["bundler"].any?

bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last

attr_reader :sources

private :sources

def nothing_changed?

!@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes && !@locked_specs_incomplete_for_platform

end

end

def converge_rubygems_sources

return false if locked_gem_sources.empty?

# Get the RubyGems remotes from the Gemfile

end

def additional_base_requirements_for_resolve

dependencies_by_name = dependencies.inject({}) {|memo, dep| memo.update(dep.name => dep) }

@locked_gems.specs.reduce({}) do |requirements, locked_spec|

name = locked_spec.name

@sources.add_rubygems_remote(source)

end

msg = "This Gemfile contains multiple primary sources. " \

"Each source after the first must include a block to indicate which gems " \

raise GemfileEvalError, msg

else

Bundler::SharedHelpers.major_deprecation 2, "Your Gemfile contains multiple primary sources. " \

"Using `source` more than once without a block is a security risk, and " \

"may result in installing unexpected gems. To resolve this warning, use " \

end

end

settings_flag(:auto_clean_without_path) { bundler_3_mode? }

settings_flag(:cache_all) { bundler_3_mode? }

settings_flag(:default_install_uses_path) { bundler_3_mode? }

settings_flag(:disable_multisource) { bundler_3_mode? }

settings_flag(:forget_cli_options) { bundler_3_mode? }

settings_flag(:global_gem_cache) { bundler_3_mode? }

settings_flag(:path_relative_to_cwd) { bundler_3_mode? }

settings_flag(:plugins) { @bundler_version >= Gem::Version.new("1.14") }

settings_flag(:print_only_version_number) { bundler_3_mode? }

built_gem_path = build_gem

end

desc "Build and install #{name}-#{version}.gem into system gems."

task "install" => "build" do

install_gem(built_gem_path)

Bundler.ui.confirm "#{name} (#{version}) installed."

end

protected

def rubygem_push(path)

# evaluates a gemfile to remove the specified gem

# from it.

def remove_deps(gemfile_path)

Bundler.ui.info "Removing gems from #{gemfile_path}"

patterns = /gem\s+(['"])#{Regexp.union(gems)}\1|gem\s*\((['"])#{Regexp.union(gems)}\2\)/

new_gemfile = []

multiline_removal = false

match_data = line.match(patterns)

if match_data && is_not_within_comment?(line, match_data)

multiline_removal = line.rstrip.end_with?(",")

builder.instance_eval(&gemfile)

builder.check_primary_source_safety

definition = builder.to_definition(nil, true)

def definition.lock(*); end

definition.validate_runtime!

module Bundler

class ParallelInstaller

class SpecInstallation

def initialize(spec)

@spec = spec

@name = spec.name

@state = :none

@post_install_message = ""

@error = nil

state == :failed

end

def ready_to_enqueue?

end

def has_post_install_message?

# Represents only the non-development dependencies, the ones that are

# itself and are in the total list.

def dependencies

end

def missing_lockfile_dependencies(all_spec_names)

end

# Represents all dependencies

end

def to_s

end

end

def call

check_for_corrupt_lockfile

if @size > 1

install_with_worker

else

install_serially

end

handle_error if failed_specs.any?

@specs

ensure

worker_pool && worker_pool.stop

end

def check_for_corrupt_lockfile

missing_dependencies = @specs.map do |s|

[

# are installed.

def enqueue_specs

@specs.select(&:ready_to_enqueue?).each do |spec|

if spec.dependencies_installed? @specs

spec.state = :enqueued

worker_pool.enq spec

same_platform_candidates = candidates.select do |spec|

MatchPlatform.platforms_match?(spec.platform, platform_object)

end

search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))

search

end

@sources << @current_source

end

when GEM

@sources << @current_source

when PLUGIN

@current_source = Plugin.source_from_lock(@opts)

def parse_ruby(line)

@ruby_version = line.strip

end

end

end

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

\fBfrozen\fR (\fBBUNDLE_FROZEN\fR): Disallow changes to the \fBGemfile\fR\. When the \fBGemfile\fR is changed and the lockfile has not been updated, running Bundler commands will be blocked\. Defaults to \fBtrue\fR when \fB\-\-deployment\fR is used\.

.

.IP "\(bu" 4

\fBgem\.push_key\fR (\fBBUNDLE_GEM__PUSH_KEY\fR): Sets the \fB\-\-key\fR parameter for \fBgem push\fR when using the \fBrake release\fR command with a private gemstash server\.

.

.IP "\(bu" 4

\fBno_prune\fR (\fBBUNDLE_NO_PRUNE\fR): Whether Bundler should leave outdated gems unpruned when caching\.

.

.IP "\(bu" 4

\fBpath\fR (\fBBUNDLE_PATH\fR): The location on disk where all gems in your bundle will be located regardless of \fB$GEM_HOME\fR or \fB$GEM_PATH\fR values\. Bundle gems not found in this location will be installed by \fBbundle install\fR\. Defaults to \fBGem\.dir\fR\. When \-\-deployment is used, defaults to vendor/bundle\.

.

.IP "\(bu" 4

Disallow changes to the `Gemfile`. When the `Gemfile` is changed and the

lockfile has not been updated, running Bundler commands will be blocked.

Defaults to `true` when `--deployment` is used.

* `gem.push_key` (`BUNDLE_GEM__PUSH_KEY`):

Sets the `--key` parameter for `gem push` when using the `rake release`

command with a private gemstash server.

Whether `bundle package` should skip installing gems.

* `no_prune` (`BUNDLE_NO_PRUNE`):

Whether Bundler should leave outdated gems unpruned when caching.

* `path` (`BUNDLE_PATH`):

The location on disk where all gems in your bundle will be located regardless

of `$GEM_HOME` or `$GEM_PATH` values. Bundle gems not found in this location

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

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\.

.

.TP

\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\.

.

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 Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

\fBbundle\fR \- Ruby Dependency Management

.\" generated with Ronn/v0.7.3

.\" http://.com/rtomayko/ronn/tree/0.7.3

.

.

.SH "NAME"

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

end

end

# Set internal representation to fetch the gems/specs from remote.

#

# When this is called, the source should try to fetch the specs and

cache_all_platforms

default_install_uses_path

deployment

disable_checksum_validation

disable_exec_load

disable_local_branch_check

init_gems_rb

no_install

no_prune

path_relative_to_cwd

path.system

plugins

spec.source == self

end

# it's possible that gems from one source depend on gems from some

# other source, so now we download gemspecs and iterate over those

# dependencies, looking for gems we don't have info on yet.

end

end

def options

{}

end

end

def install(spec, options = {})

generate_bin(spec, :disable_extensions => true)

nil # no post-install message

end

run_hooks(:post_build)

end

run_hooks(:post_install)

ensure

@dependency_names = []

@allow_remote = false

@allow_cached = false

@caches = [cache_path, *Bundler.rubygems.gem_cache]

end

def remote!

@specs = nil

@allow_remote = true

end

def cached!

@specs = nil

@allow_cached = true

end

o.is_a?(Rubygems) && (o.credless_remotes - credless_remotes).empty?

end

def can_lock?(spec)

spec.source.is_a?(Rubygems)

end

# small_idx.use large_idx.

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

idx.use(cached_specs, :override_dupes) if @allow_cached || @allow_remote

idx

end

end

def cached_specs

@cached_specs ||= begin

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

next if gemfile =~ /^bundler\-[\d\.]+?\.gem/

:metadata_source

def global_rubygems_source

end

def initialize

@global_path_source = nil

@rubygems_sources = []

@metadata_source = Source::Metadata.new

end

def add_path_source(options = {})

end

def global_rubygems_source=(uri)

end

def add_rubygems_remote(uri)

def lock_sources

lock_sources = (path_sources + git_sources + plugin_sources).sort_by(&:to_s)

else

lock_sources << combine_rubygems_sources

end

end

end

replacement_sources.detect {|s| s.is_a?(Source::Rubygems) }

@global_rubygems_source = replacement_rubygems if replacement_rubygems

materialized.map! do |s|

next s unless s.is_a?(LazySpecification)

s.source.dependency_names = deps if s.source.respond_to?(:dependency_names=)

spec = s.__materialize__

unless spec

unless missing_specs

@specs.map do |s|

next s unless s.is_a?(LazySpecification)

s.source.dependency_names = names if s.source.respond_to?(:dependency_names=)

s.source.remote!

spec = s.__materialize__

raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec

source "https://rubygems.org"

# gem "rails"

# A sample gems.rb

source "https://rubygems.org"

# gem "rails"

gem "<%= config[:test] %>", "~> <%= config[:test_framework_version] %>"

<%- end -%>

<%- end -%>

RSpec::Core::RakeTask.new(:spec)

<% end -%>

<% default_task_names << :rubocop -%>

require "rubocop/rake_task"

RuboCop::RakeTask.new

<% end -%>

<% if config[:ext] -%>

<% default_task_names.unshift(:clobber, :compile) -%>

uses: ruby/setup-ruby@v1

with:

ruby-version: <%= RUBY_VERSION %>

- name: Run the default task

require_relative "lib/<%=config[:namespaced_path]%>/version"

Gem::Specification.new do |spec|

<%- if config[:mit] -%>

<%- end -%>

spec.required_ruby_version = Gem::Requirement.new(">= <%= config[:required_ruby_version] %>")

f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})

end

end

spec.require_paths = ["lib"]

<%- if config[:ext] -%>

<%- end -%>

# Uncomment to register a new dependency of your gem

Bundler::Dir.tmpdir

end

class << (RANDOM = Random.new)

MAX = 36**6 # < 0x100000000

end

describe "frozen" do

error = Object.const_get("FrozenError")

else

error = RuntimeError

let(:app_gemspec_path) { app_path.join("#{app_name}.gemspec") }

before(:each) do

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

bundle "gem #{app_name}"

prepare_gemspec(app_gemspec_path)

mock_confirm_message message

end

subject! { Bundler::GemHelper.new(app_path) }

let(:app_version) { "0.1.0" }

let(:app_gem_dir) { app_path.join("pkg") }

let(:app_gem_path) { app_gem_dir.join("#{app_name}-#{app_version}.gem") }

let(:app_gemspec_content) { File.read(app_gemspec_path) }

before(:each) do

end

end

describe "#install_gem" do

context "when installation was successful" do

it "gem is installed" do

end

end

end

end

def a_spec.name

"I like tests"

end

a_spec

end

source_list.add_git_source("uri" => "git://first-git.org/path.git")

end

expect(source_list.lock_sources).to eq [

Bundler::Source::Git.new("uri" => "git://first-git.org/path.git"),

Bundler::Source::Git.new("uri" => "git://second-git.org/path.git"),

expect(err).to include("Could not find gem '#{invalid_regexp}'.")

end

end

end

it "does not fetch remote specs when using the --local option" do

bundle "lock --update --local", :raise_on_error => false

end

it "works with --gemfile flag" do

def bundle_exec_rubocop

prepare_gemspec(bundled_app(gem_name, "#{gem_name}.gemspec"))

bundle "exec rubocop --debug --config .rubocop.yml", :dir => bundled_app(gem_name)

end

let(:generated_gemspec) { Bundler.load_gemspec_uncached(bundled_app(gem_name).join("#{gem_name}.gemspec")) }

let(:gem_name) { "mygem" }

expect(bundled_app("#{gem_name}/README.md").read).to match(%r{https://\.com/bundleuser/#{gem_name}/blob/.*/CODE_OF_CONDUCT.md})

end

sys_exec("git config --global init.defaultBranch main")

bundle "gem #{gem_name} --coc"

end

shared_examples_for "--rubocop flag" do

before do

end

it "generates a gem skeleton with rubocop" do

end

end

define_negated_matcher :exclude, :include

before do

end

it "generates a gem skeleton without rubocop" do

expect(rubocop_dep).to be_nil

end

it "doesn't generate a default .rubocop.yml" do

expect(bundled_app("#{gem_name}/.rubocop.yml")).to_not exist

end

end

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle_exec_rubocop

expect(err).to be_empty

end

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle_exec_rubocop

expect(err).to be_empty

end

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle_exec_rubocop

expect(err).to be_empty

end

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle_exec_rubocop

expect(err).to be_empty

end

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle_exec_rubocop

expect(err).to be_empty

end

shared_examples_for "CI config is absent" do

it "does not create any CI files" do

expect(bundled_app("#{gem_name}/./workflows/main.yml")).to_not exist

end

end

shared_examples_for "generating a gem" do

it "generates a gem skeleton" do

bundle "gem #{gem_name}"

end

end

context "--edit option" do

it "opens the generated gemspec in the user's text editor" do

output = bundle "gem #{gem_name} --edit=echo"

before do

global_config "BUNDLE_GEM__RUBOCOP" => "true"

end

it_behaves_like "--rubocop flag"

it_behaves_like "--no-rubocop flag"

end

before do

global_config "BUNDLE_GEM__RUBOCOP" => "false"

end

it_behaves_like "--rubocop flag"

it_behaves_like "--no-rubocop flag"

end

context "with changelog option in bundle config settings set to true" do

before do

global_config "BUNDLE_GEM__CHANGELOG" => "true"

end

end

context "gem naming with underscore", :readline do

let(:gem_name) { "test_gem" }

end

it "asks about CI service" do

bundle "gem foobar" do |input, _, _|

input.puts ""

end

it "asks about MIT license" do

bundle "config list"

end

it "asks about CoC" do

bundle "gem foobar" do |input, _, _|

input.puts "yes"

end

it "asks about CHANGELOG" do

"BUNDLE_GEM__COC" => "false"

bundle "gem foobar" do |input, _, _|

expect(out).to end_with(expected_output)

end

end

end

bundle "config set --local without emo"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

expect(out).to include(installed_gems_stats)

bundle "config set --local without emo test"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

expect(out).to include("4 Gemfile dependencies, 3 gems now installed.")

bundle "config set --local without emo obama test"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

expect(out).to include("4 Gemfile dependencies, 2 gems now installed.")

end

bundle "config set --local without emo"

bundle :install

expect(out).to include(bundle_show_path_message)

expect(out).to include(bundle_complete_message)

bundle "config set --local path vendor"

bundle "config set --local without emo test"

bundle :install

expect(out).to include(bundle_show_path_message)

expect(out).to include(bundle_complete_message)

bundle "config set --local path vendor"

bundle "config set --local without emo obama test"

bundle :install

expect(out).to include(bundle_show_path_message)

expect(out).to include(bundle_complete_message)

end

end

bundle "install --without emo"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

expect(out).to include(installed_gems_stats)

end

bundle "install --without emo test"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

end

bundle "install --without emo obama test"

bundle :install

expect(out).to include(bundle_show_message)

expect(out).to include(bundle_complete_message)

end

end

bundle "config set --local without emo"

bundle :install

bundle :update, :all => true

expect(out).to include(bundle_updated_message)

bundle "config set --local without emo test"

bundle :install

bundle :update, :all => true

expect(out).to include(bundle_updated_message)

bundle "config set --local without emo obama test"

bundle :install

bundle :update, :all => true

expect(out).to include(bundle_updated_message)

end

end

end

describe "when a possible resolve requires an older version of a locked gem" do

end

end

end

end

bundle "config set --local path vendor/bundle"

bundle "install"

gemfile <<-G

G

lockfile <<-G

G

bundle "config set --local deployment true"

expect(out).to eq("WIN")

end

build_lib "omg", "2.0", :path => lib_path("omg")

install_gemfile <<-G

build_lib "omg", "1.0", :path => lib_path("omg")

expect(the_bundle).to include_gems "omg 1.0"

end

expect(the_bundle).to include_gems "foo 1.0"

end

build_lib "omg", "2.0", :path => lib_path("omg")

install_gemfile <<-G

build_lib "omg", "1.0", :path => lib_path("omg")

expect(the_bundle).to include_gems "omg 1.0"

end

s.executables = "foobar"

end

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

gem 'foo'

end

G

expect(the_bundle).to include_gems "foo 1.0"

bundle "exec foobar"

end

end

before do

build_repo gem_repo3 do

build_gem "depends_on_rack", "1.0.1" do |s|

s.add_dependency "rack"

end

end

end

end

end

end

end

end

end

end

end

end

end

end

end

end

end

L

end

bundle "update --all"

expect(err).to be_empty

end

end

end

end

end

before do

build_repo gem_repo3 do

build_gem "handsoap", "0.2.5.5" do |s|

G

end

bundle "install --verbose"

expect(err).not_to include("Warning")

expect(the_bundle).to include_gems("handsoap 0.2.5.5", "nokogiri 1.11.1", "racca 1.5.2")

expect(the_bundle).to include_gems("handsoap 0.2.5.5", :source => "remote3")

expect(the_bundle).to include_gems("nokogiri 1.11.1", "racca 1.5.2", :source => "remote2")

# Even if the gems are already installed

FileUtils.rm bundled_app_lock

expect(the_bundle).to include_gems("handsoap 0.2.5.5", "nokogiri 1.11.1", "racca 1.5.2")

expect(the_bundle).to include_gems("handsoap 0.2.5.5", :source => "remote3")

expect(the_bundle).to include_gems("nokogiri 1.11.1", "racca 1.5.2", :source => "remote2")

end

end

lockfile <<-L

GEM

remote: #{file_uri_for(gem_repo1)}

remote: #{file_uri_for(gem_repo3)}

specs:

rack (0.9.1)

end

end

context "with a path gem in the same Gemfile" do

before do

build_lib "foo"

G

end

end

end

end

context "when a gem is available from multiple ambiguous sources", :bundler => "3" do

L

end

it "caches the universal-darwin gem when --all-platforms is passed and properly picks it up on further bundler invocations" do

setup_multiplatform_gem

gemfile(google_protobuf)

end

describe "when adding a new source" do

build_repo2

install_gemfile <<-G

source "#{file_uri_for(gem_repo1)}"

RSpec.describe "bundle install with install-time dependencies" do

before do

build_repo2 do

# Test complicated gem dependencies for install

build_gem "net_a" do |s|

s.add_dependency "net_b"

expect(out).to eq("YES\nYES")

end

it "installs gems with a dependency with no type" do

skip "incorrect data check error" if Gem.win_platform?

end

it "installs rake and a gem dependent on rake in the same session" do

gemfile <<-G

gem "rake"

gem "another_implicit_rake_dep"

G

expect(the_bundle).to include_gems "foo 1.0", :source => "git@#{lib_path("foo")}"

end

build_git "foo", "1.0", :path => lib_path("foo"), :default_branch => "main"

install_gemfile <<-G, :verbose => true

G

end

bundle "config set http://localgemserver.test/ user:pass"

install_gemfile(<<-G, :artifice => "endpoint_strict_basic_authentication", :quiet => true)

G

end

it "lists gems alphabetically" do

install_gemfile <<-G

source "#{file_uri_for(gem_repo2)}/"

pending "fails with a helpful error", :bundler => "3"

end

describe "bundle config" do

describe "old list interface" do

before do

"Your Gemfile contains multiple primary sources. " \

"Using `source` more than once without a block is a security risk, and " \

"may result in installing unexpected gems. To resolve this warning, use " \

)

end

pending "fails with a helpful error", :bundler => "3"

end

context "when Bundler.setup is run in a ruby script" do

before do

create_file "gems.rb"

pending "fails with a helpful message", :bundler => "3"

end

end

it "documents all used settings" do

exemptions = %w[

forget_cli_options

gem.coc

gem.mit

GEM

remote: https://rubygems.org/

specs:

jruby-rack (1.1.21)

rake (13.0.1)

rubyzip (1.3.0)

PLATFORMS

java

ruby

DEPENDENCIES

demo!

warbler (~> 2.0)

BUNDLED WITH

expect(last_command.stderr).to be_empty

end

it "installs inline gems when BUNDLE_GEMFILE is set to an empty string" do

ENV["BUNDLE_GEMFILE"] = ""

expect(lockfile).to eq(good_lockfile)

end

it "will use the java platform if both generic java and generic ruby platforms are locked", :jruby do

gemfile <<-G

source "#{file_uri_for(gem_repo1)}"

describe "default gem activation" do

let(:exemptions) do

%w[did_you_mean]

else

%w[io-console openssl]

end << "bundler"

exempts

end

mocks.allow_message_expectations_on_nil = false

end

config.before :suite do

require_relative "support/rubygems_ext"

Spec::Rubygems.test_setup

ENV["BUNDLE_SPEC_RUN"] = "true"

end

config.before :all do

build_repo1

reset_paths!

end

def build_repo1

build_repo gem_repo1 do

build_gem "rack", %w[0.9.1 1.0.0] do |s|

s.executables = "rackup"

s.post_install_message = "Rack's post install message"

build_gem "duradura", "7.0"

build_gem "very_simple_binary", &:add_c_extension

build_gem "simple_binary", &:add_c_extension

def build_repo(path, &blk)

return if File.directory?(path)

rake_path = Dir["#{Path.base_system_gems}/**/rake*.gem"].first

if rake_path.nil?

rake_path = Dir["#{Path.base_system_gems}/**/rake*.gem"].first

end

abort "Your test gems are missing! Run `rm -rf #{tmp}` and try again."

end

end

def update_repo(path)

end

# We only need this hack for rubygems versions without the BundlerVersionFinder

@path_to_default_spec_map.delete_if do |_path, spec|

spec.name == "bundler"

end

def reset!

Dir.glob("#{tmp}/{gems/*,*}", File::FNM_DOTMATCH).each do |dir|

FileUtils.rm_rf(dir)

end

FileUtils.mkdir_p(home)

def ruby(ruby, options = {})

ruby_cmd = build_ruby_cmd

sys_exec(%(#{ruby_cmd} -w -e #{escaped_ruby}), options)

end

match do

opts = names.last.is_a?(Hash) ? names.pop : {}

source = opts.delete(:source)

opts[:raise_on_error] = false

require_path = name == "bundler" ? "#{lib_dir}/bundler" : name.tr("-", "/")

version_const = name == "bundler" ? "Bundler::VERSION" : Spec::Builders.constantize(name)

next "#{name} was expected to be at version #{version} but was #{actual_version}"

end

next "#{name} was expected to be of platform #{platform} but was #{actual_platform}"

end

end

end.compact

@errors.empty?

module Spec

module Path

def source_root

end

def root

end

def test_gemfile

end

def dev_gemfile

end

def vendored_gems(path = nil)

end

def cached_gem(path)

tmp.join("gems/base")

end

def file_uri_for(path)

protocol = "file://"

root = Gem.win_platform? ? "/" : ""

end

def local_gem_path(*path, base: bundled_app)

end

def lib_path(*args)

root.join("lib")

end

def global_plugin_gem(*args)

home ".bundle", "plugin", "gems", *args

end

!git_root.join(".git").directory?

end

extend self

end

end

extend self

def dev_setup

end

def gem_load(gem_name, bin_container)

ENV["HOME"] = Path.home.to_s

ENV["TMPDIR"] = Path.tmpdir.to_s

require "rubygems/user_interaction"

Gem::DefaultUserInteraction.ui = Gem::SilentUI.new

end

def install_parallel_test_deps

require "parallel"

end

end

def install_test_deps

setup_test_paths

end

def check_source_control_changes(success_message:, error_message:)

private

def gem_load_and_activate(gem_name, bin_container)

gem_activate(gem_name)

load Gem.bin_path(gem_name, bin_container)

gem gem_name, gem_requirement

end

old_gemfile = ENV["BUNDLE_GEMFILE"]

ENV["BUNDLE_GEMFILE"] = gemfile.to_s

ensure

ENV["BUNDLE_GEMFILE"] = old_gemfile

end

Path.test_gemfile

end

end

def dev_gemfile