Module: Bundler

Defined in:
lib/bundler/version.rb,
lib/bundler.rb,
lib/bundler/ui.rb,
lib/bundler/cli.rb,
lib/bundler/dsl.rb,
lib/bundler/env.rb,
lib/bundler/graph.rb,
lib/bundler/index.rb,
lib/bundler/retry.rb,
lib/bundler/errors.rb,
lib/bundler/mirror.rb,
lib/bundler/plugin.rb,
lib/bundler/source.rb,
lib/bundler/worker.rb,
lib/bundler/cli/gem.rb,
lib/bundler/cli/viz.rb,
lib/bundler/fetcher.rb,
lib/bundler/gemdeps.rb,
lib/bundler/runtime.rb,
lib/bundler/cli/exec.rb,
lib/bundler/cli/init.rb,
lib/bundler/cli/lock.rb,
lib/bundler/cli/open.rb,
lib/bundler/cli/show.rb,
lib/bundler/injector.rb,
lib/bundler/resolver.rb,
lib/bundler/ruby_dsl.rb,
lib/bundler/settings.rb,
lib/bundler/spec_set.rb,
lib/bundler/ui/shell.rb,
lib/bundler/cli/cache.rb,
lib/bundler/cli/check.rb,
lib/bundler/cli/clean.rb,
lib/bundler/constants.rb,
lib/bundler/dep_proxy.rb,
lib/bundler/deprecate.rb,
lib/bundler/installer.rb,
lib/bundler/ui/silent.rb,
lib/bundler/cli/common.rb,
lib/bundler/cli/config.rb,
lib/bundler/cli/doctor.rb,
lib/bundler/cli/inject.rb,
lib/bundler/cli/plugin.rb,
lib/bundler/cli/update.rb,
lib/bundler/definition.rb,
lib/bundler/dependency.rb,
lib/bundler/deployment.rb,
lib/bundler/gem_helper.rb,
lib/bundler/plugin/api.rb,
lib/bundler/plugin/dsl.rb,
lib/bundler/source/git.rb,
lib/bundler/cli/console.rb,
lib/bundler/cli/install.rb,
lib/bundler/cli/package.rb,
lib/bundler/gem_helpers.rb,
lib/bundler/source/path.rb,
lib/bundler/source_list.rb,
lib/bundler/ui/rg_proxy.rb,
lib/bundler/cli/binstubs.rb,
lib/bundler/cli/outdated.rb,
lib/bundler/cli/platform.rb,
lib/bundler/current_ruby.rb,
lib/bundler/feature_flag.rb,
lib/bundler/fetcher/base.rb,
lib/bundler/plugin/index.rb,
lib/bundler/psyched_yaml.rb,
lib/bundler/ruby_version.rb,
lib/bundler/fetcher/index.rb,
lib/bundler/vendored_thor.rb,
lib/bundler/match_platform.rb,
lib/bundler/shared_helpers.rb,
lib/bundler/source/gemspec.rb,
lib/bundler/friendly_errors.rb,
lib/bundler/lockfile_parser.rb,
lib/bundler/source/rubygems.rb,
lib/bundler/yaml_serializer.rb,
lib/bundler/plugin/installer.rb,
lib/bundler/plugin/api/source.rb,
lib/bundler/fetcher/dependency.rb,
lib/bundler/fetcher/downloader.rb,
lib/bundler/gem_remote_fetcher.rb,
lib/bundler/lazy_specification.rb,
lib/bundler/plugin/source_list.rb,
lib/bundler/stub_specification.rb,
lib/bundler/vendored_molinillo.rb,
lib/bundler/similarity_detector.rb,
lib/bundler/vendored_persistent.rb,
lib/bundler/compact_index_client.rb,
lib/bundler/gem_version_promoter.rb,
lib/bundler/installer/standalone.rb,
lib/bundler/plugin/installer/git.rb,
lib/bundler/remote_specification.rb,
lib/bundler/rubygems_integration.rb,
lib/bundler/source/git/git_proxy.rb,
lib/bundler/environment_preserver.rb,
lib/bundler/fetcher/compact_index.rb,
lib/bundler/source/path/installer.rb,
lib/bundler/endpoint_specification.rb,
lib/bundler/rubygems_gem_installer.rb,
lib/bundler/source/rubygems/remote.rb,
lib/bundler/uri_credentials_filter.rb,
lib/bundler/installer/gem_installer.rb,
lib/bundler/plugin/installer/rubygems.rb,
lib/bundler/compact_index_client/cache.rb,
lib/bundler/compact_index_client/updater.rb,
lib/bundler/installer/parallel_installer.rb,
lib/bundler/ssl_certs/certificate_manager.rb

