What are the differences between git remote prune, git prune, git fetch --prune, etc

Question

My situation is this... someone working on the same repo has deleted a branch from his local & remote repo...

Most people who have asked about this kind of problem on Stack Overflow, or other sites have the issue of branches still showing in their remote tracking branch list git branch -a at the bottom:

* master
  develop
  feature_blah
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah
  remotes/origin/random_branch_I_want_deleted

However, in MY situation the branch that shouldn't be there, is local:

* master
  develop
  feature_blah
  random_branch_I_want_deleted
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah

When I do any of the following, it doesn't get removed locally:

$ git prune

I also tried:

$ git remote prune origin
$ git fetch --prune

More useful info: When I check git remote show origin this is how it looks:

* remote origin
Fetch URL: utilities:homeconnections_ui.git
Push  URL: utilities:homeconnections_ui.git
HEAD branch: master
Remote branches:
 master                        tracked
 develop                       tracked
 feature_blah                  tracked
 other123                      tracked
 other444                      tracked
 other999                      tracked
Local branches configured for 'git pull':
 develop                      merges with remote develop
 feature_blah                 merges with remote other999
 master                       merges with remote master
 random_branch_I_want_deleted merges with remote random_branch_I_want_deleted
Local refs configured for 'git push':
 develop         pushes to develop     (local out of date)
 master          pushes to master      (up to date)
 feature_blah    pushes to feature_blah(up to date)

Notice that it's only in the section titled Local branches configured for 'git pull':

Why?

Uxoricide

Thanks, but I'm just curious as to why it might have occurred. – Uxoricide

There was a subtle difference when dealing with branch hierarchy (x/y): it has been fixed (see my answer below) – Sheathe

Answer 1

I don't blame you for getting frustrated about this. The best way to look at is this. There are potentially three versions of every remote branch:

