Cómo podar ramas de rastreo locales que ya no existen en remotos

Con git remote prune originpuedo eliminar las ramas locales que ya no están en el control remoto.

Pero también quiero eliminar las ramas locales que se crearon a partir de esas ramas remotas (sería bueno verificar si están sin fusionar).

¿Cómo puedo hacer esto?

Después de la poda, puede obtener la lista de ramas remotas con git branch -r. La lista de ramas con su rama de seguimiento remoto se puede recuperar con git branch -vv. Entonces, utilizando estas dos listas, puede encontrar las ramas de seguimiento remoto que no están en la lista de controles remotos.

Esta línea debería hacer el truco (requiere basho zshno funcionará con el shell Bourne estándar):

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

Esta cadena obtiene la lista de ramas remotas y la pasa a egreptravés de la entrada estándar. Y filtra las ramas que tienen una rama de seguimiento remota (usando git branch -vvy filtrando las que tienen origin) y luego obtiene la primera columna de esa salida, que será el nombre de la rama. Finalmente pasando todos los nombres de rama en el comando borrar rama.

Como está utilizando la -dopción, no eliminará las ramas que no se han fusionado en la rama en la que se encuentra cuando ejecuta este comando.

También recuerde que git fetch --prune primero deberá ejecutarlo , de lo contrario git branch -raún verá las ramas remotas.

Si desea eliminar todas las sucursales locales que ya están fusionadas en master, puede usar el siguiente comando:

git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

Más información .

En medio de la información presentada por git help fetch, hay este pequeño artículo:

 -p, --prune
        After fetching, remove any remote-tracking branches which no longer exist on the remote.

Así que tal vez, git fetch -p ¿es lo que estás buscando?

EDITAR: Ok, para aquellos que aún debaten esta respuesta 3 años después del hecho, aquí hay un poco más de información sobre por qué presenté esta respuesta ...

Primero, el OP dice que quieren "eliminar también aquellas ramas locales que se crearon a partir de esas ramas remotas [que ya no están en el remoto]". Esto no es inequívocamente posible en git. Aquí hay un ejemplo.

Digamos que tengo un repositorio en un servidor central, y tiene dos ramas, llamadas Ay B. Si clono ese repositorio en mi sistema local, mi clon tendrá referencias locales (aún no ramas reales) llamadas origin/Ay origin/B. Ahora digamos que hago lo siguiente:

git checkout -b A origin/A
git checkout -b Z origin/B
git checkout -b C <some hash>

Los hechos pertinentes aquí son que por alguna razón elegí crear una sucursal en mi repositorio local que tenga un nombre diferente a su origen, y también tengo una sucursal local que (todavía) no existe en el repositorio de origen.

Ahora supongamos que elimino las ramas Ay Ben el repositorio remoto y actualizo mi repositorio local ( git fetchde alguna forma), lo que hace que mis referencias locales origin/Ay origin/Bdesaparezcan. Ahora, mi repo local tiene tres ramas todavía, A, Z, y C. Ninguno de estos tiene una rama correspondiente en el repositorio remoto. Dos de ellos fueron "creados a partir de ... ramas remotas", pero incluso si sé que solía haber una rama llamada Ben el origen, no tengo forma de saber que Zse creó a partir deB, porque fue renombrado en el proceso, probablemente por una buena razón. Entonces, realmente, sin algún proceso externo que registre metadatos de origen de rama, o un ser humano que conozca la historia, es imposible saber cuál de las tres ramas, si es que hay alguna, el OP está apuntando para su eliminación. Sin cierta información externa que gitno se mantiene automáticamente para usted,git fetch -p es lo más cercano posible, y cualquier método automático para intentar literalmente lo que solicitó el OP corre el riesgo de eliminar demasiadas ramas o de perder algunas que el OP de otro modo quiere eliminar

También hay otros escenarios, como si creo tres ramas separadas origin/Apara probar tres enfoques diferentes de algo, y luego origin/Adesaparece. Ahora tengo tres ramas, que obviamente no pueden coincidir con el nombre, pero se crearon a partir de ellas origin/A, por lo que una interpretación literal de la pregunta de los OP requeriría eliminar las tres. Sin embargo, eso puede no ser deseable, si incluso pudiera encontrar una forma confiable de combinarlos ...

Esto eliminará las ramas locales para las que se han podado las ramas de seguimiento remoto. (¡Asegúrate de estar en la masterrama!)

git checkout master
git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -d

Detalles:

• git branch -vv muestra "desaparecido" para las sucursales locales que el control remoto ha sido podado.

  mybranch abc1234 [origin/mybranch: gone] commit comments
  

• -dcomprobará si se ha fusionado ( -Dlo eliminará independientemente)

  error: The branch 'mybranch' is not fully merged.
  

