Class: Bundler::Source::Git

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 426

def default_glob?
  @glob == DEFAULT_GLOB
end

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 367

def has_app_cache?
  locked_revision && super
end

# File 'lib/bundler/source/git.rb', line 383

def installed?
  git_proxy.installed_to?(install_path)
end

# File 'lib/bundler/source/git.rb', line 274

def local?
  @local
end

# File 'lib/bundler/source/git.rb', line 379

def locked_revision_checked_out?
  locked_revision && locked_revision == revision && installed?
end

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 375

def requires_checkout?
  allow_git_ops? && !local? && !locked_revision_checked_out?
end

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules, :sparse_checkout

# File 'lib/bundler/source/git.rb', line 371

def use_app_cache?
  has_app_cache? && !local?
end

# File 'lib/bundler/source/git.rb', line 258

def app_cache_dirname
  "#{base_name}-#{shortref_for_path(locked_revision || revision)}"
end

# File 'lib/bundler/source/git.rb', line 484

def bare_repo?(path)
  File.exist?(path.join("objects")) && File.exist?(path.join("HEAD"))
end

# File 'lib/bundler/source/git.rb', line 387

def base_name
  File.basename(uri.sub(%r{^(\w://)?([^/:]:)?(//\w*/)?(\w*/)*}, ""), ".git")
end

# File 'lib/bundler/source/git.rb', line 235

def cache(spec, custom_path = nil)
  cache_to(custom_path, try_migrate: false)
end

# File 'lib/bundler/source/git.rb', line 250

def cache_path
  @cache_path ||= if Bundler.settings[:global_gem_cache]
    Bundler.user_cache
  else
    Bundler.bundle_path.join("cache", "bundler")
  end.join("git", git_scope)
end

# File 'lib/bundler/source/git.rb', line 280

def cache_to(custom_path, try_migrate: false)
  return unless Bundler.settings[:cache_all]

  app_cache_path = app_cache_path(custom_path)

  # When several gems share a single git source, this is called once per
  # gem. Copying the repository is expensive for large repos, so skip it
  # if we already populated this cache during the same command.
  return if @cached_app_cache_path == app_cache_path

  migrate = try_migrate ? bare_repo?(app_cache_path) : false

  set_cache_path!(nil) if migrate

  return if cache_path == app_cache_path

  cached!
  FileUtils.rm_rf(app_cache_path)
  git_proxy.checkout if migrate || requires_checkout?
  git_proxy.copy_to(app_cache_path, @submodules)
  serialize_gemspecs_in(app_cache_path)

  @cached_app_cache_path = app_cache_path
end

# File 'lib/bundler/source/git.rb', line 44

def cached!
  return if @allow_cached

  @local_specs = nil
  @allow_cached = true
end

# File 'lib/bundler/source/git.rb', line 305

def checkout
  Bundler.ui.debug "  * Checking out revision: #{ref}"
  if use_app_cache? && !bare_repo?(app_cache_path)
    SharedHelpers.filesystem_access(install_path.dirname) do |p|
      FileUtils.mkdir_p(p)
    end
    FileUtils.cp_r("#{app_cache_path}/.", install_path)
  else
    if use_app_cache? && bare_repo?(app_cache_path)
      Bundler.ui.warn "Installing from cache in old \"bare repository\" format for compatibility. " \
                      "Please run `bundle cache` and commit the updated cache to migrate to the new format and get rid of this warning."
    end

    git_proxy.copy_to(install_path, submodules)
  end
  serialize_gemspecs_in(install_path)
  @copied = true
end

# File 'lib/bundler/source/git.rb', line 266

def current_branch
  git_proxy.current_branch
end

# File 'lib/bundler/source/git.rb', line 79

def eql?(other)
  other.is_a?(Git) && uri == other.uri && ref == other.ref &&
    branch == other.branch && name == other.name &&
    glob == other.glob &&
    submodules == other.submodules &&
    sparse_checkout == other.sparse_checkout
end

# File 'lib/bundler/source/git.rb', line 476

def extension_cache_slug(_)
  extension_dir_name
end

# File 'lib/bundler/source/git.rb', line 143

def extension_dir_name
  "#{base_name}-#{shortref_for_path(revision)}"
end

# File 'lib/bundler/source/git.rb', line 452

def fetch
  git_proxy.checkout
rescue GitError => e
  Bundler.ui.warn "Using cached git data because of network errors:\n#{e}"
end

# File 'lib/bundler/source/git.rb', line 448

def git_proxy
  @git_proxy ||= GitProxy.new(cache_path, uri, options, locked_revision, self)
end

# File 'lib/bundler/source/git.rb', line 472

def git_scope
  "#{base_name}-#{uri_hash}"
end

# File 'lib/bundler/source/git.rb', line 422

def glob_for_display
  default_glob? ? nil : "glob: #{@glob}"
end

# File 'lib/bundler/source/git.rb', line 75

def hash
  [self.class, uri, ref, branch, name, glob, submodules, sparse_checkout].hash
end

# File 'lib/bundler/source/git.rb', line 324

def humanized_ref
  if local?
    path
  elsif user_ref = options["ref"]
    if /\A[a-z0-9]{4,}\z/i.match?(ref)
      shortref_for_display(user_ref)
    else
      user_ref
    end
  elsif ref
    ref
  end
end

# File 'lib/bundler/source/git.rb', line 109

def identifier
  uri_with_specifiers([humanized_ref, locked_revision, glob_for_display])
end

# File 'lib/bundler/source/git.rb', line 89

def include?(other)
  other.is_a?(Git) && uri == other.uri &&
    name == other.name &&
    glob == other.glob &&
    submodules == other.submodules &&
    sparse_checkout == other.sparse_checkout
end

# File 'lib/bundler/source/git.rb', line 211

def install(spec, options = {})
  return if Bundler.settings[:no_install]
  force = options[:force]

  print_using_message "Using #{version_message(spec, options[:previous_spec])} from #{self}"

  if (requires_checkout? && !@copied) || force
    checkout
  end

  generate_bin_options = { disable_extensions: !spec.missing_extensions?, build_args: options[:build_args] }
  generate_bin(spec, generate_bin_options)

  requires_checkout? ? spec.post_install_message : nil
end

# File 'lib/bundler/source/git.rb', line 133

def install_path
  @install_path ||= begin
    git_scope = "#{base_name}-#{shortref_for_path(revision)}"

    Bundler.install_path.join(git_scope)
  end
end

# File 'lib/bundler/source/git.rb', line 461

def load_gemspec(file)
  # Expand the path before the chdir below, since resolving it inside the
  # block would base it on the gemspec directory instead of `root`.
  gemspec_path = Pathname.new(file).expand_path(root)
  SharedHelpers.chdir(gemspec_path.dirname.to_s) do
    stub = Gem::StubSpecification.gemspec_stub(gemspec_path.to_s, install_path.parent, install_path.parent)
    stub.full_gem_path = gemspec_path.dirname.to_s
    StubSpecification.from_stub(stub)
  end
end

# File 'lib/bundler/source/git.rb', line 239

def load_spec_files
  super
rescue PathError => e
  Bundler.ui.trace e
  raise GitError, "#{self} is not yet checked out. Run `bundle install` first."
end

# File 'lib/bundler/source/git.rb', line 154

def local_override!(path)
  return false if local?

  original_path = path
  path = Pathname.new(path)
  path = path.expand_path(Bundler.root) unless path.relative?

  unless branch || Bundler.settings[:disable_local_branch_check]
    raise GitError, "Cannot use local override for #{name} at #{path} because " \
      ":branch is not specified in Gemfile. Specify a branch or run " \
      "`bundle config unset local.#{override_for(original_path)}` to remove the local override"
  end

  unless path.exist?
    raise GitError, "Cannot use local override for #{name} because #{path} " \
      "does not exist. Run `bundle config unset local.#{override_for(original_path)}` to remove the local override"
  end

  @local = true
  set_paths!(path)

  # Create a new git proxy without the cached revision
  # so the Gemfile.lock always picks up the new revision.
  @git_proxy = GitProxy.new(path, uri, options)

  if current_branch != branch && !Bundler.settings[:disable_local_branch_check]
    raise GitError, "Local override for #{name} at #{path} is using branch " \
      "#{current_branch} but Gemfile specifies #{branch}"
  end

  changed = locked_revision && locked_revision != revision

  if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(locked_revision)
    raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(locked_revision)} " \
      "but the current branch in your local override for #{name} does not contain such commit. " \
      "Please make sure your branch is up to date."
  end

  changed
end

# File 'lib/bundler/source/git.rb', line 444

def locked_revision
  options["revision"]
end

# File 'lib/bundler/source/git.rb', line 227

def migrate_cache(custom_path = nil, local: false)
  if local
    cache_to(custom_path, try_migrate: false)
  else
    cache_to(custom_path, try_migrate: true)
  end
end

# File 'lib/bundler/source/git.rb', line 126

def name
  File.basename(@uri, ".git")
end

# File 'lib/bundler/source/git.rb', line 403

def normalize_sparse_checkout(options)
  return unless options["sparse_checkout"]

  dirs = Array(options["sparse_checkout"])
  unless dirs.any? && dirs.all? {|dir| dir.is_a?(String) && !dir.empty? }
    raise GemfileError, "The :sparse_checkout option must be a directory or an array of directories, " \
      "but #{options["sparse_checkout"].inspect} was given"
  end

  options["sparse_checkout"] = dirs
end

# File 'lib/bundler/source/git.rb', line 480

def override_for(path)
  Bundler.settings.local_overrides.key(path)
end

# File 'lib/bundler/source/git.rb', line 141

alias_method :path, :install_path

# File 'lib/bundler/source/git.rb', line 37

def remote!
  return if @allow_remote

  @local_specs = nil
  @allow_remote = true
end

# File 'lib/bundler/source/git.rb', line 262

def revision
  git_proxy.revision
end

# File 'lib/bundler/source/git.rb', line 338

def serialize_gemspecs_in(destination)
  destination = destination.expand_path(Bundler.root) if destination.relative?
  SharedHelpers.glob_files_in_dir(@glob, destination.to_s).each do |spec_path|
    # Evaluate gemspecs and cache the result. Gemspecs
    # in git might require git or other dependencies.
    # The gemspecs we cache should already be evaluated.
    spec = Bundler.load_gemspec(spec_path)
    next unless spec
    spec.installed_by_version = Gem::VERSION
    Bundler.rubygems.validate(spec)
    File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
  end
end

# File 'lib/bundler/source/git.rb', line 357

def set_cache_path!(path)
  @git_proxy = nil
  @cache_path = path
end

# File 'lib/bundler/source/git.rb', line 362

def set_install_path!(path)
  @local_specs = nil
  @install_path = path
end

# File 'lib/bundler/source/git.rb', line 352

def set_paths!(path)
  set_cache_path!(path)
  set_install_path!(path)
end

# File 'lib/bundler/source/git.rb', line 391

def shortref_for_display(ref)
  ref[0..6]
end

# File 'lib/bundler/source/git.rb', line 395

def shortref_for_path(ref)
  shortref = ref[0..11]
  return shortref unless @sparse_checkout

  # Checkouts of the same revision with different cones hold different files
  "#{shortref}-#{Bundler::Digest.sha1(@sparse_checkout.join("\n"))[0..7]}"
end

# File 'lib/bundler/source/git.rb', line 415

def sparse_checkout_glob
  return unless @sparse_checkout

  dirs = @sparse_checkout.size == 1 ? @sparse_checkout.first : "{#{@sparse_checkout.join(",")}}"
  "#{dirs}/#{DEFAULT_GLOB}"
end

# File 'lib/bundler/source/git.rb', line 195

def specs(*)
  set_cache_path!(app_cache_path) if use_app_cache?

  if requires_checkout? && !@copied
    Plugin.hook(Plugin::Events::GIT_BEFORE_FETCH, self)
    begin
      fetch unless use_app_cache?
      checkout
    ensure
      Plugin.hook(Plugin::Events::GIT_AFTER_FETCH, self)
    end
  end

  local_specs
end

# File 'lib/bundler/source/git.rb', line 67

def to_gemfile
  specifiers = %w[ref branch tag submodules glob sparse_checkout].map do |opt|
    "#{opt}: #{options[opt]}" if options[opt]
  end

  uri_with_specifiers(specifiers)
end

# File 'lib/bundler/source/git.rb', line 55

def to_lock
  out = String.new("GIT\n")
  out << "  remote: #{@uri}\n"
  out << "  revision: #{revision}\n"
  %w[ref branch tag submodules].each do |opt|
    out << "  #{opt}: #{options[opt]}\n" if options[opt]
  end
  @sparse_checkout&.each {|dir| out << "  sparse_checkout: #{dir}\n" }
  out << "  glob: #{@glob}\n" unless default_glob?
  out << "  specs:\n"
end

# File 'lib/bundler/source/git.rb', line 97

def to_s
  begin
    at = humanized_ref
    at = "#{at}@" if at
    rev = "at #{at}#{shortref_for_display(revision)}"
  rescue GitError
    ""
  end

  uri_with_specifiers([rev, glob_for_display])
end

# File 'lib/bundler/source/git.rb', line 147

def unlock!
  git_proxy.revision = nil
  options["revision"] = nil

  @unlocked = true
end

# File 'lib/bundler/source/git.rb', line 430

def uri_hash
  if %r{^\w://(\w@)?}.match?(uri)
    # Downcase the domain component of the URI
    # and strip off a trailing slash, if one is present
    input = Gem::URI.parse(uri).normalize.to_s.sub(%r{/$}, "")
  else
    # If there is no URI scheme, assume it is an ssh/git URI
    input = uri
  end
  # We use SHA1 here for historical reason and to preserve backward compatibility.
  # But a transition to a simpler mangling algorithm would be welcome.
  Bundler::Digest.sha1(input)
end

# File 'lib/bundler/source/git.rb', line 113

def uri_with_specifiers(specifiers)
  specifiers.compact!

  suffix =
    if specifiers.any?
      " (#{specifiers.join(", ")})"
    else
      ""
    end

  "#{@safe_uri}#{suffix}"
end

# File 'lib/bundler/source/git.rb', line 459

def validate_spec(_spec); end