tag - Cómo buscar todas las ramas de Git.
git tag (24)
Cloné un repositorio Git, que contiene alrededor de cinco ramas. Sin embargo, cuando hago git branch
solo veo uno de ellos:
$ git branch
* master
Sé que puedo hacer git branch -a
para ver todas las ramas, pero ¿cómo puedo jalar todas las sucursales localmente para que cuando haga git branch
, muestre lo siguiente?
$ git branch
* master
* staging
* etc...
Aquí hay algo que consideraría robusto:
- No actualiza el seguimiento remoto para sucursales existentes
- No intenta actualizar
HEAD
para rastrear elorigin/HEAD
- Permite mandos remotos con nombre distinto al
origin
- Correctamente citado shell
for b in $(git branch -r --format=''%(refname:short)''); do
[[ "${b#*/}" = HEAD ]] && continue
git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all
No es necesario git fetch --all
como pasar - -all
para que git pull
pase esta opción a la fetch
interna.
Crédito a esta respuesta .
Aquí hay una versión de Perl de una sola línea proporcionada en la respuesta aceptada:
git branch -r | perl -e ''while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin//(.*)/); print "git branch --track $local $remote/n";}'' > some-output-file
Puede ejecutar el archivo de salida como un script de Shell si lo desea.
Eliminamos nuestro repositorio de proyectos Stash por accidente. Afortunadamente, alguien había creado un tenedor justo antes de la pérdida accidental. Cloné el tenedor a mi local (omitiré los detalles de cómo lo hice). Una vez que tuve el tenedor completamente en mi local, corrí una de una sola línea. Modifiqué la URL del control remoto (origen en mi caso) para que apunte al repositorio de destino que estábamos recuperando:
git remote set-url origin <remote-url>
Y finalmente empujó todas las ramas a su origen como tal:
git push --all origin
y estábamos de vuelta en el negocio.
Asegúrese de que todas las ramas remotas se puedan recuperar en el archivo .git/config
.
En este ejemplo, solo se puede obtener la rama de origin/production
, incluso si intentas hacer git fetch --all
no pasará nada, pero se buscará la rama de production
:
[origin]
fetch = +refs/heads/production:refs/remotes/origin/production
Esta línea debe ser reemplazada por:
[origin]
fetch = +refs/heads/*:refs/remotes/origin/*
A continuación, ejecute git fetch
etc ...
Basado en la respuesta de Learath2, esto es lo que hice después de hacer git clone [...]
y cd
-ing en el directorio creado:
git branch -r | grep -v master | awk {print/$1} | sed ''s/^origin///(.*/)$//1 &/'' | xargs -n2 git checkout -b
Trabajó para mí, pero no puedo saber que funcionará para ti. Ten cuidado.
Creo que tienes clonar el repositorio por
git clone https://github.com/pathOfrepository
ahora ve a esa carpeta usando cd
cd pathOfrepository
si git status
puedes ver todo
On branch master
Your branch is up-to-date with ''origin/master''.
nothing to commit, working directory clean
para ver todos los tipos de ramas ocultas
git branch -a
se listará toda la rama remota
Ahora, si desea realizar el pago en cualquier rama en particular, simplemente escriba
git checkout -b localBranchName origin/RemteBranchName
Cuando clonas un repositorio, toda la información de las sucursales se descarga, pero las sucursales están ocultas. Con el comando
$ git branch -a
puede mostrar todas las ramas del repositorio, y con el comando
$ git checkout -b branchname origin/branchname
A continuación, puede "descargar" manualmente uno a la vez.
Sin embargo, hay una forma mucho más limpia y rápida, 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 duplicada 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.
Segundo paso
cambie este repositorio de un repositorio vacío (desnudo) a un repositorio regular cambiando el valor booleano "bare" de las configuraciones de git a falso:
$ git config --bool core.bare false
Tercer paso
Coge todo lo que está dentro de la carpeta actual y crea todas las ramas en la máquina local, por lo tanto, esto es un repositorio normal.
$ git reset --hard
Así que ahora solo puede escribir el comando git branch
y puede ver que todas las sucursales están descargadas.
Esta es la forma rápida en que puedes clonar un repositorio de git con todas las sucursales a la vez, pero no es algo que quieras hacer para cada proyecto de esta manera.
Después de clonar el repositorio principal, simplemente puede ejecutar
git fetch && git checkout <branchname>
El bash for loop no estaba funcionando para mí, pero esto hizo exactamente lo que quería. Todas las ramas de mi origen reflejadas como el mismo nombre localmente.
git checkout --detach
git fetch origin ''+refs/heads/*:refs/heads/*''
Editado: Ver el comentario de Mike DuPont a continuación. Creo que estaba tratando de hacer esto en un servidor Jenkins que lo deja en modo de cabeza separada.
Escribí un pequeño script para administrar la clonación de un nuevo repositorio y crear sucursales locales para todas las sucursales remotas.
Puedes encontrar la última versión here :
#!/bin/bash
# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)
clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
exit 1
fi
pushd $(echo $clone_output | head -1 | sed ''s/Cloning into ./(.*/)././././/1/'') > /dev/null 2>&1
this_branch=$(git branch | sed ''s/^..//'')
for i in $(git branch -r | grep -v HEAD); do
branch=$(echo $i | perl -pe ''s/^.*?////'')
# this doesn''t have to be done for each branch, but that''s how I did it.
remote=$(echo $i | sed ''s///.*//'')
if [[ "$this_branch" != "$branch" ]]; then
git branch -t $branch $remote/$branch
fi
done
popd > /dev/null 2>&1
Para usarlo, simplemente cópielo en su directorio de git bin (para mí, eso es C:/Program Files (x86)/Git/bin/git-cloneall
), luego, en la línea de comando:
git cloneall [standard-clone-options] <url>
Se clona como de costumbre, pero crea sucursales locales de seguimiento para todas las sucursales remotas.
Loops no parecía funcionar para mí y quería ignorar el origen / master. Esto es lo que funcionó para mí.
git branch -r | grep -v HEAD | awk -F''/'' ''{print $2 " " $1"/"$2}'' | xargs -L 1 git branch -f --track
Después de esto:
git fetch --all
git pull --all
Necesitará crear sucursales locales que sigan sucursales remotas.
Suponiendo que solo tenga un origin
remoto llamado, este fragmento creará sucursales locales para todos los de seguimiento remoto:
for b in `git branch -r | grep -v -- ''->''`; do git branch --track ${b##origin/} $b; done
Después de eso, git fetch --all
all actualizará todas las copias locales de sucursales remotas.
Además, git pull --all
todo actualizará sus sucursales de seguimiento locales, pero, dependiendo de sus confirmaciones locales y de cómo esté configurada la opción de configuración ''fusionar'', podría crear una confirmación de fusión, un avance rápido o un error.
Para listar ramas remotas:
git branch -r
Puedes consultarlos como sucursales locales con:
git checkout -b LocalName origin/remotebranchname
Para usuarios de Windows que utilizan PowerShell:
git branch -r | ForEach-Object {
# Skip default branch, this script assumes
# you already checked-out that branch when cloned the repo
if (-not ($_ -match " -> ")) {
$localBranch = ($_ -replace "^.*/", "")
$remoteBranch = $_.Trim()
git branch --track "$localBranch" "$remoteBranch"
}
}
git fetch --all
git pull --all
Podemos poner todos los nombres de rama o etiqueta en un archivo temporal, luego hacer git pull para cada nombre / etiqueta:
git branch -r | grep origin | grep -v HEAD| awk -F/ ''{print $NF}'' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done
Puedes obtener una rama de todos los controles remotos como este:
git fetch --all
fetch
actualizaciones de copias locales de sucursales remotas para que siempre sea seguro para sus sucursales locales, PERO :
fetch
no actualizará las sucursales locales (que rastrean las sucursales remotas); Si desea actualizar sus sucursales locales, todavía necesita extraer todas las sucursales.fetch
no creará sucursales locales (que rastrean sucursales remotas), debe hacerlo manualmente. Si quieres listar todas las sucursales remotas:git branch -a
Para actualizar las sucursales locales que rastrean las sucursales remotas:
git pull --all
Sin embargo, esto puede ser aún insuficiente. Solo funcionará para las sucursales locales que rastrean las sucursales remotas. Para rastrear todas las ramas remotas, ejecute este oneliner ANTES de git pull --all
:
git branch -r | grep -v ''/->'' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
TL; versión DR
git branch -r | grep -v ''/->'' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all
(Parece que pull recupera todas las ramas de todos los mandos a distancia, pero siempre lo hago primero para estar seguro)
Ejecute el primer comando solo si hay sucursales remotas en el servidor que no están siendo rastreadas por sus sucursales locales.
PS AFAIK git fetch --all
git remote update
son equivalentes.
El comment Kamil Szot, que 74 (al menos) personas encontraron útil.
Tuve que usar:
for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done
porque su código creó sucursales locales llamadas
origin/branchname
y recibí "refname ''origin / branchname'' es ambiguo cuando me referí a él.
Puedes traer todas las ramas por:
git fetch --all
o:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
El parámetro --depth=10000
puede ayudar si tienes un repositorio superficial.
Para jalar todas las ramas, usa:
git pull --all
Si lo anterior no funciona, entonces precede el comando anterior con:
git config remote.origin.fetch ''+refs/heads/*:refs/remotes/origin/*''
ya que remote.origin.fetch
podría admitir solo una rama específica mientras se recupera, especialmente cuando clonó su repositorio con --single-branch
. Compruebe esto por: git config remote.origin.fetch
.
Después de eso deberías poder pagar cualquier rama.
Ver también:
- ¿Cómo recuperar todas las ramas remotas?
- ¿Cómo clonar todas las ramas remotas en Git?
Para empujar todas las ramas hacia el control remoto, use:
git push --all
eventualmente --mirror
espejo para reflejar todas las referencias.
Si su objetivo es duplicar un repositorio, consulte: Duplicar un artículo del repositorio en GitHub.
Si está aquí buscando una solución para obtener todas las sucursales y luego migrar todo a otro servidor Git, armo el siguiente proceso. Si solo desea obtener todas las sucursales actualizadas localmente, deténgase en la primera línea vacía.
git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F''origin/'' ''!/HEAD|master/{print $2 " " $1"origin/"$2}'' | xargs -L 1 git branch -f --track
git fetch --all --prune --tags
git pull --all
git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>
Si lo haces:
git fetch origin
entonces estarán todos allí localmente. Si luego realizas:
git branch -a
Los verá listados como remotos / origen / nombre de rama. Ya que están localmente, puedes hacer lo que quieras con ellos. Por ejemplo:
git diff origin/branch-name
o
git merge origin/branch-name
o
git checkout -b some-branch origin/branch-name
Si tienes problemas con la búsqueda --todos
luego sigue tu rama remota
git checkout --track origin /% branchname%
Solo esos 3 comandos obtendrán todas las ramas.
git clone --mirror repo.git .git (gets just .git - bare repository)
git config --bool core.bare false
git reset --hard
Usualmente no uso nada más que comandos como este:
git fetch origin
git checkout --track origin/remote-branch
Una versión un poco más corta:
git fetch origin
git checkout -t origin/remote-branch
Utilice git fetch && git checkout RemoteBranchName
.
Funciona muy bien para mi ...
$ git remote update
$ git pull --all
Esto supone que todas las ramas son rastreadas.
Si no lo son, puedes disparar esto en Bash:
for remote in `git branch -r `; do git branch --track $remote; done
A continuación, ejecute el comando.
git remote add origin https://yourBitbucketLink
git fetch origin
git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)
Ahora, a nivel local, yourNewLocalBranchName
es yourNewLocalBranchName
requiredRemoteBranch
.