Eliminar las ramas de seguimiento ya no en remoto

Después del comando

git fetch -p

Elimina las referencias remotas cuando ejecuta

git branch -vv

Mostrará 'ido' como el estado remoto. Por ejemplo,

$ git branch -vv
  master                 b900de9 [origin/master: behind 4] Fixed bug
  release/v3.8           fdd2f4e [origin/release/v3.8: behind 2] Fixed bug
  release/v3.9           0d680d0 [origin/release/v3.9: behind 2] Updated comments
  bug/1234               57379e4 [origin/bug/1234: gone] Fixed bug

Por lo que puede escribir un script simple para eliminar las ramas locales que se han ido controles remotos:

git fetch -p && for branch in `git branch -vv | grep ': gone]' | awk '{print $1}'`; do git branch -D $branch; done

La mayoría de estas respuestas no responden realmente a la pregunta original. Hice un montón de excavación y esta fue la solución más limpia que encontré. Aquí hay una versión un poco más completa de esa respuesta:

1. Echa un vistazo a tu rama predeterminada. Normalmente git checkout master
2. Corre git fetch -p && git branch -vv | awk '/: gone]/{print $1}' | xargs git branch -d

Explicación:

Funciona podando sus ramas de seguimiento y luego borrando las locales que muestran que se han " ido " en git branch -vv.

Notas:

Si su idioma está configurado en algo que no sea inglés, tendrá que cambiar gone a la palabra apropiada. Las ramas que son locales solamente no serán tocadas. Las ramas que se han eliminado en remoto pero no se han fusionado mostrarán una notificación pero no se eliminarán en local. Si también desea eliminarlos, cambie -d a -D.

Parece que la solución está aquí – https://stackoverflow.com/a/1072178/133986

En resumen, git remote prune hace la magia

Encontré la respuesta aquí: ¿Cómo puedo eliminar todas las ramas de git que se han fusionado?

git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

Asegúrate de mantener al maestro

Puede asegurarse de que master, o cualquier otra rama para el caso, no se elimine añadiendo otro grep después de la primera. En ese caso dirías:

git branch --merged | grep -v "\*" | grep -v "YOUR_BRANCH_TO_KEEP" | xargs -n 1 git branch -d

Así que si queríamos mantener master, develop y staging por ejemplo, íbamos a:

git branch --merged | grep -v "\*" | grep -v "master" | grep -v "develop" | grep -v "staging" | xargs -n 1 git branch -d

Haz de esto un alias

Ya que es un poco largo, es posible que desee agregar un alias a su .zshrc o .bashrc. El mío se llama gbpurge (para git branches purge):

alias gbpurge='git branch --merged | grep -v "\*" | grep -v "master" | grep -v "develop" | grep -v "staging" | xargs -n 1 git branch -d'

Luego vuelva a cargar su .bashrc o .zshrc:

. ~/.bashrc

O

. ~/.zshrc

Normalmente no respondería a una pregunta que ya tiene 16 respuestas, pero todas las demás respuestas son incorrectas, y la respuesta correcta es muy simple. La pregunta dice: "¿Hay una manera sencilla de eliminar todas las ramas de seguimiento cuyo equivalente remoto ya no existe?"

Si "simple" significa no frágil, no peligroso, y sin depender de herramientas que no todos los lectores tendrán, entonces la respuesta correcta es: no.

Algunas respuestas son simples, pero no hacen lo que se les pidió. Otros lo hacen lo que se preguntó, pero no son simples: todos se basan en analizar la salida de Git (y la salida de porcelana para arrancar en la mayoría de los casos) a través de comandos de manipulación de texto o lenguajes de scripting, que pueden no estar presentes en todos los sistemas.

Lectura adicional: https://stackoverflow.com/a/20107184/587365 y https://stackoverflow.com/a/26152574/587365

Si desea hacer esto de forma segura, para el caso de uso en la pregunta (basura-recoger ramas de seguimiento que se han eliminado en el servidor, pero todavía existen como ramas locales) y con comandos de Git de alto nivel solamente, tienes que

• git fetch --prune (o git fetch -p, que es un alias, o git prune remote origin que hace lo mismo sin buscar, y probablemente no es lo que quieres la mayor parte del tiempo).
• Tenga en cuenta cualquier rama remota que se notifique como eliminada. O, para encontrarlos más adelante, git branch -v (cualquier rama de seguimiento huérfana se marcará como "[gone]").
• git branch -d [branch_name] en cada seguimiento huérfano branch

