module Bundler
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 Bundler.setup
to setup environment where only specified gems and their specified versions could be used.
See Bundler 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.
Constants
- ORIGINAL_ENV
- SUDO_MUTEX
Public Class Methods
# File lib/bundler.rb, line 348 def app_cache(custom_path = nil) path = custom_path || root Pathname.new(path).join(settings.app_cache_path) end
# File lib/bundler.rb, line 334 def app_config_path if app_config = ENV["BUNDLE_APP_CONFIG"] app_config_pathname = Pathname.new(app_config) if app_config_pathname.absolute? app_config_pathname else app_config_pathname.expand_path(root) end else root.join(".bundle") end end
Automatically install dependencies if Bundler.settings[:auto_install]
exists. This is set through config cmd ‘bundle config set –global auto_install
1`.
Note that this method ‘nil`s out the global Definition object, so it should be called first, before you instantiate anything like an `Installer` that’ll keep a reference to the old one instead.
# File lib/bundler.rb, line 180 def auto_install return unless settings[:auto_install] begin definition.specs rescue GemNotFound, GitError ui.info "Automatically installing missing gems." reset! CLI::Install.new({}).run reset! end end
# File lib/bundler.rb, line 170 def auto_switch self_manager.restart_with_locked_bundler_if_needed end
Returns absolute location of where binstubs are installed to.
# File lib/bundler.rb, line 118 def bin_path @bin_path ||= begin path = settings[:bin] || "bin" path = Pathname.new(path).expand_path(root).expand_path mkdir_p(path) path end end
Returns absolute path of where gems are installed on the filesystem.
# File lib/bundler.rb, line 100 def bundle_path @bundle_path ||= Pathname.new(configured_bundle_path.path).expand_path(root) end
@deprecated Use ‘unbundled_env` instead
# File lib/bundler.rb, line 374 def clean_env message = "`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`" removed_message = "`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, message, removed_message: removed_message, print_caller_location: true) unbundled_env end
@deprecated Use ‘unbundled_exec` instead
# File lib/bundler.rb, line 445 def clean_exec(*args) message = "`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`" removed_message = "`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, message, removed_message: removed_message, print_caller_location: true) with_env(unbundled_env) { Kernel.exec(*args) } end
@deprecated Use ‘unbundled_system` instead
# File lib/bundler.rb, line 423 def clean_system(*args) message = "`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`" removed_message = "`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, message, removed_message: removed_message, print_caller_location: true) with_env(unbundled_env) { Kernel.system(*args) } end
# File lib/bundler.rb, line 560 def clear_gemspec_cache @gemspec_cache = {} end
# File lib/bundler.rb, line 86 def configure @configure ||= configure_gem_home_and_path end
# File lib/bundler.rb, line 623 def configure_gem_home_and_path(path = bundle_path) configure_gem_path configure_gem_home(path) Bundler.rubygems.clear_paths end
# File lib/bundler.rb, line 113 def configured_bundle_path @configured_bundle_path ||= settings.path.tap(&:validate!) end
# File lib/bundler.rb, line 104 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
# File lib/bundler.rb, line 474 def default_bundle_dir SharedHelpers.default_bundle_dir end
# File lib/bundler.rb, line 466 def default_gemfile SharedHelpers.default_gemfile end
# File lib/bundler.rb, line 470 def default_lockfile SharedHelpers.default_lockfile end
Returns an instance of Bundler::Definition for given Gemfile and lockfile
@param unlock [Hash, Boolean, nil] Gems that have been requested
to be updated or true if all gems should be updated
@param lockfile [Pathname] Path to Gemfile.lock @return [Bundler::Definition]
# File lib/bundler.rb, line 231 def definition(unlock = nil, lockfile = default_lockfile) @definition = nil if unlock @definition ||= begin configure Definition.build(default_gemfile, lockfile, unlock) end end
# File lib/bundler.rb, line 220 def environment SharedHelpers.major_deprecation 2, "Bundler.environment has been removed in favor of Bundler.load", print_caller_location: true load end
# File lib/bundler.rb, line 569 def feature_flag @feature_flag ||= FeatureFlag.new(VERSION) end
# File lib/bundler.rb, line 239 def frozen_bundle? frozen = settings[:frozen] return frozen unless frozen.nil? settings[:deployment] end
# File lib/bundler.rb, line 564 def git_present? return @git_present if defined?(@git_present) @git_present = Bundler.which("git#{RbConfig::CONFIG["EXEEXT"]}") end
# File lib/bundler.rb, line 312 def home bundle_path.join("bundler") end
# File lib/bundler.rb, line 316 def install_path home.join("gems") end
# File lib/bundler.rb, line 216 def load @load ||= Runtime.new(root, definition) end
# File lib/bundler.rb, line 533 def load_gemspec(file, validate = false) @gemspec_cache ||= {} key = File.expand_path(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
# File lib/bundler.rb, line 542 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.expand_path.to_s Bundler.rubygems.validate(spec) if validate spec end
# File lib/bundler.rb, line 573 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 error_message = "#{spec.name} #{spec.version} has an invalid gemspec" raise Gem::InvalidSpecificationException, error_message end.flatten Bundler.rubygems.load_plugin_files(path_plugin_files) Bundler.rubygems.load_env_plugins @load_plugins_ran = true end
# File lib/bundler.rb, line 461 def local_platform return Gem::Platform::RUBY if settings[:force_ruby_platform] Gem::Platform.local end
# File lib/bundler.rb, line 246 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
# File lib/bundler.rb, line 495 def mkdir_p(path) SharedHelpers.filesystem_access(path, :write) do |p| FileUtils.mkdir_p(p) end end
# File lib/bundler.rb, line 256 def most_specific_locked_platform?(platform) return false unless defined?(@definition) && @definition definition.most_specific_locked_platform == platform end
@return [Hash] Environment present before Bundler
was activated
# File lib/bundler.rb, line 369 def original_env ORIGINAL_ENV.clone end
Run a ‘Kernel.exec` to a subcommand with the environment present before Bundler
was activated
# File lib/bundler.rb, line 440 def original_exec(*args) with_original_env { Kernel.exec(*args) } end
Run subcommand with the environment present before Bundler
was activated
# File lib/bundler.rb, line 418 def original_system(*args) with_original_env { Kernel.system(*args) } end
# File lib/bundler.rb, line 487 def preferred_gemfile_name Bundler.settings[:init_gems_rb] ? "gems.rb" : "Gemfile" end
# File lib/bundler.rb, line 514 def read_file(file) SharedHelpers.filesystem_access(file, :read) do File.open(file, "r:UTF-8", &:read) end end
Setups Bundler
environment (see Bundler.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 211 def require(*groups) load_plugins setup(*groups).require(*groups) end
# File lib/bundler.rb, line 590 def reset! reset_paths! Plugin.reset! reset_rubygems! end
# File lib/bundler.rb, line 601 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
# File lib/bundler.rb, line 616 def reset_rubygems! return unless defined?(@rubygems) && @rubygems rubygems.undo_replacements rubygems.reset @rubygems = nil end
# File lib/bundler.rb, line 596 def reset_settings_and_root! @settings = nil @root = nil end
# File lib/bundler.rb, line 358 def rm_rf(path) FileUtils.remove_entry_secure(path) if path && File.exist?(path) end
# File lib/bundler.rb, line 324 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.expand_path("..", bundle_dir)) end end
# File lib/bundler.rb, line 262 def ruby_scope "#{Bundler.rubygems.ruby_engine}/#{RbConfig::CONFIG["ruby_version"]}" end
# File lib/bundler.rb, line 520 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.message}" end else load_marshal(data, marshal_proc: SafeMarshal.proc) end end
# File lib/bundler.rb, line 629 def self_manager @self_manager ||= begin require_relative "bundler/self_manager" Bundler::SelfManager.new end end
# File lib/bundler.rb, line 362 def settings @settings ||= Settings.new(app_config_path) rescue GemfileNotFound @settings = Settings.new end
Turns on the Bundler
runtime. After Bundler.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 Bundler.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
Bundler.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 Bundler.require
.
# File lib/bundler.rb, line 154 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
# File lib/bundler.rb, line 320 def specs_path bundle_path.join("specifications") end
# File lib/bundler.rb, line 478 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
# File lib/bundler.rb, line 353 def tmp(name = Process.pid.to_s) Kernel.send(:require, "tmpdir") Pathname.new(Dir.mktmpdir(["bundler", name])) end
# File lib/bundler.rb, line 90 def ui (defined?(@ui) && @ui) || (self.ui = UI::Shell.new) end
# File lib/bundler.rb, line 94 def ui=(ui) Bundler.rubygems.ui = UI::RGProxy.new(ui) @ui = ui end
Remove all bundler-related variables from ENV
# File lib/bundler.rb, line 391 def unbundle_env! ENV.replace(unbundle_env(ENV)) end
@return [Hash] Environment with all bundler-related variables removed
# File lib/bundler.rb, line 386 def unbundled_env unbundle_env(original_env) end
Run a ‘Kernel.exec` to a subcommand in an environment with all bundler related variables removed
# File lib/bundler.rb, line 457 def unbundled_exec(*args) with_env(unbundled_env) { Kernel.exec(*args) } end
Run subcommand in an environment with all bundler related variables removed
# File lib/bundler.rb, line 435 def unbundled_system(*args) with_unbundled_env { Kernel.system(*args) } end
# File lib/bundler.rb, line 491 def use_system_gems? configured_bundle_path.use_system_gems? end
# File lib/bundler.rb, line 290 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
# File lib/bundler.rb, line 308 def user_cache user_bundle_path("cache") end
# File lib/bundler.rb, line 266 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
# File lib/bundler.rb, line 501 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.expand_path(executable, path) return executable_path if File.file?(executable_path) && File.executable?(executable_path) end end end
@deprecated Use ‘with_unbundled_env` instead
# File lib/bundler.rb, line 401 def with_clean_env message = "`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`" removed_message = "`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, message, removed_message: removed_message, print_caller_location: true) with_env(unbundled_env) { yield } end
Run block with environment present before Bundler
was activated
# File lib/bundler.rb, line 396 def with_original_env with_env(original_env) { yield } end
Run block with all bundler-related variables removed
# File lib/bundler.rb, line 413 def with_unbundled_env with_env(unbundled_env) { yield } end