Overview

Some versions of the Bundler 1.1 RC series introduced corrupted lockfiles. There were two major problems:

  • multiple copies of the same GIT section appeared in the lockfile

  • when this happened, those sections got multiple copies of gems in those sections.

As a result, Bundler 1.1 contains code that fixes the earlier corruption. We will remove this fix-up code in Bundler 1.2.

Defined Under Namespace

Modules: FriendlyErrors, GemHelpers, MatchPlatform, Molinillo, Persistent, Plugin, RubyDsl, SSLCerts, SharedHelpers, UI, URICredentialsFilter, YAMLSerializer Classes: BundlerError, CLI, CompactIndexClient, CurrentRuby, CyclicDependencyError, Definition, DepProxy, Dependency, Deployment, DeprecatedError, Dsl, EndpointSpecification, Env, EnvironmentPreserver, FeatureFlag, Fetcher, GemHelper, GemInstaller, GemNotFound, GemRemoteFetcher, GemRequireError, GemVersionPromoter, Gemdeps, GemfileError, GemfileEvalError, GemfileLockNotFound, GemfileNotFound, GemspecError, GenericSystemCallError, GitError, Graph, HTTPError, Index, Injector, InstallError, InstallHookError, Installer, InvalidOption, LazySpecification, LockfileError, LockfileParser, MarshalError, MirrorSockets, NoSpaceOnDeviceError, OperationNotSupportedError, ParallelInstaller, PathError, PermissionError, PluginError, ProductionError, RemoteSpecification, Resolver, Retry, RubyGemsGemInstaller, RubyVersion, RubyVersionMismatch, RubygemsIntegration, Runtime, SecurityError, Settings, SimilarityDetector, SocketAddress, Source, SourceList, SpecSet, Standalone, StubSpecification, SudoNotPermittedError, TemporaryResourceError, Thor, ThreadCreationError, VersionConflict, VirtualProtocolError, Worker, YamlSyntaxError

Constant Summary

ORIGINAL_ENV =
environment_preserver.restore
SUDO_MUTEX =
Mutex.new
VERSION =

We're doing this because we might write tests that deal with other versions of bundler and we are unsure how to handle this better.

"1.14.3"
WINDOWS =
RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
FREEBSD =
RbConfig::CONFIG["host_os"] =~ /bsd/
NULL =
WINDOWS ? "NUL" : "/dev/null"
Deprecate =
Gem::Deprecate
YamlLibrarySyntaxError =

Syck raises ArgumentError

::ArgumentError

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.bundle_pathObject

Returns absolute path of where gems are installed on the filesystem.



76
77
78
# File 'lib/bundler.rb', line 76

def bundle_path
  @bundle_path ||= Pathname.new(settings.path).expand_path(root)
end

Class Method Details

.app_cache(custom_path = nil) ⇒ Object



221
222
223
224
# File 'lib/bundler.rb', line 221

def app_cache(custom_path = nil)
  path = custom_path || root
  path.join(settings.app_cache_path)
end

.app_config_pathObject



213
214
215
216
217
218
219
# File 'lib/bundler.rb', line 213

def app_config_path
  if ENV["BUNDLE_APP_CONFIG"]
    Pathname.new(ENV["BUNDLE_APP_CONFIG"]).expand_path(root)
  else
    root.join(".bundle")
  end
end

.bin_pathObject

Returns absolute location of where binstubs are installed to.



81
82
83
84
85
86
87
88
# File 'lib/bundler.rb', line 81

def bin_path
  @bin_path ||= begin
    path = settings[:bin] || "bin"
    path = Pathname.new(path).expand_path(root).expand_path
    SharedHelpers.filesystem_access(path) {|p| FileUtils.mkdir_p(p) }
    path
  end
end

.cacheObject



195
196
197
# File 'lib/bundler.rb', line 195

def cache
  bundle_path.join("cache/bundler")
end

.clean_envHash

Deprecated.

Use `original_env` instead

Returns Environment with all bundler-related variables removed

Returns:

  • (Hash)

    Environment with all bundler-related variables removed



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
# File 'lib/bundler.rb', line 255

def clean_env
  Bundler::SharedHelpers.major_deprecation("`Bundler.clean_env` has weird edge cases, use `.original_env` instead")
  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")
    env["RUBYOPT"] = env["RUBYOPT"].sub "-rbundler/setup", ""
  end

  if env.key?("RUBYLIB")
    rubylib = env["RUBYLIB"].split(File::PATH_SEPARATOR)
    rubylib.delete(File.expand_path("..", __FILE__))
    env["RUBYLIB"] = rubylib.join(File::PATH_SEPARATOR)
  end

  env
end

.clean_exec(*args) ⇒ Object



290
291
292
# File 'lib/bundler.rb', line 290

def clean_exec(*args)
  with_clean_env { Kernel.exec(*args) }
end

.clean_system(*args) ⇒ Object



286
287
288
# File 'lib/bundler.rb', line 286

def clean_system(*args)
  with_clean_env { Kernel.system(*args) }
end

.clear_gemspec_cacheObject



428
429
430
# File 'lib/bundler.rb', line 428

def clear_gemspec_cache
  @gemspec_cache = {}
end

.configureObject



62
63
64
# File 'lib/bundler.rb', line 62

def configure
  @configured ||= configure_gem_home_and_path
end

.current_rubyCurrentRuby

Returns current version of Ruby

Returns:



6
7
8
# File 'lib/bundler/current_ruby.rb', line 6

def self.current_ruby
  @current_ruby ||= CurrentRuby.new
end

.default_bundle_dirObject



307
308
309
# File 'lib/bundler.rb', line 307

def default_bundle_dir
  SharedHelpers.default_bundle_dir
end

.default_gemfileObject



299
300
301
# File 'lib/bundler.rb', line 299

def default_gemfile
  SharedHelpers.default_gemfile
end

.default_lockfileObject



303
304
305
# File 'lib/bundler.rb', line 303

def default_lockfile
  SharedHelpers.default_lockfile
end

.definition(unlock = nil) ⇒ Bundler::Definition

Returns an instance of Bundler::Definition for given Gemfile and lockfile

Parameters:

  • unlock (Hash, Boolean, nil) (defaults to: nil)

    Gems that have been requested to be updated or true if all gems should be updated

Returns:



124
125
126
127
128
129
130
# File 'lib/bundler.rb', line 124

def definition(unlock = nil)
  @definition = nil if unlock
  @definition ||= begin
    configure
    Definition.build(default_gemfile, default_lockfile, unlock)
  end
end

.environmentObject



114
115
116
117
# File 'lib/bundler.rb', line 114

def environment
  SharedHelpers.major_deprecation "Bundler.environment has been removed in favor of Bundler.load"
  load
end

.feature_flagObject



437
438
439
# File 'lib/bundler.rb', line 437

def feature_flag
  @feature_flag ||= FeatureFlag.new(VERSION)
end

.git_present?Boolean

Returns:

  • (Boolean)


432
433
434
435
# File 'lib/bundler.rb', line 432

def git_present?
  return @git_present if defined?(@git_present)
  @git_present = Bundler.which("git") || Bundler.which("git.exe")
end

.homeObject



183
184
185
# File 'lib/bundler.rb', line 183

def home
  bundle_path.join("bundler")
end

.install_pathObject



187
188
189
# File 'lib/bundler.rb', line 187

def install_path
  home.join("gems")
end

.loadObject



110
111
112
# File 'lib/bundler.rb', line 110

def load
  @load ||= Runtime.new(root, definition)
end

.load_gemspec(file, validate = false) ⇒ Object



401
402
403
404
405
406
407
408
# File 'lib/bundler.rb', line 401

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 if @gemspec_cache[key]
end

.load_gemspec_uncached(file, validate = false) ⇒ Object



410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
# File 'lib/bundler.rb', line 410

def load_gemspec_uncached(file, validate = false)
  path = Pathname.new(file)
  # Eval the gemspec from its parent directory, because some gemspecs
  # depend on "./" relative paths.
  SharedHelpers.chdir(path.dirname.to_s) do
    contents = path.read
    spec = if contents[0..2] == "---" # YAML header
      eval_yaml_gemspec(path, contents)
    else
      eval_gemspec(path, contents)
    end
    return unless spec
    spec.loaded_from = path.expand_path.to_s
    Bundler.rubygems.validate(spec) if validate
    spec
  end
end

.load_marshal(data) ⇒ Object



395
396
397
398
399
# File 'lib/bundler.rb', line 395

def load_marshal(data)
  Marshal.load(data)
rescue => e
  raise MarshalError, "#{e.class}: #{e.message}"
end

.local_platformObject



294
295
296
297
# File 'lib/bundler.rb', line 294

def local_platform
  return Gem::Platform::RUBY if settings[:force_ruby_platform]
  Gem::Platform.local
end

.locked_gemsObject



132
133
134
135
136
137
138
139
140
# File 'lib/bundler.rb', line 132

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) ⇒ Object



344
345
346
347
348
349
350
351
352
# File 'lib/bundler.rb', line 344

def mkdir_p(path)
  if requires_sudo?
    sudo "mkdir -p '#{path}'" unless File.exist?(path)
  else
    SharedHelpers.filesystem_access(path, :write) do |p|
      FileUtils.mkdir_p(p)
    end
  end
end

.original_envHash

Returns Environment present before Bundler was activated

Returns:

  • (Hash)

    Environment present before Bundler was activated



249
250
251
# File 'lib/bundler.rb', line 249

def original_env
  ORIGINAL_ENV.clone
end

.read_file(file) ⇒ Object



391
392
393
# File 'lib/bundler.rb', line 391

def read_file(file)
  File.open(file, "rb", &:read)
end

.require(*groups) ⇒ Object



106
107
108
# File 'lib/bundler.rb', line 106

def require(*groups)
  setup(*groups).require(*groups)
end

.requires_sudo?Boolean

Returns:

  • (Boolean)


320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
# File 'lib/bundler.rb', line 320

def requires_sudo?
  return @requires_sudo if defined?(@requires_sudo_ran)

  sudo_present = which "sudo" if settings.allow_sudo?

  if sudo_present
    # the bundle path and subdirectories need to be writable for Rubygems
    # to be able to unpack and install gems without exploding
    path = bundle_path
    path = path.parent until path.exist?

    # bins are written to a different location on OS X
    bin_dir = Pathname.new(Bundler.system_bindir)
    bin_dir = bin_dir.parent until bin_dir.exist?

    # if any directory is not writable, we need sudo
    files = [path, bin_dir] | Dir[path.join("build_info/*").to_s] | Dir[path.join("*").to_s]
    sudo_needed = files.any? {|f| !File.writable?(f) }
  end

  @requires_sudo_ran = true
  @requires_sudo = settings.allow_sudo? && sudo_present && sudo_needed
end

.reset!Object



441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
# File 'lib/bundler.rb', line 441

def reset!
  @root = nil
  @settings = nil
  @definition = nil
  @setup = nil
  @load = nil
  @locked_gems = nil
  @bundle_path = nil
  @bin_path = nil
  @user_home = nil

  Plugin.reset!

  return unless defined?(@rubygems) && @rubygems
  rubygems.undo_replacements
  rubygems.reset
  @rubygems = nil
end

.rm_rf(path) ⇒ Object



230
231
232
233
234
235
236
237
238
239
240
# File 'lib/bundler.rb', line 230

def rm_rf(path)
  FileUtils.remove_entry_secure(path) if path && File.exist?(path)
rescue ArgumentError
  message = <<EOF
It is a security vulnerability to allow your home directory to be world-writable, and bundler can not continue.
You should probably consider fixing this issue by running `chmod o-w ~` on *nix.
Please refer to http://ruby-doc.org/stdlib-2.1.2/libdoc/fileutils/rdoc/FileUtils.html#method-c-remove_entry_secure for details.
EOF
  File.world_writable?(path) ? Bundler.ui.warn(message) : raise
  raise PathError, "Please fix the world-writable issue with your #{path} directory"
end

.rootObject



203
204
205
206
207
208
209
210
211
# File 'lib/bundler.rb', line 203

def root
  @root ||= begin
              default_gemfile.dirname.expand_path
            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

.ruby_scopeObject



142
143
144
# File 'lib/bundler.rb', line 142

def ruby_scope
  "#{Bundler.rubygems.ruby_engine}/#{Bundler.rubygems.config_map[:ruby_version]}"
end

.rubygemsObject



782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
# File 'lib/bundler/rubygems_integration.rb', line 782

def self.rubygems
  @rubygems ||= if RubygemsIntegration.provides?(">= 2.1.0")
    RubygemsIntegration::MoreFuture.new
  elsif RubygemsIntegration.provides?(">= 1.99.99")
    RubygemsIntegration::Future.new
  elsif RubygemsIntegration.provides?(">= 1.8.20")
    RubygemsIntegration::MoreModern.new
  elsif RubygemsIntegration.provides?(">= 1.8.5")
    RubygemsIntegration::Modern.new
  elsif RubygemsIntegration.provides?(">= 1.8.0")
    RubygemsIntegration::AlmostModern.new
  elsif RubygemsIntegration.provides?(">= 1.7.0")
    RubygemsIntegration::Transitional.new
  elsif RubygemsIntegration.provides?(">= 1.4.0")
    RubygemsIntegration::Legacy.new
  else # Rubygems 1.3.6 and 1.3.7
    RubygemsIntegration::Ancient.new
  end
end

.settingsObject



242
243
244
245
246
# File 'lib/bundler.rb', line 242

def settings
  @settings ||= Settings.new(app_config_path)
rescue GemfileNotFound
  @settings = Settings.new(Pathname.new(".bundle").expand_path)
end

.setup(*groups) ⇒ Object



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
# File 'lib/bundler.rb', line 90

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_pathObject



191
192
193
# File 'lib/bundler.rb', line 191

def specs_path
  bundle_path.join("specifications")
end

.sudo(str) ⇒ Object



367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
# File 'lib/bundler.rb', line 367

def sudo(str)
  SUDO_MUTEX.synchronize do
    prompt = "\n\n" + <<-PROMPT.gsub(/^ {6}/, "").strip + " "
    Your user account isn't allowed to install to the system RubyGems.
    You can cancel this installation and run:

        bundle install --path vendor/bundle

    to install the gems into ./vendor/bundle/, or you can enter your password
    and install the bundled gems to RubyGems using sudo.

    Password:
    PROMPT

    unless @prompted_for_sudo ||= system(%(sudo -k -p "#{prompt}" true))
      raise SudoNotPermittedError,
        "Bundler requires sudo access to install at the moment. " \
        "Try installing again, granting Bundler sudo access when prompted, or installing into a different path."
    end

    `sudo -p "#{prompt}" #{str}`
  end
end

.system_bindirObject



311
312
313
314
315
316
317
318
# File 'lib/bundler.rb', line 311

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 bindir foo`.
  Bundler.settings[:system_bindir] || Bundler.rubygems.gem_bindir
end

.tmp(name = Process.pid.to_s) ⇒ Object



226
227
228
# File 'lib/bundler.rb', line 226

def tmp(name = Process.pid.to_s)
  Pathname.new(Dir.mktmpdir(["bundler", name]))
end

.uiObject



66
67
68
# File 'lib/bundler.rb', line 66

def ui
  (defined?(@ui) && @ui) || (self.ui = UI::Silent.new)
end

.ui=(ui) ⇒ Object



70
71
72
73
# File 'lib/bundler.rb', line 70

def ui=(ui)
  Bundler.rubygems.ui = ui ? UI::RGProxy.new(ui) : nil
  @ui = ui
end

.user_bundle_pathObject



179
180
181
# File 'lib/bundler.rb', line 179

def user_bundle_path
  Pathname.new(user_home).join(".bundle")
end

.user_cacheObject



199
200
201
# File 'lib/bundler.rb', line 199

def user_cache
  user_bundle_path.join("cache")
end

.user_homeObject



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
# File 'lib/bundler.rb', line 146

def user_home
  @user_home ||= begin
    home = Bundler.rubygems.user_home
    warning = "Your home directory is not set properly:"
    if home.nil?
      warning += "\n * It is not set at all"
    elsif !File.directory?(home)
      warning += "\n * `#{home}` is not a directory"
    elsif !File.writable?(home)
      warning += "\n * `#{home}` is not writable"
    else
      return @user_home = Pathname.new(home)
    end

     = Etc.getlogin || "unknown"

    tmp_home = Pathname.new(Dir.tmpdir).join("bundler", "home", )
    begin
      SharedHelpers.filesystem_access(tmp_home, :write) do |p|
        FileUtils.mkdir_p(p)
      end
    rescue => e
      warning += "\n\nBundler also failed to create a temporary home directory at `#{tmp_home}`:\n#{e}"
      raise warning
    end

    warning += "\n\nBundler will use `#{tmp_home}` as your home directory temporarily"

    Bundler.ui.warn(warning)
    tmp_home
  end
end

.which(executable) ⇒ Object



354
355
356
357
358
359
360
361
362
363
364
365
# File 'lib/bundler.rb', line 354

def which(executable)
  if File.file?(executable) && File.executable?(executable)
    executable
  elsif paths = ENV["PATH"]
    quote = '"'.freeze
    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

.with_clean_envObject



282
283
284
# File 'lib/bundler.rb', line 282

def with_clean_env
  with_env(clean_env) { yield }
end

.with_friendly_errorsObject



120
121
122
123
124
125
# File 'lib/bundler/friendly_errors.rb', line 120

def self.with_friendly_errors
  yield
rescue Exception => e
  FriendlyErrors.log_error(e)
  exit FriendlyErrors.exit_status(e)
end

.with_original_envObject



278
279
280
# File 'lib/bundler.rb', line 278

def with_original_env
  with_env(original_env) { yield }
end