- return @git_commit_sha = IO.popen(%w[git rev-parse --short HEAD], { :chdir => git_dir }, &:read).strip.freeze

- Bundler::Deployment.define_task(self, :task, :except => { :no_release => true })

- buf = String.new(:capacity => DEFAULT_BLOCK_SIZE)

- check_unknown_options!(:except => [:config, :exec])

- desc "cli_help", "Prints a summary of bundler commands", :hide => true

- shell.print_table(primary_commands, :indent => 4, :truncate => true)

- shell.print_table(utilities, :indent => 4, :truncate => true)

- class_option "no-color", :type => :boolean, :desc => "Disable colorization in output"

- class_option "retry", :type => :numeric, :aliases => "-r", :banner => "NUM",

- :desc => "Specify the number of times you wish to attempt network commands"

- class_option "verbose", :type => :boolean, :desc => "Enable verbose output mode", :aliases => "-V"

- method_option "gemspec", :type => :string, :banner => "Use the specified .gemspec to create the Gemfile"

- method_option "gemfile", :type => :string, :banner => "Use the specified name for the gemfile instead of 'Gemfile'"

- method_option "dry-run", :type => :boolean, :default => false, :banner =>

- "Lock the Gemfile"

- method_option "gemfile", :type => :string, :banner =>

- "Use the specified gemfile instead of Gemfile"

- method_option "path", :type => :string, :banner =>

- "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).#{" Bundler will remember this value for future installs on this machine" unless Bundler.feature_flag.forget_cli_options?}"

- method_option "install", :type => :boolean, :banner =>

- "Runs 'bundle install' after removing the gems from the Gemfile"

- SharedHelpers.major_deprecation(2, message, :removed_message => removed_message)

- method_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>

- "Generate bin stubs for bundled gems to ./bin"

- method_option "clean", :type => :boolean, :banner =>

- "Run bundle clean automatically after install"

- method_option "deployment", :type => :boolean, :banner =>

- "Install using defaults tuned for deployment environments"

- method_option "frozen", :type => :boolean, :banner =>

- "Do not allow the Gemfile.lock to be updated after this install"

- method_option "full-index", :type => :boolean, :banner =>

- "Fall back to using the single-file index of all gems"

- method_option "gemfile", :type => :string, :banner =>

- "Use the specified gemfile instead of Gemfile"

- method_option "jobs", :aliases => "-j", :type => :numeric, :banner =>

- "Specify the number of jobs to run in parallel"

- method_option "local", :type => :boolean, :banner =>

- "Do not attempt to fetch gems remotely and use the gem cache instead"

- method_option "prefer-local", :type => :boolean, :banner =>

- "Only attempt to fetch gems remotely if not present locally, even if newer versions are available remotely"

- method_option "no-cache", :type => :boolean, :banner =>

- "Don't update the existing gem cache."

- method_option "redownload", :type => :boolean, :aliases => "--force", :banner =>

- "Force downloading every gem."

- method_option "no-prune", :type => :boolean, :banner =>

- "Don't remove stale gems from the cache."

- method_option "path", :type => :string, :banner =>

- "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).#{" Bundler will remember this value for future installs on this machine" unless Bundler.feature_flag.forget_cli_options?}"

- method_option "quiet", :type => :boolean, :banner =>

- "Only output warnings and errors."

- method_option "shebang", :type => :string, :banner =>

- "Specify a different shebang executable name than the default (usually 'ruby')"

- method_option "standalone", :type => :array, :lazy_default => [], :banner =>

- "Make a bundle that can work without the Bundler runtime"

- method_option "system", :type => :boolean, :banner =>

- "Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application"

- method_option "trust-policy", :alias => "P", :type => :string, :banner =>

- "Gem trust policy (like gem install -P). Must be one of " +

- Bundler.rubygems.security_policy_keys.join("|")

- method_option "without", :type => :array, :banner =>

- "Exclude gems that are part of the specified named group."