Se puede configurar Git para eliminar automáticamente las referencias a las ramas remotas eliminadas al buscar:

git config --global fetch.prune true

Al llamar git fetcho git pulldespués, las referencias a sucursales remotas eliminadas se eliminan automáticamente.

Hay un paquete ordenado de NPM que lo hace por usted (y debería funcionar multiplataforma).

Instalarlo con: npm install -g git-removed-branches

Y luego git removed-branchesle mostrará todas las ramas locales obsoletas, y git removed-branches --pruneeliminarlas realmente.

Más información aquí.

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 maestra

git remote update origin --prune ciruelas pasas ramas remotas

git branch -vvobtiene una salida detallada de todas las ramas ( referencia de git )

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

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

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

Enumerará las ramas locales cuya rama de seguimiento remoto se elimina de

$ git remote prune origin --dry-run

Si desea desreferenciar estas ramas locales de las locales que no se rastrean

$ git remote prune origin

Como señala @tzacks ... hay un paquete npm que es útil para esto. Solo haz:

npx git-removed-branches --prune

(Hubiera comentado pero no suficiente reputación)

Si usa Windows y Powershell, puede usar lo siguiente para eliminar todas las ramas locales que se han fusionado en la rama actualmente desprotegida:

git branch --merged | ? {$_[0] -ne '*'} | % {$_.trim()} | % {git branch -d $_}

Explicación

• Enumera la rama actual y las ramas que se han fusionado en ella.
• Filtra la rama actual
• Limpia los espacios iniciales o finales de la gitsalida para cada nombre de rama restante
• Elimina las sucursales locales fusionadas.

Vale la pena ejecutarlo git branch --mergedsolo primero para asegurarse de que solo eliminará lo que espera.

