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 347 def app_cache(custom_path = nil) path = custom_path || root Pathname.new(path).join(settings.app_cache_path) end
# File bundler.rb, line 333 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 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 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 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 bundler.rb, line 100 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 373 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 460 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 438 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 575 def clear_gemspec_cache @gemspec_cache = {} end
# File bundler.rb, line 86 def configure @configure ||= configure_gem_home_and_path end
# File bundler.rb, line 621 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 113 def configured_bundle_path @configured_bundle_path ||= settings.path.tap(&:validate!) end
# File 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
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 489 def default_bundle_dir SharedHelpers.default_bundle_dir end
# File bundler.rb, line 481 def default_gemfile SharedHelpers.default_gemfile end
# File bundler.rb, line 485 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 230 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 219 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 584 def feature_flag @feature_flag ||= FeatureFlag.new(VERSION) end
# File bundler.rb, line 238 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 579 def git_present? return @git_present if defined?(@git_present) @git_present = Bundler.which("git#{RbConfig::CONFIG["EXEEXT"]}") end
# File bundler.rb, line 311 def home bundle_path.join("bundler") end
# File bundler.rb, line 315 def install_path home.join("gems") end
# File bundler.rb, line 215 def load @load ||= Runtime.new(root, definition) end
# File bundler.rb, line 548 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 557 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 476 def local_platform return Gem::Platform::RUBY if settings[:force_ruby_platform] Gem::Platform.local end
# File bundler.rb, line 245 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 510 def mkdir_p(path) SharedHelpers.filesystem_access(path, :write) do |p| FileUtils.mkdir_p(p) end end
# File bundler.rb, line 255 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 368 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 455 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 433 def original_system(*args) with_original_env { Kernel.system(*args) } end
# File bundler.rb, line 502 def preferred_gemfile_name Bundler.settings[:init_gems_rb] ? "gems.rb" : "Gemfile" end
# File bundler.rb, line 529 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 211 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 588 def reset! reset_paths! Plugin.reset! reset_rubygems! end
# File bundler.rb, line 599 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 614 def reset_rubygems! return unless defined?(@rubygems) && @rubygems rubygems.undo_replacements rubygems.reset @rubygems = nil end
# File bundler.rb, line 594 def reset_settings_and_root! @settings = nil @root = nil end
# File bundler.rb, line 357 def rm_rf(path) FileUtils.remove_entry_secure(path) if path && File.exist?(path) end
# File bundler.rb, line 323 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 261 def ruby_scope "#{Bundler.rubygems.ruby_engine}/#{RbConfig::CONFIG["ruby_version"]}" end
# File bundler/rubygems_integration.rb, line 504 def self.rubygems @rubygems ||= RubygemsIntegration.new end
# File bundler.rb, line 535 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 627 def self_manager @self_manager ||= begin require_relative "bundler/self_manager" Bundler::SelfManager.new end end
# File bundler.rb, line 361 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 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 bundler.rb, line 319 def specs_path bundle_path.join("specifications") end
# File bundler.rb, line 493 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 352 def tmp(name = Process.pid.to_s) Kernel.send(:require, "tmpdir") Pathname.new(Dir.mktmpdir(["bundler", name])) end
# File bundler.rb, line 90 def ui (defined?(@ui) && @ui) || (self.ui = UI::Shell.new) end
# File bundler.rb, line 94 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 385 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 472 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 450 def unbundled_system(*args) with_unbundled_env { Kernel.system(*args) } end
# File bundler.rb, line 506 def use_system_gems? configured_bundle_path.use_system_gems? end
# File bundler.rb, line 289 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 307 def user_cache user_bundle_path("cache") end
# File bundler.rb, line 265 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 516 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 416 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 411 def with_original_env with_env(original_env) { yield } end
Run block with all bundler-related variables removed
# File bundler.rb, line 428 def with_unbundled_env with_env(unbundled_env) { yield } end
Private Class Methods
# File bundler.rb, line 667 def configure_gem_home(path) Bundler::SharedHelpers.set_env "GEM_HOME", path.to_s end
# File bundler.rb, line 658 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 650 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 642 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 636 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 671 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 681 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