¿Cómo clonar todas las ramas remotas en Git?

Tengo una mastery una developmentrama, ambas empujadas a GitHub . Tengo cloned, pulled y fetched, pero sigo siendo incapaz de recuperar otra cosa que la masterrama.

Estoy seguro de que me falta algo obvio, pero he leído el manual y no me alegro en absoluto.

Primero, clone un repositorio Git remoto y cd en él:

$ git clone git://example.com/myproject
$ cd myproject

Luego, mire las sucursales locales en su repositorio:

$ git branch
* master

¡Pero hay otras ramas escondidas en su repositorio! Puedes ver esto usando la -abandera:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Si solo quieres echar un vistazo rápido a una rama aguas arriba, puedes echarle un vistazo directamente:

$ git checkout origin/experimental

Pero si desea trabajar en esa rama, deberá crear una rama de seguimiento local que se realiza automáticamente mediante:

$ git checkout experimental

y tu verás

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Esa última línea arroja a algunas personas: "Nueva rama" - ¿eh? Lo que realmente significa es que la rama se toma del índice y se crea localmente para usted. La línea anterior es en realidad más informativa, ya que le indica que la rama se está configurando para rastrear la rama remota, lo que generalmente significa la rama origin / branch_name

Ahora, si observa sus sucursales locales, esto es lo que verá:

$ git branch
* experimental
  master

En realidad, puede rastrear más de un repositorio remoto utilizando git remote.

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

En este punto, las cosas se están gitkvolviendo bastante locas, así que corre para ver qué está pasando:

$ gitk --all &

Si tiene muchas ramas remotas que desea buscar a la vez, haga lo siguiente:

$ git pull --all

Ahora puede pagar cualquier rama que necesite, sin presionar el repositorio remoto.

Este script de Bash me ayudó:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Creará ramas de seguimiento para todas las ramas remotas, excepto la maestra (que probablemente obtuvo del comando de clonación original). Creo que aún podrías necesitar hacer un

git fetch --all
git pull --all

para estar seguro.

One liner : git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
como de costumbre: prueba en tu configuración antes de copiar rm -rf universe tal como lo conocemos

Los créditos para one-liner van al usuario cfi

El uso de la --mirroropción parece copiar las remoteramas de seguimiento correctamente. Sin embargo, configura el repositorio como un repositorio simple, por lo que debe volver a convertirlo en un repositorio normal después.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{Referencia: Preguntas frecuentes de Git: ¿Cómo clono un repositorio con todas las ramas con seguimiento remoto?}

Puede cambiar fácilmente a una rama sin utilizar la elegante sintaxis "git checkout -b somebranch origin / somebranch". Solo puedes hacer:

git checkout somebranch

Git hará automáticamente lo correcto:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

Git verificará si existe una rama con el mismo nombre en exactamente un control remoto, y si lo hace, lo rastreará de la misma manera que si hubiera especificado explícitamente que es una rama remota. Desde la página de manual de git-checkout de Git 1.8.2.1:

Si no se encuentra <branch> pero existe una rama de seguimiento en exactamente un control remoto (llámelo <remote>) con un nombre coincidente, trate como equivalente a

$ git checkout -b <branch> --track <remote>/<branch>

Respecto a,

$ git checkout -b origen experimental / experimental

utilizando

$ git checkout -t origin/experimental

o el más detallado pero más fácil de recordar

$ git checkout --track origin/experimental

podría ser mejor, en términos de seguimiento de un repositorio remoto.

La búsqueda que está haciendo debe obtener todas las ramas remotas, pero no creará ramas locales para ellas. Si usa gitk, debería ver las ramas remotas descritas como "remotes / origin / dev" o algo similar.

Para crear una sucursal local basada en una sucursal remota, haga algo como:

git checkout -b dev refs / remotes / origin / dev

Que debería devolver algo como:

Desarrollo de sucursal configurado para rastrear referencias remotas de sucursales / controles remotos / origen / dev.
Cambió a una nueva rama "dev"

