tag - Rastree todas las sucursales remotas de git como sucursales locales

git tag name (13)

Aquí está mi one-liner que uso (en un shell bash, probado con msysgit1.7.4):

Para copiar y pegar:

remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk ''{gsub(/^[^//]+///,"",$1); print $1}''`; do git branch --set-upstream-to $remote/$brname $brname; done

Para más lectura:

remote=origin ; // put here the name of the remote you want for brname in ` git branch -r | grep $remote | grep -v master | grep -v HEAD | awk ''{gsub(/^[^//]+///,"",$1); print $1}'' `; do git branch --set-upstream-to $remote/$brname $brname; done

solo seleccionará ramas ascendentes desde el control remoto que especifique en la variable remote (puede ser '' origin '' o cualquier nombre que haya establecido para uno de los controles remotos de su repositorio actual de Git).
extraerá el nombre de la rama: origin/a/Branch/Name => a/Branch/Name través de la expresión awk .
establecerá la rama ascendente a través de --set-upstream-to (o -u ) , no --track :
La ventaja es que, si la rama ya existe, no fallará y no cambiará el origen de la sucursal, solo configurará la configuración branch.xxx.(remote|merge) .
branch.aBranchName.remote=origin branch.aBranchName.merge=refs/heads/a/Branch/Name

Ese comando creará ramas locales para todas las sucursales ascendentes remotas y establecerá su configuración remota y de fusión en esa rama remota.

El seguimiento de una sola sucursal remota como una sucursal local es bastante sencillo.

$ git checkout --track -b ${branch_name} origin/${branch_name}

Al empujar todas las sucursales locales hasta el control remoto, también es fácil crear nuevas sucursales remotas según sea necesario.

$ git push --all origin

Quiero hacer lo contrario. Si tengo X cantidad de ramas remotas en una sola fuente:

$ git branch -r branch1 branch2 branch3 . . .

¿Puedo crear ramas de seguimiento locales para todas las sucursales remotas sin necesidad de crearlas manualmente? Diga algo como:

$ git checkout --track -b --all origin

He buscado en Google y RTM, pero he subido hasta ahora.

Aquí está mi solución del comando de BASH referido por @tjmcewan:

for remote in `git branch -r | grep -v /HEAD `; do git branch --track ${remote/"origin/"/""}; done

Mi objetivo es resolver el problema de que todas las ramas creadas tendrán "origen /" como el comienzo del nombre, porque probé que $ las variables remotas aún incluyen "origen /":

for remote in `git branch -r | grep -v /HEAD`; do echo $remote ; done

En caso de que ya tenga algunas sucursales desprotegidas y desee

echa un vistazo a todas las ramas restantes desde el control remoto
asegúrese de que todas las sucursales locales rastreen las sucursales remotas

puede usar el siguiente script compatible con bash y zsh:

git branch -r | while read b; do if git branch | grep -q " ${b##*/}$"; then git branch --set-upstream ${b##*/} $b; else git branch --track ${b##*/} $b; fi; done

La mayoría de las respuestas están complicando el análisis de la salida de git branch -r . Puede usar el siguiente ciclo for para crear las ramas de rastreo contra todas las ramas en el control remoto como ese.

Ejemplo

Digamos que tengo estas ramas remotas.

$ git branch -r origin/HEAD -> origin/master origin/development origin/integration origin/master origin/production origin/staging

Confirma que no estamos rastreando nada más que el dominio ya, localmente:

$ git branch -l # or using just git branch * master

Puedes usar este delineador para crear las ramas de seguimiento:

$ for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done Branch development set up to track remote branch development from origin. Branch integration set up to track remote branch integration from origin. Branch production set up to track remote branch production from origin. Branch staging set up to track remote branch staging from origin.

Ahora confirma:

$ git branch development integration * master production staging

Para eliminarlos:

$ git br -D production development integration staging Deleted branch production (was xxxxx). Deleted branch development (was xxxxx). Deleted branch integration (was xxxxx). Deleted branch staging (was xxxxx).

Si usa el -vv a la git branch , puede confirmar:

$ git br -vv development xxxxx [origin/development] commit log msg .... integration xxxxx [origin/integration] commit log msg .... * master xxxxx [origin/master] commit log msg .... production xxxxx [origin/production] commit log msg .... staging xxxxx [origin/staging] commit log msg ....

Desglose de for loop

El ciclo básicamente llama al comando git branch -r , filtrando cualquier HEAD o ramas principales en la salida usando grep -vE "HEAD|master" . Para obtener los nombres de solo las ramas menos el origin/ subcadena, utilizamos la manipulación de cadena de Bash ${var#stringtoremove} . Esto eliminará la cadena, "stringtoremove" de la variable $var . En nuestro caso, estamos eliminando el origin/ la cadena origin/ de la variable $i .

NOTA: Alternativamente puede usar git checkout --track ... para hacer esto también:

$ for i in $(git branch -r | grep -vE "HEAD|master" | sed ''s/^[ ]/+//''); do git checkout --track $i; done

Pero particularmente no me importa este método, ya que lo está cambiando entre las sucursales mientras realiza un pago. Cuando termine, lo dejará en la última rama que creó.

Referencias

La respuesta dada por Otto es buena, pero todas las ramas creadas tendrán "origen /" como el comienzo del nombre. Si solo desea que la última parte (después del último /) sea el nombre de su rama resultante, utilice esto:

for remote in `git branch -r | grep -v /HEAD`; do git checkout --track $remote ; done

También tiene el beneficio de no advertirte acerca de referencias ambiguas.

Para hacer lo mismo que la respuesta de tjmcewan pero en Windows, llámalo desde un archivo por lotes :

for /f "delims=" %%r in (''git branch -r ^| grep -v master'') do git checkout --track %%r

O esto desde la línea de comando :

for /f "delims=" %r in (''git branch -r ^| grep -v master'') do git checkout --track %r

Podrías escribir eso fácilmente, pero no sé cuándo sería valioso. Esas ramas rápidamente se quedarían atrás, y tendrías que actualizarlas todo el tiempo.

Las sucursales remotas se mantendrán actualizadas automáticamente, por lo que es más fácil crear la sucursal local en el punto donde realmente desea trabajar en ella.

Si quieres usar powershell y tu control remoto se llama origen. Entonces esto funciona.

git fetch git branch -r | %{$_ -replace " origin/"} | %{git branch --track $_ "origin/$_"}

Usando bash:

después de git 1.9.1

for i in `git branch -a | grep remote | grep -v HEAD | grep -v master`; do git branch --track ${i#remotes/origin/} $i; done

créditos: Val Blant, elias y Hugo

antes de git 1.9.1

Nota: el siguiente código si se usa en versiones posteriores de git (> v1.9.1) causa
(error) Todas las ramas creadas para rastrear maestro
(molestia) Todos los nombres de las sucursales locales creadas deben tener el prefijo origin/

for remote in `git branch -r `; do git branch --track $remote; done

Actualice las sucursales, suponiendo que no haya cambios en sus sucursales locales de seguimiento:

for remote in `git branch -r `; do git checkout $remote ; git pull; done

Ignore las ambiguas advertencias de refombre, git parece preferir la rama local como debería.

sin ningún tipo de script (en un directorio vacío):

$ git clone --bare repo_url .git $ git config core.bare false $ git checkout

después de eso, todas las sucursales remotas se verán como locales.

original (en ruso) .

for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do git branch --track ${branch##*/} $branch; done

Úselo y no tendrá la siguiente advertencia: el nombre de la referencia ''origen / dev'' es ambiguo

for i in `git branch -a | grep remote`; do git branch --track ${i#remotes/origin/} $i; done

for rembranch in `git remote update 2>&1 > /dev/null ; git branch -r|egrep -wv "HEAD|master"` do git checkout --track -b `echo $rembranch|awk -F// ''{print $2}''` $rembranch; done

Explicación:

línea 1: ''git branch -r'' (seguido de ''git remote update'' para actualizar la información sobre los cambios a control remoto) lista todas las sucursales remotas; ''egrep -vw'' se usa para rechazar entradas que tienen HEAD y master en el resultado.

línea 3: Rastree la rama remota nombrada mientras la revisa localmente. Se usa un simple awk para evitar que ''origin /'' sea el sufijo para las ramas locales.