- method_option "with", :type => :array, :banner =>

- "Include gems that are part of the specified named group."

- Bundler.settings.temporary(:no_install => false) do

- method_option "full-index", :type => :boolean, :banner =>

- "Fall back to using the single-file index of all gems"

- method_option "gemfile", :type => :string, :banner =>

- "Use the specified gemfile instead of Gemfile"

- method_option "group", :aliases => "-g", :type => :array, :banner =>

- "Update a specific group"

- method_option "jobs", :aliases => "-j", :type => :numeric, :banner =>

- "Specify the number of jobs to run in parallel"

- method_option "local", :type => :boolean, :banner =>

- "Do not attempt to fetch gems remotely and use the gem cache instead"

- method_option "quiet", :type => :boolean, :banner =>

- "Only output warnings and errors."

- method_option "source", :type => :array, :banner =>

- "Update a specific source (and all gems associated with it)"

- method_option "redownload", :type => :boolean, :aliases => "--force", :banner =>

- "Force downloading every gem."

- method_option "ruby", :type => :boolean, :banner =>

- "Update ruby specified in Gemfile.lock"

- method_option "bundler", :type => :string, :lazy_default => "> 0.a", :banner =>

- "Update the locked version of bundler"

- method_option "", :type => :boolean, :banner =>

- "Prefer updating only to next version"

- method_option "minor", :type => :boolean, :banner =>

- "Prefer updating only to next minor version"

- method_option "major", :type => :boolean, :banner =>

- "Prefer updating to next major version (default)"

- method_option "pre", :type => :boolean, :banner =>

- "Always choose the highest allowed version when updating gems, regardless of prerelease status"

- method_option "strict", :type => :boolean, :banner =>

- "Do not allow any gem to be updated past latest -- | --minor | --major"

- method_option "conservative", :type => :boolean, :banner =>

- "Use bundle install conservative update behavior and do not allow shared dependencies to be updated."

- method_option "all", :type => :boolean, :banner =>

- "Update everything."

- Bundler.settings.temporary(:no_install => false) do

- method_option "paths", :type => :boolean,

- :banner => "List the paths of all gems that are required by your Gemfile."

- method_option "outdated", :type => :boolean,

- :banner => "Show verbose output including whether gems are outdated."

- SharedHelpers.major_deprecation(2, message, :removed_message => removed_message)

- method_option "name-only", :type => :boolean, :banner => "print only the gem names"

- method_option "only-group", :type => :array, :default => [], :banner => "print gems from a given set of groups"

- method_option "without-group", :type => :array, :default => [], :banner => "print all gems except from a given set of groups"

- method_option "paths", :type => :boolean, :banner => "print the path to each gem in the bundle"

- method_option "path", :type => :boolean, :banner => "Print full path to gem"

- method_option "version", :type => :boolean, :banner => "Print gem version"

- method_option "force", :type => :boolean, :default => false, :banner =>

- "Overwrite existing binstubs if they exist"

- method_option "path", :type => :string, :lazy_default => "bin", :banner =>

- "Binstub destination directory (default bin)"

- method_option "shebang", :type => :string, :banner =>

- "Specify a different shebang executable name than the default (usually 'ruby')"

- method_option "standalone", :type => :boolean, :banner =>

- "Make binstubs that can work without the Bundler runtime"

- method_option "all", :type => :boolean, :banner =>

- "Install binstubs for all gems"

- method_option "all-platforms", :type => :boolean, :default => false, :banner =>

- "Install binstubs for all platforms"

- method_option "version", :aliases => "-v", :type => :string

- method_option "group", :aliases => "-g", :type => :string

- method_option "source", :aliases => "-s", :type => :string

- method_option "require", :aliases => "-r", :type => :string, :banner => "Adds require path to gem. Provide false, or a path as a string."

- method_option "path", :type => :string

- method_option "git", :type => :string

- method_option "", :type => :string

- method_option "branch", :type => :string