Ahora, cuando esté en la rama de desarrollo, "git pull" actualizará su desarrollo local al mismo punto que la rama de desarrollo remota. Tenga en cuenta que buscará todas las ramas, pero solo arrastrará la que está hacia la parte superior del árbol.

Cuando haces "git clone git: // location", se obtienen todas las ramas y etiquetas.

Para trabajar encima de una rama remota específica, suponiendo que sea el origen remoto:

git checkout -b branch origin/branchname

Usa alias. Aunque no hay ninguna línea nativa de Git, puedes definir la tuya

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

y luego úsalo como

git clone-branches

¿Por qué solo ves "maestro"

git clonedescarga todas las ramas remotas pero aún las considera "remotas", aunque los archivos se encuentren en su nuevo repositorio. Hay una excepción a esto, que es que el proceso de clonación crea una rama local llamada "maestro" a partir de la rama remota llamada "maestro". De forma predeterminada, git branchsolo muestra sucursales locales, por lo que solo se ve "maestro".

git branch -amuestra todas las ramas, incluidas las ramas remotas .

Cómo obtener sucursales locales

Si realmente quiere trabajar en una rama, probablemente querrá una versión "local" de la misma. Para crear simplemente sucursales locales desde sucursales remotas (sin desprotegerlas y, por lo tanto, cambiar el contenido de su directorio de trabajo) , puede hacerlo así:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

En este ejemplo, branchonees el nombre de una sucursal local en la que está creando origin/branchone; si en su lugar desea crear sucursales locales con diferentes nombres, puede hacer esto:

git branch localbranchname origin/branchone

Una vez que haya creado una sucursal local, puede verla con git branch(recuerde, no necesita -aver sucursales locales).

Esto no es demasiado complicado, los pasos muy simples y directos son los siguientes;

git fetch origin Esto traerá todas las sucursales remotas a su local.

git branch -a Esto le mostrará todas las ramas remotas.

git checkout --track origin/<branch you want to checkout>

Verifique si está en la rama deseada con el siguiente comando;

git branch

La salida tendrá gusto de esto;

*your current branch 
some branch2
some branch3 

Observe el signo * que denota la rama actual.

Mejor tarde que nunca, pero esta es la mejor manera de hacer esto:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

En este punto, tiene una copia completa del repositorio remoto con todas sus ramas (verifique con git branch). Puede usar en --mirrorlugar de --baresi su repositorio remoto tiene sus propios controles remotos.

Solo haz esto:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

Verá, 'git clone git: //example.com/myprojectt' recupera todo, incluso las ramas, solo tiene que pagarlas, luego se creará su rama local.

Solo necesita usar "git clone" para obtener todas las ramas.

git clone <your_http_url>

Aunque solo vea la rama maestra, puede usar "git branch -a" para ver todas las ramas.

git branch -a

Y puede cambiar a cualquier rama que ya tenga.

git checkout <your_branch_name>

No se preocupe que después de "git clone", no necesita conectarse con el repositorio remoto, "git branch -a" y "git checkout" se pueden ejecutar con éxito cuando cierra su wifi. Por lo tanto, se demuestra que cuando hace "git clone", ya ha copiado todas las ramas del repositorio remoto. Después de eso, no necesita el repositorio remoto, su local ya tiene los códigos de todas las sucursales.

Se git clonesupone que A copia todo el repositorio. Intenta clonarlo y luego corre git branch -a. Debería enumerar todas las ramas. Si quiere cambiar a la rama "foo" en lugar de "master", use git checkout foo.

Use mi herramienta git_remote_branch (necesita que Ruby esté instalado en su máquina). Está construido específicamente para hacer que las manipulaciones de sucursales remotas sean muy fáciles.

Cada vez que realiza una operación en su nombre, lo imprime en rojo en la consola. Con el tiempo, finalmente se pegan en tu cerebro :-)

Si no desea que grb ejecute comandos en su nombre, simplemente use la función 'explicar'. Los comandos se imprimirán en su consola en lugar de ejecutarse por usted.

Finalmente, todos los comandos tienen alias para facilitar la memorización.

Tenga en cuenta que este es un software alfa ;-)

Aquí está la ayuda cuando ejecuta grb help:

