tag - git ver archivos modificados




Cómo buscar todas las ramas de Git. (16)

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 el origin/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.


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

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.


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 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 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 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                  

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-branch