- method_option "ref", :type => :string

- method_option "skip-install", :type => :boolean, :banner =>

- "Adds gem to the Gemfile but does not install it"

- method_option "optimistic", :type => :boolean, :banner => "Adds optimistic declaration of version to gem"

- method_option "strict", :type => :boolean, :banner => "Adds strict declaration of version to gem"

- method_option "group", :type => :string, :banner => "List gems from a specific group"

- method_option "groups", :type => :boolean, :banner => "List gems organized by groups"

- method_option "local", :type => :boolean, :banner =>

- "Do not attempt to fetch gems remotely and use the gem cache instead"

- method_option "pre", :type => :boolean, :banner => "Check for newer gems"

- method_option "source", :type => :array, :banner => "Check against a specific source"

- method_option "filter-strict", :type => :boolean, :aliases => "--strict", :banner =>

- "Only list newer versions allowed by your Gemfile requirements"

- method_option "update-strict", :type => :boolean, :banner =>

- "Strict conservative resolution, do not allow any gem to be updated past latest -- | --minor | --major"

- method_option "minor", :type => :boolean, :banner => "Prefer updating only to next minor version"

- method_option "major", :type => :boolean, :banner => "Prefer updating to next major version (default)"

- method_option "", :type => :boolean, :banner => "Prefer updating only to next version"

- method_option "filter-major", :type => :boolean, :banner => "Only list major newer versions"

- method_option "filter-minor", :type => :boolean, :banner => "Only list minor newer versions"

- method_option "filter-", :type => :boolean, :banner => "Only list newer versions"

- method_option "parseable", :aliases => "--porcelain", :type => :boolean, :banner =>

- "Use minimal formatting for more parseable output"

- method_option "json", :type => :boolean, :banner => "Produce parseable json output"

- method_option "only-explicit", :type => :boolean, :banner =>

- "Only list gems specified in your Gemfile, not their dependencies"

- method_option "group", :aliases => "-g", :type => :array, :banner =>

- "Fetch funding information for a specific group"

- method_option "all", :type => :boolean,

- :default => Bundler.feature_flag.cache_all?,

- :banner => "Include all sources (including path and git)."

- method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms present in the lockfile, not only the current one"

- method_option "cache-path", :type => :string, :banner =>

- "Specify a different cache path than the default (vendor/cache)."

- method_option "gemfile", :type => :string, :banner => "Use the specified gemfile instead of Gemfile"

- method_option "no-install", :type => :boolean, :banner => "Don't install the gems, only update the cache."

- method_option "no-prune", :type => :boolean, :banner => "Don't remove stale gems from the cache."

- method_option "path", :type => :string, :banner =>

- "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).#{" Bundler will remember this value for future installs on this machine" unless Bundler.feature_flag.forget_cli_options?}"

- method_option "quiet", :type => :boolean, :banner => "Only output warnings and errors."

- method_option "frozen", :type => :boolean, :banner =>

- "Do not allow the Gemfile.lock to be updated after this bundle cache operation's install"

- SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- method_option :keep_file_descriptors, :type => :boolean, :default => true

- method_option :gemfile, :type => :string, :required => false

- SharedHelpers.major_deprecation(2, message, :removed_message => removed_message)

- method_option "path", :type => :string, :lazy_default => "", :banner => "Open relative path of the gem source."

- desc "viz [OPTIONS]", "Generates a visual dependency graph", :hide => true

- method_option :file, :type => :string, :default => "gem_graph", :aliases => "-f", :desc => "The name to use for the generated file. see format option"

- method_option :format, :type => :string, :default => "png", :aliases => "-F", :desc => "This is output format option. Supported format is png, jpg, svg, dot ..."

- method_option :requirements, :type => :boolean, :default => false, :aliases => "-R", :desc => "Set to show the version of each required dependency."

- method_option :version, :type => :boolean, :default => false, :aliases => "-v", :desc => "Set to show each gem version."