(Portado / automatizado de http://railsware.com/blog/2014/08/11/git-housekeeping-tutorial-clean-up-outdated-branches-in-local-and-remote-repositories/ .)

Una línea más corta y segura:

git branch -d $(git branch --merged | cut -c 3- | grep -v master)

Asegúrese de pagar a la rama que aún no está fusionada, antes de ejecutarla. Porque no puede eliminar la rama en la que está registrado actualmente.

Quería algo que purgara todas las sucursales locales que estaban rastreando una rama remota, en origin, donde se ha eliminado la rama remota ( gone). No quería eliminar ramas locales que nunca se configuraron para rastrear una rama remota (es decir, mis ramas de desarrollo local). Además, quería una línea simple que solo use git, u otras herramientas simples de CLI, en lugar de escribir scripts personalizados. Terminé usando un poco de grepy awkpara hacer este comando simple, luego lo agregué como un alias 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 git config --global ...comando para agregar esto fácilmente 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: El uso de la -Dbandera git branchpuede ser muy peligroso. Entonces, en el comando de configuración anterior, uso la -dopción paragit branch lugar de -D; Yo uso -Den mi configuración actual. Lo uso -Dporque no quiero escuchar a Git quejarse de ramas no fusionadas, solo quiero que se vayan. Es posible que también desee esta funcionalidad. Si es así, simplemente use en -Dlugar de -dal final de ese comando de configuración.

Para eliminar ramas remotas:

$git remote prune origin

Para eliminar sucursales locales que ya están fusionadas:

$git branch -D $(git branch --merged)

No parece haber una línea segura, demasiados casos extremos (como una rama que tiene "maestro" como parte de su nombre, etc.). Lo más seguro es estos pasos:

1. git branch -vv | grep 'gone]' > stale_branches.txt
2. vea el archivo y elimine las líneas de las ramas que desea conservar (como la rama maestra); no necesita editar el contenido de ninguna línea
3. awk '{print $1}' stale_branches.txt | xargs git branch -d

Según las respuestas anteriores, estoy usando este revestimiento más corto:

git remote prune origin | awk 'BEGIN{FS="origin/"};/pruned/{print $2}' | xargs -r git branch -d

Además, si ya podaste y tienes ramas colgantes locales, entonces esto las limpiará:

git branch -vv | awk '/^ .*gone/{print $1}' | xargs -r git branch -d

No estoy seguro de cómo hacerlo todo a la vez, pero git git branch -d <branchname> eliminará una rama local SOLAMENTE si está completamente combinada. Tenga en cuenta las minúsculas d.

git branch -D <branchname> (tenga en cuenta que la D mayúscula) eliminará una sucursal local independientemente de su estado combinado.

Puedes usar este comando:

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

Git Clean: Eliminar ramas ya fusionadas, incluido el desglose del comando

Basado en las respuestas anteriores, vine con esta solución de una línea:

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

Usando una variante en la respuesta de @ wisbucky, agregué lo siguiente como un alias a mi ~/.gitconfigarchivo:

pruneitgood = "!f() { \
    git remote prune origin; \
    git branch -vv | perl -nae 'system(qw(git branch -d), $F[0]) if $F[3] eq q{gone]}'; \
}; f"

Con esto, un simple git pruneitgoodlimpiará las sucursales locales y remotas que ya no son necesarias después de las fusiones.

La versión Powershell de git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

git branch --merged master | %{ if($_ -notmatch '\*.*master'){ git branch -d "$($_.Trim())" }}

Esto eliminará cualquier sucursal local que se haya fusionado en maestra, mientras usted esté en la sucursal maestra .

git checkout master para cambiar

La variante de Schleis no funciona para mí (Ubuntu 12.04), así que permítanme proponer mis variantes (claras y brillantes :):

Variante 1 (preferiría esta opción):

git for-each-ref --format='%(refname:short) %(upstream)' refs/heads/ | awk '$2 !~/^refs\/remotes/' | xargs git branch -D 

Variante 2:

a. Funcionamiento en seco:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | awk '{print "git branch -D " $1}'

si. Eliminar ramas:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | xargs git branch -D

La siguiente es una adaptación de la respuesta de @ wisbucky para los usuarios de Windows:

for /f "tokens=1" %i in ('git branch -vv ^| findstr ": gone]"') DO git branch %i -d

Uso posh-git y desafortunadamente a PS no le gusta el desnudo for, así que creé un script de comando simple llamado PruneOrphanBranches.cmd:

@ECHO OFF
for /f "tokens=1" %%i in ('git branch -vv ^| findstr ": gone]"') DO CALL :ProcessBranch %%i %1

GOTO :EOF

:ProcessBranch
IF /I "%2%"=="-d" (
    git branch %1 %2
) ELSE (
    CALL :OutputMessage %1
)
GOTO :EOF

:OutputMessage
ECHO Will delete branch [%1] 
GOTO :EOF

:EOF

Llámelo sin parámetros para ver una lista y luego llámelo con "-d" para realizar la eliminación real o "-D" para cualquier rama que no esté completamente fusionada pero que quiera eliminar de todos modos.

Pruebe esto en git bash, para buscar y podar referencias a ramas eliminadas, y luego pode las ramas locales que estaban rastreando las eliminadas:

git fetch -p && git branch -d `git branch -vv | grep ': gone]' | awk '{print $1}' | xargs`

Recuerde verificar primero una rama que no se eliminará, para que no bloquee la eliminación de la rama.

He convertido la respuesta aceptada en un guión robusto. Lo encontrarás en mi repositorio de git-extensions .

$ git-prune --help
Remove old local branches that do not exist in <remote> any more.
With --test, only print which local branches would be deleted.
Usage: git-prune [-t|--test|-f|--force] <remote>

Llegué a esta página buscando la respuesta para "¿cómo elimino sucursales localmente desprotegidas que ya no tienen una sucursal ascendente?"

Tampoco me importaba si la sucursal local se había fusionado o no todavía, ya que la tubería git branch -dsimplemente advertirá en lugar de eliminar sucursales locales no fusionadas .

git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3 | egrep -v -f /dev/fd/0 <(git branch -a | grep -v origin) | grep branch_prefix_that_I_care_about | xargs git branch -d

# translation
# git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3
## this finds all remote branch names minus the "remote/origin/" part
#
# <(git branch -a | grep -v origin)
## this finds all local branch names and redirects it into the previous command
#
# egrep -v -f /dev/fd/0 STUFF
## this is doing some weird magic that I'm grokking as "take the set difference from whatever was piped in"
#
#
# overall translation: (STUFF TO CONSIDER) | egrep magic <(STUFF TO REMOVE FROM CONSIDERATION) | do cool things with resulting stuff

En Powershell :

git branch -D (git branch --merged |% { $_.trim() } )

Aquí está mi solución:

git fetch -p
git branch -vv | grep ": gone" | awk '{print $1}' | xargs git branch -d

• -p es eliminar cualquier referencia de seguimiento remoto que ya no exista en el control remoto. Entonces, el primer paso eliminará las referencias a ramas remotas.

• -vv es para mostrar la línea de asunto sha1 y commit para cada encabezado, junto con la relación con la rama ascendente (si la hay). El segundo paso obtendrá todas las ramas locales y el comando grep filtrará las ramas que se han eliminado.

Eliminar cualquier rama que no esté actualizada con master

git co master && git branch | sed s/\*/\ / | xargs git branch -d 2> /dev/null

Estoy bastante seguro de que eso git remote prune origines lo que quieres.

Puede ejecutarlo git remote prune origin --dry-runpara ver qué haría sin realizar ningún cambio.

¿Usando la GUI? Procedimiento manual, pero rápido y fácil.

$ git gui

Seleccione "Rama -> Eliminar". Puede seleccionar múltiples ramas con Ctrl-clic (Windows) y eliminarlas todas.