module Bundler

# File lib/bundler.rb, line 186
def app_cache
  root.join("vendor/cache")
end

# File lib/bundler.rb, line 180
def app_config_path
  ENV['BUNDLE_APP_CONFIG'] ?
    Pathname.new(ENV['BUNDLE_APP_CONFIG']).expand_path(root) :
    root.join('.bundle')
end

# File lib/bundler.rb, line 103
def bin_path
  @bin_path ||= begin
    path = settings[:bin] || "bin"
    path = Pathname.new(path).expand_path(root).expand_path
    FileUtils.mkdir_p(path)
    path
  end
end

# File lib/bundler.rb, line 98
def bundle_path
  @bundle_path ||= Pathname.new(settings.path).expand_path(root)
end

# File lib/bundler.rb, line 172
def cache
  bundle_path.join("cache/bundler")
end

# File lib/bundler.rb, line 226
def clean_exec(*args)
  with_clean_env { Kernel.exec(*args) }
end

# File lib/bundler.rb, line 222
def clean_system(*args)
  with_clean_env { Kernel.system(*args) }
end

# File lib/bundler.rb, line 317
def clear_gemspec_cache
  @gemspec_cache = {}
end

# File lib/bundler.rb, line 89
def configure
  @configured ||= configure_gem_home_and_path
end

# File lib/bundler.rb, line 230
def default_gemfile
  SharedHelpers.default_gemfile
end

# File lib/bundler.rb, line 234
def default_lockfile
  SharedHelpers.default_lockfile
end

# File lib/bundler.rb, line 143
def definition(unlock = nil)
  @definition = nil if unlock
  @definition ||= begin
    configure
    upgrade_lockfile
    Definition.build(default_gemfile, default_lockfile, unlock)
  end
end

# File lib/bundler.rb, line 139
def environment
  Bundler::Environment.new(root, definition)
end

# File lib/bundler.rb, line 160
def home
  bundle_path.join("bundler")
end

# File lib/bundler.rb, line 164
def install_path
  home.join("gems")
end

# File lib/bundler.rb, line 135
def load
  @load ||= Runtime.new(root, definition)
end

# File lib/bundler.rb, line 294
def load_gemspec(file)
  @gemspec_cache ||= {}
  key = File.expand_path(file)
  spec = ( @gemspec_cache[key] ||= load_gemspec_uncached(file) )
  # Protect against caching side-effected gemspecs by returning a
  # new instance each time.
  spec.dup if spec
end

# File lib/bundler.rb, line 303
def load_gemspec_uncached(file)
  path = Pathname.new(file)
  # Eval the gemspec from its parent directory, because some gemspecs
  # depend on "./" relative paths.
  Dir.chdir(path.dirname.to_s) do
    contents = path.read
    if contents[0..2] == "---" # YAML header
      eval_yaml_gemspec(path, contents)
    else
      eval_gemspec(path, contents)
    end
  end
end

# File lib/bundler.rb, line 288
def load_marshal(data)
  Marshal.load(data)
rescue => e
  raise MarshalError, "#{e.class}: #{e.message}"
end

# File lib/bundler.rb, line 261
def mkdir_p(path)
  if requires_sudo?
    sudo "mkdir -p '#{path}'" unless File.exist?(path)
  else
    FileUtils.mkdir_p(path)
  end
end

# File lib/bundler/gem_path_manipulation.rb, line 2
def self.preserve_gem_path
  original_gem_path = ENV["_ORIGINAL_GEM_PATH"]
  gem_path          = ENV["GEM_PATH"]
  ENV["_ORIGINAL_GEM_PATH"] = gem_path          if original_gem_path.nil? || original_gem_path == ""
  ENV["GEM_PATH"]           = original_gem_path if gem_path.nil? || gem_path == ""
end

# File lib/bundler.rb, line 284
def read_file(file)
  File.open(file, "rb") { |f| f.read }
end

# File lib/bundler.rb, line 131
def require(*groups)
  setup(*groups).require(*groups)
end

# File lib/bundler.rb, line 247
def requires_sudo?
  return @requires_sudo if defined?(@checked_for_sudo)

  path = bundle_path
  path = path.parent until path.exist?
  sudo_present = which "sudo"
  bin_dir = Pathname.new(Bundler.system_bindir)
  bin_dir = bin_dir.parent until bin_dir.exist?

  @checked_for_sudo = true
  sudo_gems = !File.writable?(path) || !File.writable?(bin_dir)
  @requires_sudo = settings.allow_sudo? && sudo_gems && sudo_present
end

# File lib/bundler.rb, line 176
def root
  default_gemfile.dirname.expand_path
end

# File lib/bundler.rb, line 152
def ruby_scope
  "#{Bundler.rubygems.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}"
end

# File lib/bundler.rb, line 194
def settings
  @settings ||= begin
    Settings.new(app_config_path)
  rescue GemfileNotFound
    Settings.new
  end
end

# File lib/bundler.rb, line 112
def setup(*groups)
  # Just return if all groups are already loaded
  return @setup if defined?(@setup)

  definition.validate_ruby!

  if groups.empty?
    # Load all groups, but only once
    @setup = load.setup
  else
    @completed_groups ||= []
    # Figure out which groups haven't been loaded yet
    unloaded = groups - @completed_groups
    # Record groups that are now loaded
    @completed_groups = groups
    unloaded.any? ? load.setup(*groups) : load
  end
end

# File lib/bundler.rb, line 168
def specs_path
  bundle_path.join("specifications")
end

# File lib/bundler.rb, line 280
def sudo(str)
  %xsudo -p 'Enter your password to install the bundled RubyGems to your system: ' #{str}`
end

# File lib/bundler.rb, line 238
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

# File lib/bundler.rb, line 190
def tmp
  user_bundle_path.join("tmp", Process.pid.to_s)
end

# File lib/bundler.rb, line 93
def ui
  @ui ||= UI.new
end

# File lib/bundler.rb, line 156
def user_bundle_path
  Pathname.new(Bundler.rubygems.user_home).join(".bundler")
end

# File lib/bundler.rb, line 269
def which(executable)
  if File.executable?(executable)
    executable
  elsif ENV['PATH']
    path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
      File.executable?(File.join(p, executable))
    end
    path && File.expand_path(executable, path)
  end
end

# File lib/bundler.rb, line 210
def with_clean_env
  with_original_env do
    ENV['MANPATH'] = ENV['BUNDLE_ORIG_MANPATH']
    ENV.delete_if { |k,_| k[0,7] == 'BUNDLE_' }
    if ENV.has_key? 'RUBYOPT'
      ENV['RUBYOPT'] = ENV['RUBYOPT'].sub '-rbundler/setup', ''
      ENV['RUBYOPT'] = ENV['RUBYOPT'].sub "-I#{File.expand_path('..', __FILE__)}", ''
    end
    yield
  end
end

# File lib/bundler/friendly_errors.rb, line 2
  def self.with_friendly_errors
    yield
  rescue Bundler::BundlerError => e
    Bundler.ui.error e.message, :wrap => true
    Bundler.ui.trace e
    exit e.status_code
  rescue LoadError => e
    raise e unless e.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/
    Bundler.ui.error "\nCould not load OpenSSL."
    Bundler.ui.warn "You must recompile Ruby with OpenSSL support or change the sources in your"        "\nGemfile from 'https' to 'http'. Instructions for compiling with OpenSSL"        "\nusing RVM are available at rvm.io/packages/openssl."
    Bundler.ui.trace e
    exit 1
  rescue Interrupt => e
    Bundler.ui.error "\nQuitting..."
    Bundler.ui.trace e
    exit 1
  rescue SystemExit => e
    exit e.status
  rescue Exception => e
    Bundler.ui.error "      Unfortunately, a fatal error has occurred. Please see the Bundler
      troubleshooting documentation at http://bit.ly/bundler-issues. Thanks!

", :wrap => true
    raise e
  end

# File lib/bundler.rb, line 202
def with_original_env
  bundled_env = ENV.to_hash
  ENV.replace(ORIGINAL_ENV)
  yield
ensure
  ENV.replace(bundled_env.to_hash)
end

# File lib/bundler.rb, line 362
def configure_gem_home
  # TODO: This mkdir_p is only needed for JRuby <= 1.5 and should go away (GH #602)
  FileUtils.mkdir_p bundle_path.to_s rescue nil

  ENV['GEM_HOME'] = File.expand_path(bundle_path, root)
  Bundler.rubygems.clear_paths
end

# File lib/bundler.rb, line 346
def configure_gem_home_and_path
  blank_home = ENV['GEM_HOME'].nil? || ENV['GEM_HOME'].empty?
  if settings[:disable_shared_gems]
    ENV['GEM_PATH'] = ''
    configure_gem_home
  elsif blank_home || Bundler.rubygems.gem_dir != bundle_path.to_s
    possibles = [Bundler.rubygems.gem_dir, Bundler.rubygems.gem_path]
    paths = possibles.flatten.compact.uniq.reject { |p| p.empty? }
    ENV["GEM_PATH"] = paths.join(File::PATH_SEPARATOR)
    configure_gem_home
  end

  Bundler.rubygems.refresh
  bundle_path
end

# File lib/bundler.rb, line 331
def eval_gemspec(path, contents)
  eval(contents, TOPLEVEL_BINDING, path.expand_path.to_s)
rescue ScriptError, StandardError => e
  original_line = e.backtrace.find { |line| line.include?(path.to_s) }
  msg  = "There was a #{e.class} while loading #{path.basename}: \n#{e.message}"
  msg << " from\n  #{original_line}" if original_line
  msg << "\n"

  if e.is_a?(LoadError) && RUBY_VERSION >= "1.9"
    msg << "\nDoes it try to require a relative path? That's been removed in Ruby 1.9."
  end

  raise GemspecError, msg
end

# File lib/bundler.rb, line 323
def eval_yaml_gemspec(path, contents)
  # If the YAML is invalid, Syck raises an ArgumentError, and Psych
  # raises a Psych::SyntaxError. See psyched_yaml.rb for more info.
  Gem::Specification.from_yaml(contents)
rescue YamlSyntaxError, ArgumentError, Gem::EndOfYAMLException, Gem::Exception
  eval_gemspec(path, contents)
end

# File lib/bundler.rb, line 370
def upgrade_lockfile
  lockfile = default_lockfile
  if lockfile.exist? && lockfile.read(3) == "---"
    Bundler.ui.warn "Detected Gemfile.lock generated by 0.9, deleting..."
    lockfile.rmtree
  end
end