class Bundler::Source::Git

# File bundler/source/git.rb, line 34
def self.from_lock(options)
  new(options.merge("uri" => options.delete("remote")))
end

# File bundler/source/git.rb, line 12
def initialize(options)
  @options = options
  @glob = options["glob"] || DEFAULT_GLOB

  @allow_cached = false
  @allow_remote = false

  # Stringify options that could be set as symbols
  %w[ref branch tag revision].each {|k| options[k] = options[k].to_s if options[k] }

  @uri        = URINormalizer.normalize_suffix(options["uri"] || "", :trailing_slash => false)
  @safe_uri   = URICredentialsFilter.credential_filtered_uri(@uri)
  @branch     = options["branch"]
  @ref        = options["ref"] || options["branch"] || options["tag"]
  @submodules = options["submodules"]
  @name       = options["name"]
  @version    = options["version"].to_s.strip.gsub("-", ".pre.")

  @copied     = false
  @local      = false
end

# File bundler/source/git.rb, line 236
def allow_git_ops?
  @allow_remote || @allow_cached
end

# File bundler/source/git.rb, line 224
def app_cache_dirname
  "#{base_name}-#{shortref_for_path(cached_revision || revision)}"
end

# File bundler/source/git.rb, line 194
def cache(spec, custom_path = nil)
  app_cache_path = app_cache_path(custom_path)
  return unless Bundler.feature_flag.cache_all?
  return if path == app_cache_path
  cached!
  FileUtils.rm_rf(app_cache_path)
  git_proxy.checkout if requires_checkout?
  git_proxy.copy_to(app_cache_path, @submodules)
  serialize_gemspecs_in(app_cache_path)
end

# File bundler/source/git.rb, line 216
def cache_path
  @cache_path ||= if Bundler.feature_flag.global_gem_cache?
    Bundler.user_cache
  else
    Bundler.bundle_path.join("cache", "bundler")
  end.join("git", git_scope)
end

# File bundler/source/git.rb, line 232
def current_branch
  git_proxy.current_branch
end

# File bundler/source/git.rb, line 53
def eql?(other)
  other.is_a?(Git) && uri == other.uri && ref == other.ref &&
    branch == other.branch && name == other.name &&
    version == other.version && glob == other.glob &&
    submodules == other.submodules
end

# File bundler/source/git.rb, line 111
def extension_dir_name
  "#{base_name}-#{shortref_for_path(revision)}"
end

# File bundler/source/git.rb, line 49
def hash
  [self.class, uri, ref, branch, name, version, glob, submodules].hash
end

# File bundler/source/git.rb, line 175
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
    Bundler.ui.debug "  * Checking out revision: #{ref}"
    git_proxy.copy_to(install_path, submodules)
    serialize_gemspecs_in(install_path)
    @copied = true
  end

  generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }
  generate_bin(spec, generate_bin_options)

  requires_checkout? ? spec.post_install_message : nil
end

# File bundler/source/git.rb, line 101
def install_path
  @install_path ||= begin
    git_scope = "#{base_name}-#{shortref_for_path(revision)}"

    Bundler.install_path.join(git_scope)
  end
end

# File bundler/source/git.rb, line 205
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 bundler/source/git.rb, line 240
def local?
  @local
end

# File bundler/source/git.rb, line 122
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

  set_local!(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 = cached_revision && cached_revision != revision

  if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(cached_revision)
    raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(cached_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 bundler/source/git.rb, line 94
def name
  File.basename(@uri, ".git")
end

# File bundler/source/git.rb, line 228
def revision
  git_proxy.revision
end

# File bundler/source/git.rb, line 162
def specs(*)
  set_local!(app_cache_path) if has_app_cache? && !local?

  if requires_checkout? && !@copied
    fetch
    git_proxy.copy_to(install_path, submodules)
    serialize_gemspecs_in(install_path)
    @copied = true
  end

  local_specs
end

# File bundler/source/git.rb, line 38
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
  out << "  glob: #{@glob}\n" unless default_glob?
  out << "  specs:\n"
end

# File bundler/source/git.rb, line 62
def to_s
  begin
    at = 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
    else
      current_branch
    end

    rev = "at #{at}@#{shortref_for_display(revision)}"
  rescue GitError
    ""
  end

  specifiers = [rev, glob_for_display].compact
  suffix =
    if specifiers.any?
      " (#{specifiers.join(", ")})"
    else
      ""
    end

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

# File bundler/source/git.rb, line 115
def unlock!
  git_proxy.revision = nil
  options["revision"] = nil

  @unlocked = true
end

# File bundler/source/git.rb, line 278
def base_name
  File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*}, ""), ".git")
end

# File bundler/source/git.rb, line 316
def cached?
  cache_path.exist?
end

# File bundler/source/git.rb, line 312
def cached_revision
  options["revision"]
end

# File bundler/source/git.rb, line 274
def cached_revision_checked_out?
  cached_revision && cached_revision == revision && install_path.exist?
end

# File bundler/source/git.rb, line 294
def default_glob?
  @glob == DEFAULT_GLOB
end

# File bundler/source/git.rb, line 344
def extension_cache_slug(_)
  extension_dir_name
end

# File bundler/source/git.rb, line 324
def fetch
  git_proxy.checkout
rescue GitError => e
  raise unless Bundler.feature_flag.allow_offline_install?
  Bundler.ui.warn "Using cached git data because of network errors:\n#{e}"
end

# File bundler/source/git.rb, line 320
def git_proxy
  @git_proxy ||= GitProxy.new(cache_path, uri, options, cached_revision, self)
end

# File bundler/source/git.rb, line 340
def git_scope
  "#{base_name}-#{uri_hash}"
end

# File bundler/source/git.rb, line 290
def glob_for_display
  default_glob? ? nil : "glob: #{@glob}"
end

# File bundler/source/git.rb, line 266
def has_app_cache?
  cached_revision && super
end

# File bundler/source/git.rb, line 334
def load_gemspec(file)
  stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
  stub.full_gem_path = Pathname.new(file).dirname.expand_path(root).to_s.tap {|x| x.untaint if RUBY_VERSION < "2.7" }
  StubSpecification.from_stub(stub)
end

# File bundler/source/git.rb, line 348
def override_for(path)
  Bundler.settings.local_overrides.key(path)
end

# File bundler/source/git.rb, line 270
def requires_checkout?
  allow_git_ops? && !local? && !cached_revision_checked_out?
end

# File bundler/source/git.rb, line 246
def serialize_gemspecs_in(destination)
  destination = destination.expand_path(Bundler.root) if destination.relative?
  Dir["#{destination}/#{@glob}"].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
    Bundler.rubygems.set_installed_by_version(spec)
    Bundler.rubygems.validate(spec)
    File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
  end
end

# File bundler/source/git.rb, line 260
def set_local!(path)
  @local       = true
  @local_specs = @git_proxy = nil
  @cache_path  = @install_path = path
end

# File bundler/source/git.rb, line 282
def shortref_for_display(ref)
  ref[0..6]
end

# File bundler/source/git.rb, line 286
def shortref_for_path(ref)
  ref[0..11]
end

# File bundler/source/git.rb, line 298
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 = Bundler::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 bundler/source/git.rb, line 332
def validate_spec(_spec); end