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.
This code was extracted from github.com/Solistra/ruby-digest which is under public domain
Constants
- Deprecate
- FREEBSD
- NULL
- ORIGINAL_ENV
- SUDO_MUTEX
- VERSION
- WINDOWS
Public Class Methods
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>
# File bundler/vendor/uri/lib/uri/common.rb, line 842 def URI(uri) if uri.is_a?(Bundler::URI::Generic) uri elsif uri = String.try_convert(uri) Bundler::URI.parse(uri) else raise ArgumentError, "bad argument (expected Bundler::URI object or Bundler::URI string)" end end
# File bundler.rb, line 342 def app_cache(custom_path = nil) path = custom_path || root Pathname.new(path).join(settings.app_cache_path) end
# File bundler.rb, line 328 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 bundler.rb, line 175 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
Returns absolute location of where binstubs are installed to.
# File bundler.rb, line 117 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 bundler.rb, line 99 def bundle_path @bundle_path ||= Pathname.new(configured_bundle_path.path).expand_path(root) end
# File bundler/version.rb, line 6 def self.bundler_major_version @bundler_major_version ||= VERSION.split(".").first.to_i end
@deprecated Use ‘unbundled_env` instead
# File bundler.rb, line 368 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 bundler.rb, line 455 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 bundler.rb, line 433 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 bundler.rb, line 570 def clear_gemspec_cache @gemspec_cache = {} end
# File bundler.rb, line 85 def configure @configure ||= configure_gem_home_and_path end
# File bundler.rb, line 616 def configure_gem_home_and_path(path = bundle_path) configure_gem_path configure_gem_home(path) Bundler.rubygems.clear_paths end
# File bundler.rb, line 112 def configured_bundle_path @configured_bundle_path ||= settings.path.tap(&:validate!) end
# File bundler.rb, line 103 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
Returns current version of Ruby
@return [CurrentRuby] Current version of Ruby
# File bundler/current_ruby.rb, line 7 def self.current_ruby @current_ruby ||= CurrentRuby.new end
# File bundler.rb, line 484 def default_bundle_dir SharedHelpers.default_bundle_dir end
# File bundler.rb, line 476 def default_gemfile SharedHelpers.default_gemfile end
# File bundler.rb, line 480 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 bundler.rb, line 225 def definition(unlock = nil, lockfile = default_lockfile) @definition = nil if unlock @definition ||= begin configure Definition.build(default_gemfile, lockfile, unlock) end end
# File bundler.rb, line 214 def environment SharedHelpers.major_deprecation 2, "Bundler.environment has been removed in favor of Bundler.load", print_caller_location: true load end
# File bundler.rb, line 579 def feature_flag @feature_flag ||= FeatureFlag.new(VERSION) end
# File bundler.rb, line 233 def frozen_bundle? frozen = settings[:frozen] return frozen unless frozen.nil? settings[:deployment] end
# File bundler/version.rb, line 10 def self.gem_version @gem_version ||= Gem::Version.create(VERSION) end
# File bundler.rb, line 574 def git_present? return @git_present if defined?(@git_present) @git_present = Bundler.which("git#{RbConfig::CONFIG["EXEEXT"]}") end
# File bundler.rb, line 306 def home bundle_path.join("bundler") end
# File bundler.rb, line 310 def install_path home.join("gems") end
# File bundler.rb, line 210 def load @load ||= Runtime.new(root, definition) end
# File bundler.rb, line 543 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 bundler.rb, line 552 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 bundler.rb, line 471 def local_platform return Gem::Platform::RUBY if settings[:force_ruby_platform] Gem::Platform.local end
# File bundler.rb, line 240 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 bundler.rb, line 505 def mkdir_p(path) SharedHelpers.filesystem_access(path, :write) do |p| FileUtils.mkdir_p(p) end end
# File bundler.rb, line 250 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 bundler.rb, line 363 def original_env ORIGINAL_ENV.clone end
Run a ‘Kernel.exec` to a subcommand with the environment present before Bundler
was activated
# File bundler.rb, line 450 def original_exec(*args) with_original_env { Kernel.exec(*args) } end
Run subcommand with the environment present before Bundler
was activated
# File bundler.rb, line 428 def original_system(*args) with_original_env { Kernel.system(*args) } end
# File bundler.rb, line 497 def preferred_gemfile_name Bundler.settings[:init_gems_rb] ? "gems.rb" : "Gemfile" end
# File bundler.rb, line 524 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 bundler.rb, line 206 def require(*groups) setup(*groups).require(*groups) end
# File bundler/vendored_thor.rb, line 4 def self.require_thor_actions require_relative "vendor/thor/lib/thor/actions" end
# File bundler.rb, line 583 def reset! reset_paths! Plugin.reset! reset_rubygems! end
# File bundler.rb, line 594 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 bundler.rb, line 609 def reset_rubygems! return unless defined?(@rubygems) && @rubygems rubygems.undo_replacements rubygems.reset @rubygems = nil end
# File bundler.rb, line 589 def reset_settings_and_root! @settings = nil @root = nil end
# File bundler.rb, line 352 def rm_rf(path) FileUtils.remove_entry_secure(path) if path && File.exist?(path) end
# File bundler.rb, line 318 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 bundler.rb, line 256 def ruby_scope "#{Bundler.rubygems.ruby_engine}/#{RbConfig::CONFIG["ruby_version"]}" end
# File bundler/rubygems_integration.rb, line 490 def self.rubygems @rubygems ||= RubygemsIntegration.new end
# File bundler.rb, line 530 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 bundler.rb, line 622 def self_manager @self_manager ||= begin require_relative "bundler/self_manager" Bundler::SelfManager.new end end
# File bundler.rb, line 356 def settings @settings ||= Settings.new(app_config_path) rescue GemfileNotFound @settings = Settings.new(Pathname.new(".bundle").expand_path) 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 bundler.rb, line 153 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 bundler.rb, line 314 def specs_path bundle_path.join("specifications") end
# File bundler.rb, line 488 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 bundler.rb, line 347 def tmp(name = Process.pid.to_s) Kernel.send(:require, "tmpdir") Pathname.new(Dir.mktmpdir(["bundler", name])) end
# File bundler.rb, line 89 def ui (defined?(@ui) && @ui) || (self.ui = UI::Shell.new) end
# File bundler.rb, line 93 def ui=(ui) Bundler.rubygems.ui = UI::RGProxy.new(ui) @ui = ui end
@return [Hash] Environment with all bundler-related variables removed
# File bundler.rb, line 380 def unbundled_env env = original_env if env.key?("BUNDLER_ORIG_MANPATH") env["MANPATH"] = env["BUNDLER_ORIG_MANPATH"] end env.delete_if {|k, _| k[0, 7] == "BUNDLE_" } if env.key?("RUBYOPT") rubyopt = env["RUBYOPT"].split(" ") rubyopt.delete("-r#{File.expand_path("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
Run a ‘Kernel.exec` to a subcommand in an environment with all bundler related variables removed
# File bundler.rb, line 467 def unbundled_exec(*args) with_env(unbundled_env) { Kernel.exec(*args) } end
Run subcommand in an environment with all bundler related variables removed
# File bundler.rb, line 445 def unbundled_system(*args) with_unbundled_env { Kernel.system(*args) } end
# File bundler.rb, line 501 def use_system_gems? configured_bundle_path.use_system_gems? end
# File bundler.rb, line 284 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 bundler.rb, line 302 def user_cache user_bundle_path("cache") end
# File bundler.rb, line 260 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 bundler.rb, line 511 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 bundler.rb, line 411 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
# File 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
Run block with environment present before Bundler
was activated
# File bundler.rb, line 406 def with_original_env with_env(original_env) { yield } end
Run block with all bundler-related variables removed
# File bundler.rb, line 423 def with_unbundled_env with_env(unbundled_env) { yield } end
Private Class Methods
# File bundler.rb, line 662 def configure_gem_home(path) Bundler::SharedHelpers.set_env "GEM_HOME", path.to_s end
# File bundler.rb, line 653 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
# File bundler.rb, line 645 def eval_gemspec(path, contents) eval(contents, TOPLEVEL_BINDING.dup, path.expand_path.to_s) rescue ScriptError, StandardError => e msg = "There was an error while loading `#{path.basename}`: #{e.message}" raise GemspecError, Dsl::DSLError.new(msg, path, e.backtrace, contents) end
# File bundler.rb, line 637 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
# File bundler.rb, line 631 def load_marshal(data, marshal_proc: nil) Marshal.load(data, marshal_proc) rescue TypeError => e raise MarshalError, "#{e.class}: #{e.message}" end
# File bundler.rb, line 666 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
@param env [Hash]
# File bundler.rb, line 676 def with_env(env) backup = ENV.to_hash ENV.replace(env) yield ensure ENV.replace(backup) end
Private Instance Methods
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>
# File bundler/vendor/uri/lib/uri/common.rb, line 842 def URI(uri) if uri.is_a?(Bundler::URI::Generic) uri elsif uri = String.try_convert(uri) Bundler::URI.parse(uri) else raise ArgumentError, "bad argument (expected Bundler::URI object or Bundler::URI string)" end end