- method_option :without, :type => :array, :default => [], :aliases => "-W", :banner => "GROUP[ GROUP...]", :desc => "Exclude gems that are part of the specified named group."

- method_option :exe, :type => :boolean, :default => false, :aliases => ["--bin", "-b"], :desc => "Generate a binary executable for your library."

- method_option :coc, :type => :boolean, :desc => "Generate a code of conduct file. Set a default with `bundle config set --global gem.coc true`."

- method_option :edit, :type => :string, :aliases => "-e", :required => false, :banner => "EDITOR",

- :lazy_default => [ENV["BUNDLER_EDITOR"], ENV["VISUAL"], ENV["EDITOR"]].find {|e| !e.nil? && !e.empty? },

- :desc => "Open generated gemspec in the specified editor (defaults to $EDITOR or $BUNDLER_EDITOR)"

- method_option :ext, :type => :string, :desc => "Generate the boilerplate for C extension code.", :enum => EXTENSIONS

- method_option :git, :type => :boolean, :default => true, :desc => "Initialize a git repo inside your library."

- method_option :mit, :type => :boolean, :desc => "Generate an MIT license file. Set a default with `bundle config set --global gem.mit true`."

- 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 Actions, GitLab CI or CircleCI. Set a default with `bundle config set --global gem.ci (|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 :_username, :type => :string, :default => Bundler.settings["gem._username"], :banner => "Set your username on ", :desc => "Fill in username on README so that you don't have to do it manually. Set a default with `bundle config set --global gem._username <your_username>`."

- desc "clean [OPTIONS]", "Cleans up unused gems in your bundler directory", :hide => true

- method_option "dry-run", :type => :boolean, :default => false, :banner =>

- "Only print out changes, do not clean gems"

- method_option "force", :type => :boolean, :default => false, :banner =>

- "Forces cleaning up unused gems even if Bundler is configured to use globally installed gems. As a consequence, removes all system gems except for the ones in the current application."

- method_option "ruby", :type => :boolean, :default => false, :banner =>

- "only display ruby related platform information"

- desc "inject GEM VERSION", "Add the named gem, with version requirements, to the resolved Gemfile", :hide => true

- method_option "source", :type => :string, :banner =>

- "Install gem from the given source"

- method_option "group", :type => :string, :banner =>

- "Install gem into a bundler group"

- method_option "update", :type => :array, :lazy_default => true, :banner =>

- "ignore the existing lockfile, update all gems by default, or update list of given gems"

- method_option "local", :type => :boolean, :default => false, :banner =>

- "do not attempt to fetch remote gemspecs and use the local gem cache only"

- method_option "print", :type => :boolean, :default => false, :banner =>

- "print the lockfile to STDOUT instead of writing to the file system"

- method_option "gemfile", :type => :string, :banner =>

- "Use the specified gemfile instead of Gemfile"

- method_option "lockfile", :type => :string, :default => nil, :banner =>

- "the path the lockfile should be written to"

- method_option "full-index", :type => :boolean, :default => false, :banner =>

- "Fall back to using the single-file index of all gems"

- method_option "add-platform", :type => :array, :default => [], :banner =>

- "Add a new platform to the lockfile"

- method_option "remove-platform", :type => :array, :default => [], :banner =>

- "Remove a platform from the lockfile"

- method_option "", :type => :boolean, :banner =>

- "If updating, prefer updating only to next version"

- method_option "minor", :type => :boolean, :banner =>

- "If updating, prefer updating only to next minor version"

- method_option "major", :type => :boolean, :banner =>

- "If updating, prefer updating to next major version (default)"

- method_option "pre", :type => :boolean, :banner =>

- "If updating, always choose the highest allowed version, regardless of prerelease status"

- method_option "strict", :type => :boolean, :banner =>

- "If updating, do not allow any gem to be updated past latest -- | --minor | --major"

- method_option "conservative", :type => :boolean, :banner =>

- "If updating, use bundle install conservative update behavior and do not allow shared dependencies to be updated"

- method_option "bundler", :type => :string, :lazy_default => "> 0.a", :banner =>

- "Update the locked version of bundler"

- method_option "gemfile", :type => :string, :banner =>

- "Use the specified gemfile instead of Gemfile"

- method_option "quiet", :type => :boolean, :banner =>

- "Only output warnings and errors."

- SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- Bundler::SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- :conservative_versioning => options[:version].nil?, # Perform conservative versioning only when version is not specified

- :optimistic => options[:optimistic],

- :strict => options[:strict])

- :force => options[:force],

- :binstubs_cmd => true,

- :all_platforms => options["all-platforms"],

- Bundler.settings.temporary(:path => (Bundler.settings[:path] || Bundler.root)) do

- Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do

- Bundler.load.lock(:preserve_unknown_sections => true) unless options[:"dry-run"]

- class_option :parseable, :type => :boolean, :banner => "Use minimal formatting for more parseable output"

- method_option :global, :type => :boolean, :banner => "Only change the global config"

- method_option :local, :type => :boolean, :banner => "Only change the local config"

- desc "base NAME [VALUE]", "The Bundler 1 config interface", :hide => true

- method_option :delete, :type => :boolean, :banner => "delete"

- SharedHelpers.major_deprecation 3, message, :removed_message => removed_message

- Bundler::SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- @args << { :close_others => !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?

- :name => name,

- :underscored_name => underscored_name,

- :namespaced_path => namespaced_path,

- :makefile_path => "#{underscored_name}/#{underscored_name}",

- :constant_name => constant_name,

- :constant_array => constant_array,

- :author => git_author_name.empty? ? "TODO: Write your name" : git_author_name,

- :email => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,

- :test => options[:test],

- :ext => extension,

- :exe => options[:exe],

- :bundler_version => bundler_dependency_version,

- :git => use_git,

- :_username => _username.empty? ? "[USERNAME]" : _username,

- :required_ruby_version => required_ruby_version,

- :rust_builder_required_rubygems_version => rust_builder_required_rubygems_version,

- :minitest_constant_name => minitest_constant_name,

- IO.popen(%w[git add .], { :chdir => target }, &:read)

- :removed_message => "--rubocop has been removed, use --linter=rubocop"

- :removed_message => "--no-rubocop has been removed, use --linter"

- :removed_message => "config gem.rubocop has been removed; we've updated your config to use gem.linter instead"

- :removed_message => "The --binstubs option have been removed in favor of `bundle binstubs --all`"

- Bundler.settings.temporary(:cache_all_platforms => options[:local] ? false : Bundler.settings[:cache_all_platforms]) do

- "will break this application for all non-root users on this machine.", :wrap => true

- Bundler.settings.temporary(:path_relative_to_cwd => false) do

- update = { :gems => update, :conservative => conservative }

- update = { :conservative => conservative }

- update = { :bundler => bundler }

- Bundler.settings.temporary(:frozen => false) do

- system(*command, { :chdir => root_path })

- Bundler.definition(:gems => gems, :sources => sources)

- options.merge(:strict => @strict)

- :active_spec => active_spec,

- :current_spec => current_spec,

- :dependency => dependency,

- :groups => groups,

- by_group(outdated_gems, :filter => options[:group])

- data = { :outdated_count => gems_list.count, :outdated_gems => data }

- :current_spec => spec_data_for(current_spec),

- :active_spec => spec_data_for(active_spec),

- :dependency => dependency&.to_s,

- :groups => (groups || "").split(", "),

- :name => spec.name,

- :version => spec.version.to_s,

- :platform => spec.platform,

- :source => spec.source.to_s,

- :required_ruby_version => spec.required_ruby_version.to_s,

- :required_rubygems_version => spec.required_rubygems_version.to_s,

- method_option "source", :type => :string, :default => nil, :banner =>

- "URL of the RubyGems source to fetch the plugin from"

- method_option "version", :type => :string, :default => nil, :banner =>

- "The version of the plugin to fetch"

- method_option "git", :type => :string, :default => nil, :banner =>

- "URL of the git repo to fetch from"

- method_option "local_git", :type => :string, :default => nil, :banner =>

- "Path of the local git repo to fetch from"

- method_option "branch", :type => :string, :default => nil, :banner =>

- "The git branch to checkout"

- method_option "ref", :type => :string, :default => nil, :banner =>

- "The git revision to check out"

- method_option "all", :type => :boolean, :default => nil, :banner =>

- "Uninstall all the installed plugins. If no plugin is installed, then it does nothing."

- Bundler.definition(:conservative => conservative)

- Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby],

- :conservative => conservative,

- :bundler => update_bundler)

- h[s.name] = { :spec => s, :version => s.version, :source => s.source.identifier }

- packages = Resolver::Base.new(source_requirements, expanded_dependencies, last_resolve, @platforms, :locked_specs => @originally_locked_specs, :unlock => @unlock[:gems], :prerelease => gem_version_promoter.pre?)

- { :default => default_source }.merge(all_requirements)

- { :default => Source::RubygemsAggregate.new(sources, source_map) }.merge(source_map.direct_requirements)

- :ruby => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],

- :mri => [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],

- :rbx => [Gem::Platform::RUBY],

- :truffleruby => [Gem::Platform::RUBY],

- :jruby => [Gem::Platform::JAVA, [18, 19]],

- :windows => [Gem::Platform::WINDOWS, ALL_RUBY_VERSIONS],

- :mswin => [Gem::Platform::MSWIN, ALL_RUBY_VERSIONS],

- :mswin64 => [Gem::Platform::MSWIN64, ALL_RUBY_VERSIONS - [18]],

- :mingw => [Gem::Platform::MINGW, ALL_RUBY_VERSIONS],

- :x64_mingw => [Gem::Platform::X64_MINGW, ALL_RUBY_VERSIONS - [18, 19]],

- gem spec.name, :name => spec.name, :path => path, :glob => glob

- gem dep.name, *(dep.requirement.as_list + [:type => :development])

- Bundler::SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- Bundler::SharedHelpers.major_deprecation 2, message, :removed_message => removed_message

- con = PersistentHTTP.new :name => "bundler", :proxy => :ENV

- Bundler.ui.error error.message, :wrap => true

- Bundler.ui.error error.message, :wrap => true

- outbuf = IO.popen(cmd, :err => [:child, :out], &:read)

- label.nil? ? {} : { :label => label }

- @g ||= ::GraphViz.digraph(@graph_name, :concentrate => true, :normalize => true, :nodesep => 0.55) do |g|

- :style => "filled",

- :fillcolor => "#B9B9D5",

- :shape => "box3d",

- :fontsize => 16,

- g.add_nodes(child, { :style => "filled", :fillcolor => "#B9B9D5" }.merge(@node_options[child]))

- g.add_edges(parent, child, { :constraint => false }.merge(@edge_options["#{parent}_#{child}"]))

- $stdout.puts g.output :none => String

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

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

- Bundler.settings.temporary(:inline => true, :no_install => false) do

- installer = Bundler::Installer.install(Bundler.root, definition, :system => true)

- content = ERB.new(template, :trim_mode => "-").result(binding)

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

- File.write("#{binstub_path}.cmd", prefix + content, :mode => mode)

- content = ERB.new(template, :trim_mode => "-").result(binding)

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

- File.write("#{bin_path}/#{executable}.cmd", prefix + content, :mode => mode)

- :force => force,

- :ensure_builtin_gems_cached => standalone,

- :build_args => Array(spec_settings),

- :previous_spec => previous_spec,

- installer.generate_bundler_executable_stubs(spec, :force => true)

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

- specification = __materialize__(installable_candidates, :fallback_to_non_installable => false)

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

- opts = { :env_shebang => false, :disable_extensions => disable_exts }

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

- solve_versions(:root => root, :logger => logger)

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

- PubGrub::VersionConstraint.new(package, :range => range)

- Incompatibility.new([unsatisfied_term], :cause => cause, :custom_explanation => custom_explanation, :extended_explanation => extended_explanation)

- range = PubGrub::VersionRange.new(:min => low, :max => high, :include_min => true)

- self_constraint = PubGrub::VersionConstraint.new(package, :range => range)

- PubGrub::Incompatibility.new([self_term, dep_term], :cause => :dependency, :custom_explanation => custom_explanation)

- groups << Resolver::Candidate.new(version, :specs => ruby_specs) if ruby_specs.any?

- groups << Resolver::Candidate.new(version, :specs => platform_specs)

- PubGrub::VersionRange.new(:name => name, :min => ver, :max => bump, :include_min => true)

- PubGrub::VersionRange.new(:min => platform_ver)

- PubGrub::VersionRange.new(:min => ver, :include_min => true)

- PubGrub::VersionRange.new(:max => ver)

- PubGrub::VersionRange.new(:max => platform_ver, :include_max => true)

- PubGrub::VersionRange.new(:min => ver, :max => platform_ver, :include_min => true, :include_max => true)

- PubGrub::VersionRange.new(:min => ver, :max => platform_ver, :include_min => true, :include_max => true).invert

- @packages[name] = Package.new(name, dep_platforms, **options.merge(:dependency => dep))

- super(terms, :cause => cause, :custom_explanation => custom_explanation)

- Dir.glob(glob, :base => base_path).map! {|f| File.expand_path(f, base_path) }

- FileUtils.mkdir_p gem_dir, :mode => 0o755

- lock(:preserve_unknown_sections => true)

- :temporary => @temporary,

- :local => @local_config,

- :env => @env_config,

- :global => @global_config,

- :default => DEFAULT_CONFIG,

- buf = String.new(:capacity => 16_384, :encoding => Encoding::BINARY)

- @uri = URINormalizer.normalize_suffix(options["uri"] || "", :trailing_slash => false)

- generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }

- git_local("rev-parse", "--abbrev-ref", "HEAD", :dir => path).strip

- result, status = git_null("branch", "--contains", commit, :dir => path)

- git "config", "uploadpack.allowAnySHA1InWant", "true", :dir => path.to_s if @commit_ref.nil? && needs_allow_any_sha1_in_want?

- git "fetch", "--force", "--quiet", *extra_fetch_args(ref), :dir => destination

- git "reset", "--hard", @revision, :dir => destination

- git_retry "submodule", "update", "--init", "--recursive", :dir => destination

- git_retry "submodule", "foreach", "--quiet", inner_command, :dir => destination

- capture(command, dir, :ignore_err => true)

- git(*command, :dir => dir)

- run_command(*command, :dir => dir) do |unredacted_command|

- run_command(*command, :dir => dir) do |unredacted_command|

- git("cat-file", "-e", @revision, :dir => path)

- git("rev-parse", "--verify", reference, :dir => path).strip

- ["git", *cmd, { :chdir => dir.to_s }]

- generate_bin(spec, :disable_extensions => true)

- :env_shebang => false,

- :disable_extensions => options[:disable_extensions],

- :build_args => options[:build_args],

- :bundler_extension_cache_path => extension_cache_path(spec)

- :security_policy => Bundler.rubygems.security_policies[Bundler.settings["trust-policy"]],

- :install_dir => install_path.to_s,

- :bin_dir => bin_path.to_s,

- :ignore_dependencies => true,

- :wrappers => true,

- :env_shebang => true,

- :build_args => options[:build_args],

- :bundler_extension_cache_path => extension_cache_path(spec)

- Bundler::Deployment.define_task(Rake::RemoteTask, :remote_task, :roles => :app)