class Bundler::Source::Git::GitProxy

def allow?
  @git ? @git.allow_git_ops? : true
end

def allowed_with_path
  return with_path { yield } if allow?
  raise GitError, "The git source #{uri} is not yet checked out. Please run `bundle install` before trying to start your application"
end

def branch
  @branch ||= allowed_with_path do
    git("rev-parse", "--abbrev-ref", "HEAD", :dir => path).strip
  end
end

def capture3_args_for(cmd, dir)
  return ["git", *cmd] unless dir
  if Bundler.feature_flag.bundler_3_mode? || supports_minus_c?
    ["git", "-C", dir.to_s, *cmd]
  else
    ["git", *cmd, { :chdir => dir.to_s }]
  end
end

def capture_and_filter_stderr(*cmd)
  require "open3"
  return_value, captured_err, status = Open3.capture3(*cmd)
  Bundler.ui.warn URICredentialsFilter.credential_filtered_string(captured_err, uri) unless captured_err.empty?
  [return_value, status]
end

def capture_and_ignore_stderr(*cmd)
  require "open3"
  return_value, _, status = Open3.capture3(*cmd)
  [return_value, status]
end

def check_allowed(command)
  command_with_no_credentials = URICredentialsFilter.credential_filtered_string("git #{command.shelljoin}", uri)
  raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
  command_with_no_credentials
end

def checkout
  return if path.exist? && has_revision_cached?
  extra_ref = "#{ref}:#{ref}" if ref && ref.start_with?("refs/")
  Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
  configured_uri = configured_uri_for(uri).to_s
  unless path.exist?
    SharedHelpers.filesystem_access(path.dirname) do |p|
      FileUtils.mkdir_p(p)
    end
    git_retry "clone", configured_uri, path.to_s, "--bare", "--no-hardlinks", "--quiet"
    return unless extra_ref
  end
  with_path do
    git_retry(*["fetch", "--force", "--quiet", "--tags", configured_uri, "refs/heads/*:refs/heads/*", extra_ref].compact, :dir => path)
  end
end

def configured_uri_for(uri)
  if /https?:/ =~ uri
    remote = Bundler::URI(uri)
    config_auth = Bundler.settings[remote.to_s] || Bundler.settings[remote.host]
    remote.userinfo ||= config_auth
    remote.to_s
  else
    uri
  end
end

def contains?(commit)
  allowed_with_path do
    result, status = git_null("branch", "--contains", commit, :dir => path)
    status.success? && result =~ /^\* (.*)$/
  end
end

def copy_to(destination, submodules = false)
  # method 1
  unless File.exist?(destination.join(".git"))
    begin
      SharedHelpers.filesystem_access(destination.dirname) do |p|
        FileUtils.mkdir_p(p)
      end
      SharedHelpers.filesystem_access(destination) do |p|
        FileUtils.rm_rf(p)
      end
      git_retry "clone", "--no-checkout", "--quiet", path.to_s, destination.to_s
      File.chmod(((File.stat(destination).mode | 0o777) & ~File.umask), destination)
    rescue Errno::EEXIST => e
      file_path = e.message[%r{.*?((?:[a-zA-Z]:)?/.*)}, 1]
      raise GitError, "Bundler could not install a gem because it needs to " \
        "create a directory, but a file exists - #{file_path}. Please delete " \
        "this file and try again."
    end
  end
  # method 2
  git_retry "fetch", "--force", "--quiet", "--tags", path.to_s, :dir => destination
  begin
    git "reset", "--hard", @revision, :dir => destination
  rescue GitCommandError => e
    raise MissingGitRevisionError.new(e.command, destination, @revision, URICredentialsFilter.credential_filtered_uri(uri))
  end
  if submodules
    git_retry "submodule", "update", "--init", "--recursive", :dir => destination
  elsif Gem::Version.create(version) >= Gem::Version.create("2.9.0")
    inner_command = "git -C $toplevel submodule deinit --force $sm_path"
    git_retry "submodule", "foreach", "--quiet", inner_command, :dir => destination
  end
end

def find_local_revision
  allowed_with_path do
    git("rev-parse", "--verify", ref || "HEAD", :dir => path).strip
  end
rescue GitCommandError => e
  raise MissingGitRevisionError.new(e.command, path, ref, URICredentialsFilter.credential_filtered_uri(uri))
end

def full_version
  git("--version").sub("git version", "").strip
end

def git(*command, dir: nil)
  command_with_no_credentials = check_allowed(command)
  out, status = SharedHelpers.with_clean_git_env do
    capture_and_filter_stderr(*capture3_args_for(command, dir))
  end
  filtered_out = URICredentialsFilter.credential_filtered_string(out, uri)
  raise GitCommandError.new(command_with_no_credentials, dir || SharedHelpers.pwd, filtered_out) unless status.success?
  filtered_out
end

def git_null(*command, dir: nil)
  check_allowed(command)
  out, status = SharedHelpers.with_clean_git_env do
    capture_and_ignore_stderr(*capture3_args_for(command, dir))
  end
  [URICredentialsFilter.credential_filtered_string(out, uri), status]
end

def git_retry(*command, dir: nil)
  command_with_no_credentials = check_allowed(command)
  Bundler::Retry.new("`#{command_with_no_credentials}` at #{dir || SharedHelpers.pwd}").attempts do
    git(*command, :dir => dir)
  end
end

def has_revision_cached?
  return unless @revision
  with_path { git("cat-file", "-e", @revision, :dir => path) }
  true
rescue GitError
  false
end

def initialize(path, uri, ref, revision = nil, git = nil)
  @path     = path
  @uri      = uri
  @ref      = ref
  @revision = revision
  @git      = git
  raise GitNotInstalledError.new if allow? && !Bundler.git_present?
end

def remove_cache
  FileUtils.rm_rf(path)
end

def revision
  @revision ||= find_local_revision
end

def supports_minus_c?
  @supports_minus_c ||= Gem::Version.new(version) >= Gem::Version.new("1.8.5")
end

def version
  git("--version").match(/(git version\s*)?((\.?\d+)+).*/)[2]
end

def with_path(&blk)
  checkout unless path.exist?
  blk.call
end