Explicación de los antecedentes

Para entender lo que está sucediendo, debe darse cuenta de que, en la situación de seguimiento de ramas, no tiene una rama, sino tres. (Y tener en cuenta que una "rama" es una etiqueta para un puntero a un commit.)

Para una rama feature/X, el repositorio remoto tendrá esta rama y llamar a feature/X. Su repositorio local tiene una rama remotes/origin/feature/X que significa, " Esto es lo que el servidor me dijo que era su rama feature/X, la última vez hablamos, " y finalmente, el repositorio local tiene una rama feature/X que apunta a su última confirmación, y está configurado para "rastrear" remotes/origin/feature/X, lo que significa que puede tirar y empujar para mantener los tres alineados.

En algún momento, alguien ha eliminado el feature/X en el servidor. A partir de ese momento, te quedas con tu feature/X local (que probablemente ya no quieras, ya que el trabajo en la característica X está presumiblemente terminado), y tu remotes/origin/feature/X que es ciertamente inútil porque su único propósito era recordar el estado de la rama del servidor.

Y Git te permitirá limpiar automáticamente el remotes/origin/feature/X redundante that eso es lo que hace el git fetch --prune but pero por alguna razón, no te permite eliminar automáticamente tu propio feature/X... a pesar de que su feature/X todavía contiene la información de seguimiento huérfana, por lo que tiene la información para identificar las ramas de seguimiento anteriores que se han fusionado completamente. (Después de todo, puede darte la información que te permite hacer la operación a mano a ti mismo.)

Elimina todas las ramas que se han fusionado en master, pero no intentes eliminar master:

git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)

O añadir un alias:

alias gitcleanlocal="git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)"

Explicación:

git checkout master checkout master branch

git pull origin master asegúrese de que la rama local tiene todos los cambios remotos combinados

git fetch -p eliminar referencias a ramas remotas que se han eliminado

git branch -d $(git branch master --merged | grep master -v) elimine todas las ramas que se han fusionado en master, pero no intente eliminar master en sí

git fetch -p

Esto eliminará todas las ramas que no se rastrean de forma remota.

Podría ser útil para algunos, una línea simple para borrar todas las ramas locales excepto master y develop

git branch | grep -v "master" | grep -v "develop" | xargs git branch -D

No creo que haya un comando incorporado para hacer esto, pero es seguro hacer lo siguiente:

git checkout master
git branch -d bug-fix-a

Cuando usas -d, git se negará a eliminar la rama a menos que esté completamente fusionada con HEAD o su rama de seguimiento remoto. Por lo tanto, siempre se puede hacer un bucle sobre la salida de git for-each-ref y tratar de eliminar cada rama. El problema con ese enfoque es que sospecho que probablemente no desea que bug-fix-d se elimine solo porque origin/bug-fix-d contiene su historial. En su lugar, usted podría cree un script como el siguiente:

#!/bin/sh

git checkout master &&
for r in $(git for-each-ref refs/heads --format='%(refname:short)')
do
  if [ x$(git merge-base master "$r") = x$(git rev-parse --verify "$r") ]
  then
    if [ "$r" != "master" ]
    then
      git branch -d "$r"
    fi
  fi
done

Advertencia: No he probado este script-use solo con cuidado...

Esto eliminará todas las ramificaciones locales combinadas excepto la referencia maestra local y la que se está utilizando actualmente:

git branch --merged | grep -v "*" | grep -v "master" | xargs git branch -d

Y esto eliminará todas las ramas que ya han sido eliminadas del repositorio remoto referenciado por " origin", pero que todavía están disponibles localmente en " remotes/origin".

git remote prune origin

Solución de Windows

Para Microsoft Windows Powershell:

git checkout master; git remote update origin --prune; git branch -vv | Select-String -Pattern ": gone]" | % { $_.toString().Trim().Split(" ")[0]} | % {git branch -d $_}

Explicación

git checkout master cambia a la rama master

git remote update origin --prune ciruelas pasas ramas remotas

git branch -vv obtiene una salida detallada de todas las ramas (git reference)

Select-String -Pattern ": gone]" obtiene solo los registros donde se han eliminado del control remoto.

% { $_.toString().Trim().Split(" ")[0]} obtener el nombre de la rama

