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

https://stackoverflow.com/questions/67699

09-06-2019
|

Pregunta

tengo un master y un development rama, ambos empujados hacia GitHub.He cloned, pullEd, y fetched, pero sigo sin poder obtener nada más que el master rama hacia atrás.

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

Solución

Primero, clona un control remoto git repositorio y cd en ello:

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

A continuación, mira las sucursales locales en tu repositorio:

$ git branch
* master

¡Pero hay otras ramas escondidas en tu repositorio!Puedes verlos usando el -a bandera:

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

Si solo desea echar un vistazo rápido a una rama ascendente, puede consultarla directamente:

$ git checkout origin/experimental

Pero si desea trabajar en esa sucursal, deberá crear una sucursal 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 desconcierta a algunas personas:"Nueva sucursal" - ¿eh?Lo que realmente significa es que la rama se toma del índice y se crea localmente para usted.El anterior La línea es en realidad más informativa ya que le indica que la sucursal se está configurando para rastrear la sucursal remota, lo que generalmente significa la sucursal origen/nombre_sucursal.

Ahora, si miras tus sucursales locales, esto es lo que verás:

$ git branch
* experimental
  master

De hecho, puedes rastrear más de un repositorio remoto usando 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 poniendo bastante locas, así que corre. gitk para ver que esta pasando:

$ gitk --all &

Otros consejos

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

$ git pull --all

Ahora puede verificar cualquier rama que necesite, sin tener que acceder al repositorio remoto.

Este Intento El guión 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 es posible que aún necesites hacer un

git fetch --all
git pull --all

para estar seguro.

Un trazador de líneas: 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 siempre:Pruebe su configuración antes de copiar el universo rm -rf tal como lo conocemos.

Créditos por una sola línea para el usuario cfi

Utilizando el --mirror La opción parece copiar el remote realizar un seguimiento adecuado de las ramas.Sin embargo, configura el repositorio como un repositorio simple, por lo que luego debes volver a convertirlo en un repositorio normal.

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 sobre Git:¿Cómo clono un repositorio con todas las ramas rastreadas de forma remota?}

Puedes cambiar fácilmente a una rama sin usar la sofisticada sintaxis "git checkout -b somebranch origin/somebranch".Puedes simplemente hacer:

git checkout somebranch

Git automáticamente hará 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 exactamente en una rama remota y, si es así, la 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:

Siu003Cbranch> no se encuentra, pero existe una rama de seguimiento en exactamente un control remoto (llámelou003Cremote> ) con un nombre coincidente, trate como equivalente a
$ git checkout -b <branch> --track <remote>/<branch>

Acerca de,

$ git checkout -b origen experimental/experimental

usando

$ 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 recuperación que está realizando debería obtener todas las sucursales remotas, pero no creará sucursales locales para ellas.Si usas gitk, deberías 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:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "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á en la parte superior del árbol.

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

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

git checkout -b branch origin/branchname

Utilice alias.Aunque no hay frases ingeniosas nativas de Git, puedes definir las tuyas propias como

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

y luego usarlo como

git clone-branches

¿Por qué solo ves "maestro"?

git clone descarga todas las ramas remotas pero aún las considera "remotas", aunque los archivos estén ubicados en su nuevo repositorio.Hay una excepción a esto, que es que el proceso de clonación crea una rama local llamada "maestra" a partir de la rama remota llamada "maestra".Por defecto, git branch solo muestra sucursales locales, por eso solo ves "master".

git branch -a muestra todas las ramas, incluyendo sucursales remotas.

Cómo conseguir sucursales locales

Si realmente quieres trabajar en una rama, probablemente querrás una versión "local".Para crear simplemente sucursales locales a partir de sucursales remotas (sin revisarlos y, por lo tanto, cambiar el contenido de su directorio de trabajo), puedes hacerlo así:

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

En este ejemplo, branchone es el nombre de una sucursal local que estás creando en función de origin/branchone;Si, en cambio, deseas crear sucursales locales con nombres diferentes, puedes hacer esto:

git branch localbranchname origin/branchone

Una vez que haya creado una sucursal local, podrá verla con git branch (recuerda, no necesitas -a para ver 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 sucursales remotas.

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

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

git branch

Al resultado le gustará esto;

*your current branch 
some branch2
some branch3

Observe el signo * que indica la rama actual.

Más vale tarde que nunca, pero esta es la mejor manera de hacerlo:

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).Puedes usar --mirror en lugar de --bare si su repositorio remoto tiene sus propios controles remotos.

Sólo 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 sucursales, solo tiene que verificarlas y luego se creará su sucursal local.

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

git clone <your_http_url>

Aunque solo veas la rama maestra, puedes usar "git Branch -a" para ver todas las ramas.

git branch -a

Y puedes cambiar a cualquier sucursal que ya tengas.

git checkout <your_branch_name>