1. The actual branch on the remote repository
   (e.g., remote repo at https://example.com/repo.git, refs/heads/master)
2. Your snapshot of that branch locally (stored under refs/remotes/...)
   (e.g., local repo, refs/remotes/origin/master)
3. And a local branch that might be tracking the remote branch
   (e.g., local repo, refs/heads/master)

Let's start with git prune. This removes objects that are no longer being referenced, it does not remove references. In your case, you have a local branch. That means there's a ref named random_branch_I_want_deleted that refers to some objects that represent the history of that branch. So, by definition, git prune will not remove random_branch_I_want_deleted. Really, git prune is a way to delete data that has accumulated in Git but is not being referenced by anything. In general, it doesn't affect your view of any branches.

git remote prune origin and git fetch --prune both operate on references under refs/remotes/... (I'll refer to these as remote references). It doesn't affect local branches. The git remote version is useful if you only want to remove remote references under a particular remote. Otherwise, the two do exactly the same thing. So, in short, git remote prune and git fetch --prune operate on number 2 above. For example, if you deleted a branch using the git web GUI and don't want it to show up in your local branch list anymore (git branch -r), then this is the command you should use.

To remove a local branch, you should use git branch -d (or -D if it's not merged anywhere). FWIW, there is no git command to automatically remove the local tracking branches if a remote branch disappears.

Mukerji

This does a better job of addressing the overall question by explaining the pertinent differences. It also answers additional questions I had from the one above. – Uxoricide

This command will show a list of all local branches that don't have a corresponding remote branch. You could pipe this to xargs git branch -D, but note that any new branches you've created but never pushed to the server would be deleted, so tread carefully: git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' – Currier

I wrote a script to delete branches already merged into development. I guess it is safer than @JasonWalton's approach. Whatever orphans are left under refs/remotes/... are then deleted by the occasional git-gc. – Interrupted

@Seed No it doesn't. :-( It only deletes the local remote tracking refs. I just double-checked this with version 2.7.0. – Mukerji

I put alias gitcleanup="git fetch --prune && git branch --merged | egrep -v \"(^\*|master|dev)\" | xargs git branch -d" in my ~/.profile file. Then I can just run gitcleanup in the project root to cleanup all remote tracking and local branches. – Cropland

@BlueRaja-DannyPflughoeft Be careful with that approach. For instance, depending on how you do your stable branches, they may appear to be merged into the master branch, and you would end up removing them. It's not a big loss here since you aren't removing them from the server, but if you had any special configuration you set for it then that would be lost when the branch is deleted. – Mukerji

please do not use git branch for scripting and consider this answer: #10610827 – Reglet

To understand your note on 3 versions of every branch: If I have a remote branch named master...1) would this be the 'remote branch'? and I do git checkout -b master upstream/master then 2) would that be 'snapshot'? If those two are right then I don't know what the third one is. Can you explain? – Gwendolin

You can also just delete them manually through the file explorer – Felixfeliza

@Felixfeliza Not entirely true. References can be packed (see the packed-refs file in the .git area), so it's not necessarily a simple matter of deleting them via file explorer. Better to use the commands to make sure both are taken care of correctly. – Mukerji

Answer 2

git remote prune and git fetch --prune do the same thing: deleting the refs to the branches that don't exist on the remote, as you said. The second command connects to the remote and fetches its current branches before pruning.

However it doesn't touch the local branches you have checked out, that you can simply delete with

git branch -d  random_branch_I_want_deleted

Replace -d by -D if the branch is not merged elsewhere

git prune does something different, it purges unreachable objects, those commits that aren't reachable in any branch or tag, and thus not needed anymore.

Johnsen

I know it seems obvious, but git prune looks not only for branches and tags, but all other refs as well. – Glomerate

So in my case, why wouldn't git prune work? Because it does't care about local branches, but remote references? Thanks for the concise info. – Uxoricide

@hvd what kind of refs are there other than branches and tags? – Johnsen

@Uxoricide yes exactly. (supposing you meant git remote prune) – Johnsen

@Johnsen At the very least, reflog, detached HEAD, replacement refs (git replace), but probably more too. (In fairness, I may have made a mistake in calling all of those refs, I'm not sure that's the right term.) – Glomerate

IMO the git naming convention of using "prune" for both object-collection and reference-cleanup is where the confusion sets in. But that's just one of many UI puzzlements, in git. :-) – Camacho

Answer 3

In the event that anyone would be interested. Here's a quick shell script that will remove all local branches that aren't tracked remotely. A word of caution: This will get rid of any branch that isn't tracked remotely regardless of whether it was merged or not.

If you guys see any issues with this please let me know and I'll fix it (etc. etc.)

Save it in a file called git-rm-ntb (call it whatever) on PATH and run:

git-rm-ntb <remote1:optional> <remote2:optional> ...

clean()
{
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  RBRANCHES=()
  while read REMOTE; do
    CURRBRANCHES=($(git ls-remote $REMOTE | awk '{print $2}' | grep 'refs/heads/' | sed 's:refs/heads/::'))
    RBRANCHES=("${CURRBRANCHES[@]}" "${RBRANCHES[@]}")
  done < <(echo "$REMOTES" )
  [[ $RBRANCHES ]] || exit
  LBRANCHES=($(git branch | sed 's:\*::' | awk '{print $1}'))
  for i in "${LBRANCHES[@]}"; do
    skip=
    for j in "${RBRANCHES[@]}"; do
      [[ $i == $j ]] && { skip=1; echo -e "\033[32m Keeping $i \033[0m"; break; }
    done
    [[ -n $skip ]] || { echo -e "\033[31m $(git branch -D $i) \033[0m"; }
  done
}
    
clean $@

Quin

Wouldn't $(git branch -d $i) be safer to only delete merged branches? – Rhapsodize

The safer options are discussed in #7727449 – Vaden

Answer 4

Note that one difference between git remote --prune and git fetch --prune is being fixed, with commit 10a6cc8, by Tom Miller (tmiller) (for git 1.9/2.0, Q1 2014):

When we have a remote-tracking branch named "frotz/nitfol" from a previous fetch, and the upstream now has a branch named "frotz", fetch would fail to remove "frotz/nitfol" with a "git fetch --prune" from the upstream.
git would inform the user to use "git remote prune" to fix the problem.

So: when a upstream repo has a branch ("frotz") with the same name as a branch hierarchy ("frotz/xxx", a possible branch naming convention), git remote --prune was succeeding (in cleaning up the remote tracking branch from your repo), but git fetch --prune was failing.

Not anymore:

Change the way "fetch --prune" works by moving the pruning operation before the fetching operation.
This way, instead of warning the user of a conflict, it automatically fixes it.

---

Another difference:

With Git 2.39 (Q4 2022), "git prune"^(man) may try to iterate over .git/objects/pack for trash files to remove in it, and loudly fail when the directory is missing, which is not necessary.
The command has been taught to ignore such a failure.

... while git fetch --prune would still loudly fail when the directory is missing

See commit 6974765 (19 Nov 2022) by Eric Wong (ele828).
^{(Merged by Junio C Hamano -- gitster -- in commit 7d7ed48, 28 Nov 2022)}

prune: quiet ENOENT on missing directories

^{Signed-off-by: Eric Wong}

$GIT_DIR/objects/pack may be removed to save inodes in shared repositories.
Quiet down prune in cases where either $GIT_DIR/objects or $GIT_DIR/objects/pack is non-existent, but emit the system error in other cases to help users diagnose permissions problems or resource constraints.

So, no "Unable to open directory ..." for git prune when $GIT_DIR/objects or $GIT_DIR/objects/pack is missing.

Sheathe