git_remote_branch versión 0.2.6

  Uso:

  grb create branch_name [servidor_origen] 

  grb publica nombre_búsqueda [servidor_origen] 

  grb rename branch_name [servidor_origen] 

  grb delete branch_name [servidor_origen] 

  pista de grb nombre_búsqueda [servidor_origen] 



  Notas:
  - Si no se especifica origin_server, se asume el nombre 'origin' 
    (Por defecto de git)
  - La funcionalidad de cambio de nombre cambia el nombre de la rama actual

  El metacomando explicado: también puede anteponer cualquier comando con el 
palabra clave 'explicar'. En lugar de ejecutar el comando, git_remote_branch
simplemente mostrará la lista de comandos que necesita ejecutar para lograr 
ese objetivo

  Ejemplo: 
    grb explicar crear
    grb explicar crear my_branch github

  Todos los comandos también tienen alias:
  crear: crear, nuevo
  eliminar: eliminar, destruir, matar, eliminar, rm
  publicar: publicar, remotizar
  renombrar: renombrar, rn, mv, mover
  rastrear: rastrear, seguir, agarrar, buscar

Todas las respuestas que vi aquí son válidas, pero hay una forma mucho más limpia de clonar un repositorio y extraer todas las ramas a la vez.

Cuando clonas un repositorio, toda la información de las ramas se descarga, pero las ramas están ocultas. Con el comando

$ git branch -a

puedes mostrar todas las ramas del repositorio y con el comando

$ git checkout -b branchname origin/branchname

luego puede "descargarlos" manualmente uno a la vez.

Sin embargo, cuando desea clonar un repositorio con muchas ramas, todas las formas ilustradas arriba son largas y tediosas con respecto a una forma mucho más limpia y rápida que voy a mostrar, aunque es un poco complicado. Necesita tres pasos para lograr esto:

1. Primer paso

cree una nueva carpeta vacía en su máquina y clone una copia espejo de la carpeta .git desde el repositorio:

$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git

el repositorio local dentro de la carpeta my_repo_folder todavía está vacío, solo hay una carpeta oculta .git ahora que puede ver con un comando "ls -alt" desde el terminal.

2. Segundo paso

cambie este repositorio de un repositorio vacío (desnudo) a un repositorio regular cambiando el valor booleano "desnudo" de las configuraciones de git a falso:

$ git config --bool core.bare false

3. Tercer paso

Tome todo lo que está dentro de la carpeta actual y cree todas las ramas en la máquina local, por lo tanto, este es un repositorio normal.

$ git reset --hard

Así que ahora puede escribir el comando "git branch" y ver que todas las ramas se descargan.

Esta es la forma rápida en que puede clonar un repositorio git con todas las ramas a la vez, pero no es algo que quiera hacer para cada proyecto de esta manera.

La clonación desde un repositorio local no funcionará con git clone & git fetch: muchas ramas / etiquetas permanecerán intactas.

Para obtener un clon con todas las ramas y etiquetas.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

Para obtener un clon con todas las ramas y etiquetas, pero también con una copia de trabajo:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

OK, cuando clonas tu repositorio, tienes todas las ramas allí ...

Si solo lo haces git branch, están algo escondidos ...

Entonces, si desea ver el nombre de todas las ramas, simplemente agregue una --allbandera como esta:

git branch --all o git branch -a

Si solo realiza el pago en la sucursal, obtendrá todo lo que necesita.

Pero, ¿qué tal si la rama creada por otra persona después de que clones?

En este caso, solo haz:

git fetch

y verifique todas las ramas nuevamente ...

Si desea obtener y pagar al mismo tiempo, puede hacer lo siguiente:

git fetch && git checkout your_branch_name

También creé la imagen a continuación para que puedas simplificar lo que dije:

Al mirar una de las respuestas a la pregunta, noté que es posible acortarla:

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

Pero cuidado, si una de las ramas remotas se nombra como, por ejemplo, admin_master, ¡no se descargará!

Gracias a bigfish por la idea original.

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

Este código extraerá todos los códigos de sucursales remotas al repositorio local.