No se preocupe porque después de "git clone", no necesita conectarse con el repositorio remoto, "git branch -a" y "git checkout" se pueden ejecutar correctamente cuando cierra su wifi.Por lo tanto, está demostrado que cuando haces "git clone", ya se han 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.

A git clone se supone que copia todo el repositorio.Intenta clonarlo y luego ejecuta git branch -a.Debería enumerar todas las sucursales.Si luego desea cambiar a la rama "foo" en lugar de "master", use git checkout foo.

Usa mi herramienta git_remote_branch (Necesita Ruby instalado en su máquina).Está diseñado específicamente para facilitar la manipulación de sucursales remotas.

Cada vez que realiza una operación en tu nombre, la imprime en rojo en la consola.Con el tiempo, finalmente se quedan 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 esto es software alfa ;-)

Aquí está la ayuda cuando ejecuta grb help:

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

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 podrá "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 complicada.Necesita tres pasos para lograr esto:

Primer paso

cree una nueva carpeta vacía en su máquina y clone una copia espejo de la carpeta .git del 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, ahora solo hay una carpeta .git oculta que puedes ver con un comando "ls -alt" desde la terminal.

Segundo paso

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

$ git config --bool core.bare false

Tercer paso

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

$ git reset --hard

Ahora puedes escribir el comando "git branch" y podrás ver que todas las ramas están descargadas.

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

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 tenga cuidado, si una de las sucursales remotas tiene el nombre p.e.admin_master ¡no se descargará!

Gracias a Bigfish por la idea original.

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

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

DE ACUERDO, 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 sucursales, simplemente agregue --all bandera así:

git branch --all o git branch -a

Si simplemente paga en la sucursal, obtendrá todo lo que necesita.

Pero, ¿qué pasa si la rama creada por otra persona después de clonarla?

En este caso, simplemente haga:

git fetch

y revisa todas las sucursales nuevamente...

Si desea buscar y pagar al mismo tiempo, puede hacer:

git fetch && git checkout your_branch_name

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

#!/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 mayor 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

Esta voluntad:

echa un vistazo a master (para que podamos eliminar la rama en la que estamos)
seleccionar control remoto para pagar (cámbielo a cualquier control remoto que tenga)
recorrer todas las ramas del control remoto excepto master y HEAD
1. borrar sucursal local (para que podamos verificar las sucursales actualizadas forzadamente)
2. verificar rama desde el control remoto
echa un vistazo al maestro (por el simple hecho de hacerlo)

Residencia en respuesta de VonC.

Necesitaba hacer exactamente lo mismo.Aquí está mi Rubí guion.

#!/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]

Escribí este pequeño Potencia Shell funciones para poder verificar todas mis ramas de 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

Git normalmente (cuando no se especifica) recupera todas las ramas y/o etiquetas (referencias, consulte: git ls-refs) de uno o más repositorios junto con los objetos necesarios para completar sus historiales.En otras palabras, recupera los objetos a los que pueden acceder los objetos que ya están descargados.Ver: Que hace git fetch ¿realmente?

A veces es posible que tengas ramas/etiquetas que no estén conectadas directamente a la actual, por lo que git pull --all/git fetch --all no ayudará en ese caso, pero puede enumerarlos de la siguiente manera:

git ls-remote -h -t origin

y recuperarlos manualmente conociendo los nombres de las referencias.

Así que traerlos a todos, intentar:

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

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

Luego revisa todas tus sucursales nuevamente:

git branch -avv

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

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

por git remote set-branches como:

git remote set-branches --add origin missing_branch

por lo que puede aparecer debajo remotes/origin despué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 nada más que la rama maestra, verifique lo siguiente:

Verifique dos veces sus controles remotos (git remote -v), p.ej.
- Validar eso git config branch.master.remote es origin.
- Comprobar si origin apunta a la URL correcta a través de: git remote show origin (mira esto correo).

Ninguna de estas respuestas es suficiente, 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 master, por lo que cuando envié al nuevo control remoto, solo se envió la rama master.

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

Utilice comandos que pueda recordar

Estoy usando Bitbucket, un servicio de alojamiento de repositorios de Atlassian.Entonces trato de seguir sus documentos.Y eso funciona perfectamente para mí.Con los siguientes comandos sencillos y breves, puede verificar su sucursal remota.

Primero clone su repositorio, luego cambie a la carpeta de destino.Y por último, pero no menos importante, buscar y pagar:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

Eso es todo.Aquí un ejemplo un poco más real del mundo:

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Encontrará información detallada sobre los comandos en los documentos:Comando clonar, Comando de búsqueda, Comando de pago

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

git fetch <origin-name> <branch-name> baja la rama por ti.Si bien esto no extrae todas las ramas a la vez, puede ejecutar esto de forma singular por rama.

Aquí hay otro comando corto 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

También funciona correctamente si ya se han creado el seguimiento de sucursales locales.Puedes llamarlo después del primero. git clone o en cualquier momento posterior.

Si no necesitas tener master rama retirada después de la clonación, use

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

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

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow