Module: Bundler
Overview
Bundler
provides a consistent environment for Ruby projects by tracking and installing the exact gems and versions that are needed.
Bundler
is a part of Ruby’s standard library.
Bundler
is used by creating gemfiles listing all the project dependencies and (optionally) their versions and then using
require 'bundler/setup'
or .setup to setup environment where only specified gems and their specified versions could be used.
See website for extensive documentation on gemfiles creation and Bundler
usage.
As a standard library inside project, Bundler
could be used for introspection of loaded and required modules.
Constant Summary
-
FREEBSD =
# File 'lib/bundler/constants.rb', line 9RbConfig::CONFIG["host_os"].to_s.include?("bsd")
-
NULL =
# File 'lib/bundler/constants.rb', line 12File::NULL
-
ORIGINAL_ENV =
# File 'lib/bundler.rb', line 37environment_preserver.restore
-
SUDO_MUTEX =
# File 'lib/bundler.rb', line 39Thread::Mutex.new
-
VERSION =
# File 'lib/bundler/version.rb', line 4"2.6.0.dev".freeze
-
WINDOWS =
# File 'lib/bundler/constants.rb', line 6RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
Class Attribute Summary
- .frozen_bundle? ⇒ Boolean readonly
- .git_present? ⇒ Boolean readonly
- .ui rw
- .ui=(ui) rw
- .use_system_gems? ⇒ Boolean readonly
Class Method Summary
- .app_cache(custom_path = nil)
- .app_config_path
-
.auto_install
Automatically install dependencies if
Bundler
.settings exists. - .auto_switch
-
.bin_path
Returns absolute location of where binstubs are installed to.
-
.bundle_path
Returns absolute path of where gems are installed on the filesystem.
- .bundler_major_version
-
.clean_env
deprecated
Deprecated.
Use .unbundled_env instead
-
.clean_exec(*args)
deprecated
Deprecated.
Use .unbundled_exec instead
-
.clean_system(*args)
deprecated
Deprecated.
Use .unbundled_system instead
- .clear_gemspec_cache
- .configure
- .configure_gem_home_and_path(path = bundle_path)
- .configured_bundle_path
- .create_bundle_path
-
.current_ruby ⇒ CurrentRuby
Returns current version of Ruby.
- .default_bundle_dir
- .default_gemfile
- .default_lockfile
-
.definition(unlock = nil, lockfile = default_lockfile) ⇒ Bundler::Definition
Returns an instance of
Definition
for given Gemfile and lockfile. - .environment
- .feature_flag
- .gem_version
- .home
- .install_path
- .load
- .load_gemspec(file, validate = false)
- .load_gemspec_uncached(file, validate = false)
- .load_plugins(definition = Bundler.definition)
- .local_platform
- .locked_gems
- .mkdir_p(path)
- .original_env ⇒ Hash
-
.original_exec(*args)
Run a
Kernel.exec
to a subcommand with the environment present beforeBundler
was activated. -
.original_system(*args)
Run subcommand with the environment present before
Bundler
was activated. - .preferred_gemfile_name
- .read_file(file)
-
.require(*groups)
Setups Bundler environment (see .setup) if it is not already set, and loads all gems from groups specified.
- .require_thor_actions
- .reset!
- .reset_paths!
- .reset_rubygems!
- .reset_settings_and_root!
- .rm_rf(path)
- .root
- .ruby_scope
- .rubygems
- .safe_load_marshal(data)
- .self_manager
- .settings
-
.setup(*groups)
Turns on the
Bundler
runtime. - .specs_path
- .system_bindir
- .tmp(name = Process.pid.to_s)
-
.unbundle_env!
Remove all bundler-related variables from ENV.
- .unbundled_env ⇒ Hash
-
.unbundled_exec(*args)
Run a
Kernel.exec
to a subcommand in an environment with all bundler related variables removed. -
.unbundled_system(*args)
Run subcommand in an environment with all bundler related variables removed.
- .user_bundle_path(dir = "home")
- .user_cache
- .user_home
- .which(executable)
-
.with_clean_env
deprecated
Deprecated.
Use .with_unbundled_env instead
- .with_friendly_errors
-
.with_original_env
Run block with environment present before
Bundler
was activated. -
.with_unbundled_env
Run block with all bundler-related variables removed.
-
URI(uri)
mod_func
Returns a Bundler::URI object derived from the given
uri
, which may be a Bundler::URI string or an existing Bundler::URI object: - .configure_gem_home(path) private
- .configure_gem_path private
- .eval_gemspec(path, contents) private
- .eval_yaml_gemspec(path, contents) private
- .load_marshal(data, marshal_proc: nil) private
- .tmp_home_path private
- .unbundle_env(env) private
- .with_env(env) private
Class Attribute Details
.frozen_bundle? ⇒ Boolean
(readonly)
[ GitHub ]
.git_present? ⇒ Boolean
(readonly)
[ GitHub ]
# File 'lib/bundler.rb', line 560
def git_present? return @git_present if defined?(@git_present) @git_present = Bundler.which("git#{RbConfig::CONFIG["EXEEXT"]}") end
.ui (rw)
[ GitHub ].ui=(ui) (rw)
[ GitHub ]
.use_system_gems? ⇒ Boolean
(readonly)
[ GitHub ]
# File 'lib/bundler.rb', line 487
def use_system_gems? configured_bundle_path.use_system_gems? end
Class Method Details
.app_cache(custom_path = nil)
[ GitHub ].app_config_path
[ GitHub ].auto_install
Automatically install dependencies if Bundler
.settings exists. This is set through config cmd bundle config set --global auto_install 1
.
Note that this method nil
s out the global ::Bundler::Definition
object, so it should be called first, before you instantiate anything like an ::Bundler::Installer
that’ll keep a reference to the old one instead.
.auto_switch
[ GitHub ]# File 'lib/bundler.rb', line 172
def auto_switch self_manager.restart_with_locked_bundler_if_needed end
.bin_path
Returns absolute location of where binstubs are installed to.
.bundle_path
Returns absolute path of where gems are installed on the filesystem.
# File 'lib/bundler.rb', line 102
def bundle_path @bundle_path ||= Pathname.new(configured_bundle_path.path). (root) end
.bundler_major_version
[ GitHub ]# File 'lib/bundler/version.rb', line 6
def self.bundler_major_version @bundler_major_version ||= VERSION.split(".").first.to_i end
.clean_env
Use .unbundled_env instead
# File 'lib/bundler.rb', line 370
def clean_env = "`Bundler.clean_env` has been deprecated in favor of `Bundler.unbundled_env`. " \ "If you instead want the environment before bundler was originally loaded, use `Bundler.original_env`" = "`Bundler.clean_env` has been removed in favor of `Bundler.unbundled_env`. " \ "If you instead want the environment before bundler was originally loaded, use `Bundler.original_env`" Bundler::SharedHelpers.major_deprecation(2, , removed_message: , print_caller_location: true) unbundled_env end
.clean_exec(*args)
Use .unbundled_exec instead
# File 'lib/bundler.rb', line 441
def clean_exec(*args) = "`Bundler.clean_exec` has been deprecated in favor of `Bundler.unbundled_exec`. " \ "If you instead want to exec to a command in the environment before bundler was originally loaded, use `Bundler.original_exec`" = "`Bundler.clean_exec` has been removed in favor of `Bundler.unbundled_exec`. " \ "If you instead want to exec to a command in the environment before bundler was originally loaded, use `Bundler.original_exec`" Bundler::SharedHelpers.major_deprecation(2, , removed_message: , print_caller_location: true) with_env(unbundled_env) { Kernel.exec(*args) } end
.clean_system(*args)
Use .unbundled_system instead
# File 'lib/bundler.rb', line 419
def clean_system(*args) = "`Bundler.clean_system` has been deprecated in favor of `Bundler.unbundled_system`. " \ "If you instead want to run the command in the environment before bundler was originally loaded, use `Bundler.original_system`" = "`Bundler.clean_system` has been removed in favor of `Bundler.unbundled_system`. " \ "If you instead want to run the command in the environment before bundler was originally loaded, use `Bundler.original_system`" Bundler::SharedHelpers.major_deprecation(2, , removed_message: , print_caller_location: true) with_env(unbundled_env) { Kernel.system(*args) } end
.clear_gemspec_cache
[ GitHub ]# File 'lib/bundler.rb', line 556
def clear_gemspec_cache @gemspec_cache = {} end
.configure
[ GitHub ]# File 'lib/bundler.rb', line 88
def configure @configure ||= configure_gem_home_and_path end
.configure_gem_home(path) (private)
[ GitHub ]# File 'lib/bundler.rb', line 689
def configure_gem_home(path) Bundler::SharedHelpers.set_env "GEM_HOME", path.to_s end
.configure_gem_home_and_path(path = bundle_path)
[ GitHub ]# File 'lib/bundler.rb', line 619
def configure_gem_home_and_path(path = bundle_path) configure_gem_path configure_gem_home(path) Bundler.rubygems.clear_paths end
.configure_gem_path (private)
[ GitHub ]# File 'lib/bundler.rb', line 680
def configure_gem_path unless use_system_gems? # this needs to be empty string to cause # PathSupport.split_gem_path to only load up the # Bundler --path setting as the GEM_PATH. Bundler::SharedHelpers.set_env "GEM_PATH", "" end end
.configured_bundle_path
[ GitHub ]# File 'lib/bundler.rb', line 115
def configured_bundle_path @configured_bundle_path ||= settings.path.tap(&:validate!) end
.create_bundle_path
[ GitHub ]# File 'lib/bundler.rb', line 106
def create_bundle_path mkdir_p(bundle_path) unless bundle_path.exist? @bundle_path = bundle_path.realpath rescue Errno::EEXIST raise PathError, "Could not install to path `#{bundle_path}` " \ "because a file already exists at that path. Either remove or rename the file so the directory can be created." end
.current_ruby ⇒ CurrentRuby
Returns current version of Ruby
# File 'lib/bundler/current_ruby.rb', line 7
def self.current_ruby @current_ruby ||= CurrentRuby.new end
.default_bundle_dir
[ GitHub ]# File 'lib/bundler.rb', line 470
def default_bundle_dir SharedHelpers.default_bundle_dir end
.default_gemfile
[ GitHub ]# File 'lib/bundler.rb', line 462
def default_gemfile SharedHelpers.default_gemfile end
.default_lockfile
[ GitHub ]# File 'lib/bundler.rb', line 466
def default_lockfile SharedHelpers.default_lockfile end
.definition(unlock = nil, lockfile = default_lockfile) ⇒ Bundler::Definition
Returns an instance of ::Bundler::Definition
for given Gemfile and lockfile
# File 'lib/bundler.rb', line 233
def definition(unlock = nil, lockfile = default_lockfile) @definition = nil if unlock @definition ||= begin configure Definition.build(default_gemfile, lockfile, unlock) end end
.environment
[ GitHub ]# File 'lib/bundler.rb', line 222
def environment SharedHelpers.major_deprecation 2, "Bundler.environment has been removed in favor of Bundler.load", print_caller_location: true load end
.eval_gemspec(path, contents) (private)
[ GitHub ]# File 'lib/bundler.rb', line 672
def eval_gemspec(path, contents) eval(contents, TOPLEVEL_BINDING.dup, path. .to_s) rescue ScriptError, StandardError => e msg = "There was an error while loading `#{path.basename}`: #{e.}" raise GemspecError, Dsl::DSLError.new(msg, path.to_s, e.backtrace, contents) end
.eval_yaml_gemspec(path, contents) (private)
[ GitHub ]# File 'lib/bundler.rb', line 664
def eval_yaml_gemspec(path, contents) Kernel.require "psych" Gem::Specification.from_yaml(contents) rescue ::Psych::SyntaxError, ArgumentError, Gem::EndOfYAMLException, Gem::Exception eval_gemspec(path, contents) end
.feature_flag
[ GitHub ]# File 'lib/bundler.rb', line 565
def feature_flag @feature_flag ||= FeatureFlag.new(VERSION) end
.gem_version
[ GitHub ].home
[ GitHub ]# File 'lib/bundler.rb', line 308
def home bundle_path.join("bundler") end
.install_path
[ GitHub ]# File 'lib/bundler.rb', line 312
def install_path home.join("gems") end
.load
[ GitHub ]# File 'lib/bundler.rb', line 218
def load @load ||= Runtime.new(root, definition) end
.load_gemspec(file, validate = false)
[ GitHub ]# File 'lib/bundler.rb', line 529
def load_gemspec(file, validate = false) @gemspec_cache ||= {} key = File. (file) @gemspec_cache[key] ||= load_gemspec_uncached(file, validate) # Protect against caching side-effected gemspecs by returning a # new instance each time. @gemspec_cache[key]&.dup end
.load_gemspec_uncached(file, validate = false)
[ GitHub ]# File 'lib/bundler.rb', line 538
def load_gemspec_uncached(file, validate = false) path = Pathname.new(file) contents = read_file(file) spec = if contents.start_with?("---") # YAML header eval_yaml_gemspec(path, contents) else # Eval the gemspec from its parent directory, because some gemspecs # depend on "./" relative paths. SharedHelpers.chdir(path.dirname.to_s) do eval_gemspec(path, contents) end end return unless spec spec.loaded_from = path. .to_s Bundler.rubygems.validate(spec) if validate spec end
.load_marshal(data, marshal_proc: nil) (private)
[ GitHub ]# File 'lib/bundler.rb', line 658
def load_marshal(data, marshal_proc: nil) Marshal.load(data, marshal_proc) rescue TypeError => e raise MarshalError, "#{e.class}: #{e.}" end
.load_plugins(definition = Bundler.definition)
[ GitHub ]# File 'lib/bundler.rb', line 569
def load_plugins(definition = Bundler.definition) return if defined?(@load_plugins_ran) Bundler.rubygems.load_plugins requested_path_gems = definition.requested_specs.select {|s| s.source.is_a?(Source::Path) } path_plugin_files = requested_path_gems.map do |spec| spec.matches_for_glob("rubygems_plugin#{Bundler.rubygems.suffix_pattern}") rescue TypeError = "#{spec.name} #{spec.version} has an invalid gemspec" raise Gem::InvalidSpecificationException, end.flatten Bundler.rubygems.load_plugin_files(path_plugin_files) Bundler.rubygems.load_env_plugins @load_plugins_ran = true end
.local_platform
[ GitHub ].locked_gems
[ GitHub ]# File 'lib/bundler.rb', line 248
def locked_gems @locked_gems ||= if defined?(@definition) && @definition definition.locked_gems elsif Bundler.default_lockfile.file? lock = Bundler.read_file(Bundler.default_lockfile) LockfileParser.new(lock) end end
.mkdir_p(path)
[ GitHub ]# File 'lib/bundler.rb', line 491
def mkdir_p(path) SharedHelpers.filesystem_access(path, :create) do |p| FileUtils.mkdir_p(p) end end
.original_env ⇒ Hash
# File 'lib/bundler.rb', line 365
def original_env ORIGINAL_ENV.clone end
.original_exec(*args)
Run a Kernel.exec
to a subcommand with the environment present before Bundler
was activated
# File 'lib/bundler.rb', line 436
def original_exec(*args) with_original_env { Kernel.exec(*args) } end
.original_system(*args)
Run subcommand with the environment present before Bundler
was activated
# File 'lib/bundler.rb', line 414
def original_system(*args) with_original_env { Kernel.system(*args) } end
.preferred_gemfile_name
[ GitHub ]# File 'lib/bundler.rb', line 483
def preferred_gemfile_name Bundler.settings[:init_gems_rb] ? "gems.rb" : "Gemfile" end
.read_file(file)
[ GitHub ]# File 'lib/bundler.rb', line 510
def read_file(file) SharedHelpers.filesystem_access(file, :read) do File.open(file, "r:UTF-8", &:read) end end
.require(*groups)
Setups Bundler environment (see .setup) if it is not already set, and loads all gems from groups specified. Unlike .setup, can be called multiple times with different groups (if they were allowed by setup).
Assuming Gemfile
gem 'first_gem', '= 1.0'
group :test do
gem 'second_gem', '= 1.0'
end
The code will work as follows:
Bundler.setup # allow all groups
Bundler.require(:default) # requires only first_gem
# ...later
Bundler.require(:test) # requires second_gem
# File 'lib/bundler.rb', line 213
def require(*groups) load_plugins setup(*groups).require(*groups) end
.require_thor_actions
[ GitHub ]# File 'lib/bundler/vendored_thor.rb', line 4
def self.require_thor_actions require_relative "vendor/thor/lib/thor/actions" end
.reset!
[ GitHub ]# File 'lib/bundler.rb', line 586
def reset! reset_paths! Plugin.reset! reset_rubygems! end
.reset_paths!
[ GitHub ]# File 'lib/bundler.rb', line 597
def reset_paths! @bin_path = nil @bundler_major_version = nil @bundle_path = nil @configure = nil @configured_bundle_path = nil @definition = nil @load = nil @locked_gems = nil @root = nil @settings = nil @setup = nil @user_home = nil end
.reset_rubygems!
[ GitHub ].reset_settings_and_root!
[ GitHub ]# File 'lib/bundler.rb', line 592
def reset_settings_and_root! @settings = nil @root = nil end
.rm_rf(path)
[ GitHub ]# File 'lib/bundler.rb', line 354
def rm_rf(path) FileUtils.remove_entry_secure(path) if path && File.exist?(path) end
.root
[ GitHub ]# File 'lib/bundler.rb', line 320
def root @root ||= begin SharedHelpers.root rescue GemfileNotFound bundle_dir = default_bundle_dir raise GemfileNotFound, "Could not locate Gemfile or .bundle/ directory" unless bundle_dir Pathname.new(File. ("..", bundle_dir)) end end
.ruby_scope
[ GitHub ]# File 'lib/bundler.rb', line 258
def ruby_scope "#{Bundler.rubygems.ruby_engine}/#{RbConfig::CONFIG["ruby_version"]}" end
.rubygems
[ GitHub ]# File 'lib/bundler/rubygems_integration.rb', line 465
def self.rubygems @rubygems ||= RubygemsIntegration.new end
.safe_load_marshal(data)
[ GitHub ]# File 'lib/bundler.rb', line 516
def safe_load_marshal(data) if Gem.respond_to?(:load_safe_marshal) Gem.load_safe_marshal begin Gem::SafeMarshal.safe_load(data) rescue Gem::SafeMarshal::Reader::Error, Gem::SafeMarshal::Visitors::ToRuby::Error => e raise MarshalError, "#{e.class}: #{e.}" end else load_marshal(data, marshal_proc: SafeMarshal.proc) end end
.self_manager
[ GitHub ]# File 'lib/bundler.rb', line 625
def self_manager @self_manager ||= begin require_relative "bundler/self_manager" Bundler::SelfManager.new end end
.settings
[ GitHub ]# File 'lib/bundler.rb', line 358
def settings @settings ||= Settings.new(app_config_path) rescue GemfileNotFound @settings = Settings.new end
.setup(*groups)
Turns on the Bundler
runtime. After setup
call, all .load or .require of the gems would be allowed only if they are part of the Gemfile or Ruby’s standard library. If the versions specified in Gemfile, only those versions would be loaded.
Assuming Gemfile
gem 'first_gem', '= 1.0'
group :test do
gem 'second_gem', '= 1.0'
end
The code using setup
works as follows:
require 'third_gem' # allowed, required from global gems
require 'first_gem' # allowed, loads the last installed version
Bundler.setup
require 'fourth_gem' # fails with LoadError
require 'second_gem' # loads exactly version 1.0
setup
can be called only once, all subsequent calls are no-op.
If groups list is provided, only gems from specified groups would be allowed (gems specified outside groups belong to special :default
group).
To require all gems from Gemfile (or only some groups), see .require.
# File 'lib/bundler.rb', line 156
def setup(*groups) # Return if all groups are already loaded return @setup if defined?(@setup) && @setup definition.validate_runtime! SharedHelpers.print_major_deprecations! if groups.empty? # Load all groups, but only once @setup = load.setup else load.setup(*groups) end end
.specs_path
[ GitHub ]# File 'lib/bundler.rb', line 316
def specs_path bundle_path.join("specifications") end
.system_bindir
[ GitHub ]# File 'lib/bundler.rb', line 474
def system_bindir # Gem.bindir doesn't always return the location that RubyGems will install # system binaries. If you put '-n foo' in your .gemrc, RubyGems will # install binstubs there instead. Unfortunately, RubyGems doesn't expose # that directory at all, so rather than parse .gemrc ourselves, we allow # the directory to be set as well, via `bundle config set --local bindir foo`. Bundler.settings[:system_bindir] || Bundler.rubygems.gem_bindir end
.tmp(name = Process.pid.to_s)
[ GitHub ]# File 'lib/bundler.rb', line 349
def tmp(name = Process.pid.to_s) Kernel.send(:require, "tmpdir") Pathname.new(Dir.mktmpdir(["bundler", name])) end
.tmp_home_path (private)
[ GitHub ]# File 'lib/bundler.rb', line 693
def tmp_home_path Kernel.send(:require, "tmpdir") SharedHelpers.filesystem_access(Dir.tmpdir) do path = Bundler.tmp at_exit { Bundler.rm_rf(path) } path end end
.unbundle_env(env) (private)
[ GitHub ]# File 'lib/bundler.rb', line 634
def unbundle_env(env) if env.key?("BUNDLER_ORIG_MANPATH") env["MANPATH"] = env["BUNDLER_ORIG_MANPATH"] end env.delete_if {|k, _| k[0, 7] == "BUNDLE_" } env.delete("BUNDLER_SETUP") if env.key?("RUBYOPT") rubyopt = env["RUBYOPT"].split(" ") rubyopt.delete("-r#{File. ("bundler/setup", __dir__)}") rubyopt.delete("-rbundler/setup") env["RUBYOPT"] = rubyopt.join(" ") end if env.key?("RUBYLIB") rubylib = env["RUBYLIB"].split(File::PATH_SEPARATOR) rubylib.delete(__dir__) env["RUBYLIB"] = rubylib.join(File::PATH_SEPARATOR) end env end
.unbundle_env!
Remove all bundler-related variables from ENV
# File 'lib/bundler.rb', line 387
def unbundle_env! ENV.replace(unbundle_env(ENV)) end
.unbundled_env ⇒ Hash
# File 'lib/bundler.rb', line 382
def unbundled_env unbundle_env(original_env) end
.unbundled_exec(*args)
Run a Kernel.exec
to a subcommand in an environment with all bundler related variables removed
# File 'lib/bundler.rb', line 453
def unbundled_exec(*args) with_env(unbundled_env) { Kernel.exec(*args) } end
.unbundled_system(*args)
Run subcommand in an environment with all bundler related variables removed
# File 'lib/bundler.rb', line 431
def unbundled_system(*args) with_unbundled_env { Kernel.system(*args) } end
URI(uri) (mod_func)
Returns a Bundler::URI object derived from the given uri
, which may be a Bundler::URI string or an existing Bundler::URI object:
# Returns a new Bundler::URI.
uri = Bundler::URI('http://github.com/ruby/ruby')
# => #<Bundler::URI::HTTP http://github.com/ruby/ruby>
# Returns the given Bundler::URI.
Bundler::URI(uri)
# => #<Bundler::URI::HTTP http://github.com/ruby/ruby>
.user_bundle_path(dir = "home")
[ GitHub ]# File 'lib/bundler.rb', line 286
def user_bundle_path(dir = "home") env_var, fallback = case dir when "home" ["BUNDLE_USER_HOME", proc { Pathname.new(user_home).join(".bundle") }] when "cache" ["BUNDLE_USER_CACHE", proc { user_bundle_path.join("cache") }] when "config" ["BUNDLE_USER_CONFIG", proc { user_bundle_path.join("config") }] when "plugin" ["BUNDLE_USER_PLUGIN", proc { user_bundle_path.join("plugin") }] else raise BundlerError, "Unknown user path requested: #{dir}" end # `fallback` will already be a Pathname, but Pathname.new() is # idempotent so it's OK Pathname.new(ENV.fetch(env_var, &fallback)) end
.user_cache
[ GitHub ]# File 'lib/bundler.rb', line 304
def user_cache user_bundle_path("cache") end
.user_home
[ GitHub ]# File 'lib/bundler.rb', line 262
def user_home @user_home ||= begin home = Bundler.rubygems.user_home bundle_home = home ? File.join(home, ".bundle") : nil warning = if home.nil? "Your home directory is not set." elsif !File.directory?(home) "`#{home}` is not a directory." elsif !File.writable?(home) && (!File.directory?(bundle_home) || !File.writable?(bundle_home)) "`#{home}` is not writable." end if warning Bundler.ui.warn "#{warning}\n" user_home = tmp_home_path Bundler.ui.warn "Bundler will use `#{user_home}' as your home directory temporarily.\n" user_home else Pathname.new(home) end end end
.which(executable)
[ GitHub ]# File 'lib/bundler.rb', line 497
def which(executable) if File.file?(executable) && File.executable?(executable) executable elsif paths = ENV["PATH"] quote = '"' paths.split(File::PATH_SEPARATOR).find do |path| path = path[1..-2] if path.start_with?(quote) && path.end_with?(quote) executable_path = File. (executable, path) return executable_path if File.file?(executable_path) && File.executable?(executable_path) end end end
.with_clean_env
Use .with_unbundled_env instead
# File 'lib/bundler.rb', line 397
def with_clean_env = "`Bundler.with_clean_env` has been deprecated in favor of `Bundler.with_unbundled_env`. " \ "If you instead want the environment before bundler was originally loaded, use `Bundler.with_original_env`" = "`Bundler.with_clean_env` has been removed in favor of `Bundler.with_unbundled_env`. " \ "If you instead want the environment before bundler was originally loaded, use `Bundler.with_original_env`" Bundler::SharedHelpers.major_deprecation(2, , removed_message: , print_caller_location: true) with_env(unbundled_env) { yield } end
.with_env(env) (private)
# File 'lib/bundler.rb', line 703
def with_env(env) backup = ENV.to_hash ENV.replace(env) yield ensure ENV.replace(backup) end
.with_friendly_errors
[ GitHub ]# File 'lib/bundler/friendly_errors.rb', line 115
def self.with_friendly_errors FriendlyErrors.enable! yield rescue SignalException raise rescue Exception => e # rubocop:disable Lint/RescueException raise if FriendlyErrors.disabled? FriendlyErrors.log_error(e) exit FriendlyErrors.exit_status(e) end
.with_original_env
Run block with environment present before Bundler
was activated
# File 'lib/bundler.rb', line 392
def with_original_env with_env(original_env) { yield } end
.with_unbundled_env
Run block with all bundler-related variables removed
# File 'lib/bundler.rb', line 409
def with_unbundled_env with_env(unbundled_env) { yield } end