% {git branch -d $_} elimina la rama

La coincidencia de patrones para "gone" en la mayoría de las otras soluciones fue un poco aterradora para mí. Para ser más seguro, utiliza el indicador --format para extraer el estado de seguimiento ascendente de cada rama.

Necesitaba una versión compatible con Windows, por lo que elimina todas las ramas que aparecen como "gone" usando Powershell:

git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)" | 
    ? { $_ -ne "" } | 
    % { git branch -D $_ }

La primera línea enumera el nombre de las ramas locales cuya rama ascendente está "desaparecida". La siguiente línea elimina las líneas en blanco (que son de salida para las ramas que no se han " ido"), a continuación, el nombre de la rama se pasa al comando para eliminar la rama.

Basado en la información anterior, esto funcionó para mí:

git br -d `git br -vv | grep ': gone] ' | awk '{print $1}' | xargs`

Elimina todas las ramas locales con are ': gone] ' en remoto.

Yet-another-answer for the pile, drawing heavily from https://stackoverflow.com/a/48411554/2858703 (que me gusta porque parece eliminar cualquier ambigüedad sobre dónde gone] coincidirá en la salida git branch) pero agregando un * nix bent:

git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)" \
  | sed 's,^refs/heads/,,;/^$/d' \
  | xargs git branch -D

Tengo esto envuelto en un script git-gone en mi camino:

#!/usr/bin/env bash

action() {
  ${DELETE} && xargs git branch -D || cat
}

get_gone() {
  git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)" \
    | sed 's,^refs/heads/,,;/^$/d'

}

main() {
  DELETE=false
  while [ $# -gt 0 ] ; do
    case "${1}" in
      (-[dD] | --delete) DELETE=true ;;
    esac
    shift
  done
  get_gone | action
}

main "${@}"

NB - La opción format format parece ser bastante nueva; necesitaba actualizar git desde la versión 2.10.algo a 2.16.3 para conseguirlo.

grep gone <(git branch -v) | cut -d ' ' -f 3 | xargs git branch -d

El comando anterior se puede usar para obtener ramas que se fusionan y eliminan en remoto y elimina la rama local que ya no está disponible en remoto

Nada de esto era realmente correcto para mí. Quería algo que purgara todas las ramas locales que estaban rastreando una rama remota, en origin, donde la rama remota ha sido eliminada (gone). No quería eliminar las ramas locales que nunca se configuraron para rastrear una rama remota (es decir, mis ramas de desarrollo locales). También quería un simple one-liner que solo use git, u otras herramientas de CLI simples, en lugar de escribir scripts personalizados. Terminé usando un poco de grep y awk para hacer esto simple comando.

Esto es en última instancia lo que terminó en mi ~/.gitconfig:

[alias]
  prune-branches = !git remote prune origin && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs -r git branch -D

Aquí hay un comando git config --global ... para agregar fácilmente esto como git prune-branches:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | xargs -r git branch -d'

NOTA: En el comando config, uso la opción -d para git branch en lugar de -D, como hago en mi configuración real. Utilizo -D porque no quiero que Git se queje de ramas no fusionadas. Es posible que desee esta funcionalidad también. Si es así, simplemente use -D en lugar de -d al final de ese comando de configuración.

Se me ocurrió este guión bash. Siempre mantenga las ramas develop, qa, master.

git-clear() {
  git pull -a > /dev/null

  local branches=$(git branch --merged | grep -v 'develop' | grep -v 'master' | grep -v 'qa' | sed 's/^\s*//')
  branches=(${branches//;/ })

  if [ -z $branches ]; then
    echo 'No branches to delete...'
    return;
  fi

  echo $branches

  echo 'Do you want to delete these merged branches? (y/n)'
  read yn
  case $yn in
      [^Yy]* ) return;;
  esac

  echo 'Deleting...'

  git remote prune origin
  echo $branches | xargs git branch -d
  git branch -vv
}

Esto funcionó para mí:

git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' | xargs git branch -d

No estoy seguro por cuánto tiempo, pero ahora uso git-up, que se encarga de eso.

Hago git up y comienza a rastrear nuevas ramas y elimina las antiguas.

Solo para que quede claro, no está fuera de la caja comando git - https://github.com/aanand/git-up

Por cierto, también esconde dirty tree y hace rebases todavía con solo git up.

Espero que sea útil para alguien

Aquí hay una solución que uso para la cáscara de pescado. Probado en Mac OS X 10.11.5, fish 2.3.0 y git 2.8.3.

function git_clean_branches
  set base_branch develop

  # work from our base branch
  git checkout $base_branch

  # remove local tracking branches where the remote branch is gone
  git fetch -p

  # find all local branches that have been merged into the base branch
  # and delete any without a corresponding remote branch
  set local
  for f in (git branch --merged $base_branch | grep -v "\(master\|$base_branch\|\*\)" | awk '/\s*\w*\s*/ {print $1}')
    set local $local $f
  end

  set remote
  for f in (git branch -r | xargs basename)
    set remote $remote $f
  end

  for f in $local
    echo $remote | grep --quiet "\s$f\s"
    if [ $status -gt 0 ]
      git branch -d $f
    end
  end
end

Algunas notas:

Asegúrese de establecer el base_branch correcto. En este caso utilizo develop como la rama base, pero podría ser cualquier cosa.

Esta parte es muy importante: grep -v "\(master\|$base_branch\|\*\)". Se asegura de que no elimine master o su rama base.

Utilizo git branch -d <branch> como precaución adicional, para no eliminar ninguna rama que no se haya fusionado completamente con upstream o current CABEZA.

Una manera fácil de probar es reemplazar git branch -d $f por echo "will delete $f".

Supongo que también debería agregar: ¡ÚSELO BAJO SU PROPIO RIESGO!

Utilizo un método corto para hacer el truco, te recomiendo que hagas lo mismo ya que podría ahorrar algunas horas y darte más visibilidad

Simplemente agregue el siguiente fragmento en su .bashrc (.bashprofile en macos).

git-cleaner() { git fetch --all --prune && git branch --merged | grep -v -E "\bmaster|preprod|dmz\b" | xargs -n 1 git branch -d ;};

1. Obtener todos los controles remotos
2. Obtener solo ramas fusionadas de git
3. Elimine de esta lista las ramas "protegidas / importantes"
4. Eliminar el resto (por ejemplo, limpiar y fusionar ramas)

Tendrás Que editar el regex grep con el fin de adaptarse a sus necesidades (aquí, evitar maestro, preprod y dmz de eliminación)

Basado en Sugerencia de Git: Eliminar Antiguas Ramas Locales, que se parece a jason.solución de rickman Implementé un comando personalizado para este propósito llamado git gone usando Bash:

$ git gone
usage: git gone [-pndD] [<branch>=origin]
OPTIONS
  -p  prune remote branch
  -n  dry run: list the gone branches
  -d  delete the gone branches
  -D  delete the gone branches forcefully

EXAMPLES
git gone -pn    prune and dry run
git gone -d     delete the gone branches

git gone -pn combina la poda y la lista de las ramas "desaparecidas":

$ git gone -pn
  bport/fix-server-broadcast         b472d5d2b [origin/bport/fix-server-broadcast: gone] Bump modules
  fport/rangepos                     45c857d15 [origin/fport/rangepos: gone] Bump modules

Entonces puedes apretar el gatillo usando git gone -d o git gone -D.

Notas

• La expresión regular que usé es "$BRANCH/.*: gone]" donde $BRANCH normalmente sería origin. Esto probablemente no funciona si tu salida de Git está localizada en francés, etc.
• Sebastian Wiesner también lo portó a Rust para usuarios de Windows. Ese también se llama git gone.

Utilizo este método para poder tener más control.

git branch -D $(git branch | grep -v "master" | grep -v "develop")

Esto es eliminar cualquier rama no nombrada: master o develop.

Esto va a eliminar todas las ramas remotas que no están presentes localmente (en ruby):

bs = `git branch`.split; bs2 = `git branch -r | grep origin`.split.reject { |b| bs.include?(b.split('/')[1..-1].join('/')) }; bs2.each { |b| puts `git  push origin --delete #{b.split('/')[1..-1].join('/')}` }

Explicado:

# local branches
bs = `git branch`.split
# remote branches
bs2 = `git branch -r | grep origin`.split
# reject the branches that are present locally (removes origin/ in front)
bs2.reject! { |b| bs.include?(b.split('/')[1..-1].join('/')) }
# deletes the branches (removes origin/ in front)
bs2.each { |b| puts `git  push origin --delete #{b.split('/')[1..-1].join('/')}` }