Para copiar y pegar en la línea de comando:

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

Para más legibilidad:

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

1. echa un vistazo a master (para que podamos eliminar la rama en la que estamos)
2. seleccione el control remoto para pagar (cámbielo a cualquier control remoto que tenga)
3. recorrer todas las ramas del control remoto, excepto maestro y CABEZA
   1. eliminar sucursal local (para que podamos verificar las sucursales actualizadas a la fuerza)
   2. echa un vistazo a la sucursal desde el control remoto
4. echa un vistazo a maestro (por el bien de eso)

Basado en la respuesta de VonC .

Escribí estas pequeñas funciones de Powershell para poder verificar todas mis ramas git, que están en origen remoto.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Se pueden encontrar más funciones de git en mi repositorio de configuración de git

Aquí hay una respuesta que usa awk. Este método debería ser suficiente si se usa en un nuevo repositorio.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Las ramas existentes simplemente se retirarán o se declararán como ya en él, pero se pueden agregar filtros para evitar conflictos.

También se puede modificar para que llame a un git checkout -b <branch> -t <remote>/<branch>comando explícito .

Esta respuesta se desprende Nikos C 's idea .

Alternativamente, podemos especificar la rama remota en su lugar. Esto se basa en la respuesta de murphytalk .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Lanza mensajes de error fatales sobre conflictos pero los veo inofensivos.

Ambos comandos pueden tener un alias.

Usando la respuesta de nadie como referencia, podemos tener los siguientes comandos para crear los alias:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Personalmente usaría track-allo track-all-branches.

Necesitaba hacer exactamente lo mismo. Aquí está mi script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Ninguna de estas respuestas lo cortó, excepto que el usuario nadie está en el camino correcto.

Estaba teniendo problemas para mover un repositorio de un servidor / sistema a otro. Cuando cloné el repositorio, solo creó una rama local para el maestro, por lo que cuando presioné el nuevo control remoto, solo se presionó la rama maestra.

Entonces encontré estos dos métodos MUY útiles. Espero que ayuden a alguien más.

Método 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Método 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

git clone --mirror en el repositorio original funciona bien para esto.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

Git generalmente (cuando no se especifica) obtiene todas las ramas y / o etiquetas (referencias, ver:) git ls-refsde uno o más repositorios junto con los objetos necesarios para completar sus historias. En otras palabras, recupera los objetos a los que pueden acceder los objetos que ya están descargados. Ver: ¿Qué hace git fetchrealmente?

A veces puede tener ramas / etiquetas que no están conectadas directamente con la actual, por lo que git pull --all/ git fetch --allno ayudará en ese caso, pero puede enumerarlas por:

git ls-remote -h -t origin

y buscarlos manualmente al conocer los nombres de referencia.

Entonces, para buscarlos a todos , intente:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{El --depth=10000parámetro puede ayudar si ha reducido el repositorio.}

Luego revise todas sus ramas nuevamente:

git branch -avv

Si lo anterior no ayuda, debe agregar las ramas que faltan manualmente a la lista de seguimiento (ya que de alguna manera se perdieron):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

por me git remote set-branchesgusta:

git remote set-branches --add origin missing_branch

por lo que puede aparecer debajo remotes/origindespués de buscar:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

Solución de problemas

Si aún no puede obtener otra cosa que no sea la rama maestra, verifique lo siguiente:

• Verifique sus controles remotos ( git remote -v), p. Ej.
  • Validar que git config branch.master.remotees origin.
  • Verifique si originapunta a la URL correcta a través de: git remote show origin(vea esta publicación ).

A principios de 2017, la respuesta en este comentario funciona:

git fetch <origin-name> <branch-name>derriba la rama para ti. Si bien esto no tira todas las ramas a la vez, puede ejecutar singularmente esta por rama.

Aquí hay otro comando breve de una línea que crea ramas locales para todas las ramas remotas:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

Funciona también correctamente si ya se han creado ramas locales de seguimiento. Puede llamarlo después del primero git cloneo en cualquier momento posterior.

Si no necesita que le mastersaquen una rama después de la clonación, use

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout