Mario González - Blog sobre desarrollo web

Git – Bajar todas las nuevas ramas del repositorio remoto

En Git
| ,

Cuando estamos trabajando en un equipo de desarrolladores, muchas veces necesitamos bajar alguna rama nueva del repositorio remoto, creada por otro miembro del equipo. Para no tener que estar pendiente de cuándo alguien crea una nueva rama y de cómo se llama, vamos a ver una forma cómoda de tener nuestro repositorio local siempre actualizado con las nuevas ramas del remoto.

Clonar el repositorio con todas las ramas

Si nos queremos clonar un repositorio remoto que ya tiene varias ramas, lo solemos hacer con git clone:


git clone URL_REPOSITORIO_REMOTO

Muchos usuarios de Git piensan que al hacer un git clone sólo nos bajamos la rama principal (generalmente master). Y es fácil pensarlo, porque si yo listo las ramas locales después de hacer un git clone, sólo veo la rama master:

git clone
git branch nos muestra sólo la rama master

Pero en realidad no es la única que nos ha bajado. El comando git branch, si lo lanzamos sin parámetros, nos lista las ramas locales. Pero si le pasamos el parámetro --all (o -a), nos mostrará tanto las locales como las remotas:

git branch
git branch -a nos muestra tanto las ramas locales como las remotas

En realidad, esas ramas remotas que vemos en el listado son copias locales de las ramas remotas. Como acabamos de hacer un git clone, esas copias estarán exactamente igual que en el repositorio remoto. Si queremos crear las correspondientes ramas locales, sólo tenemos que ir a cada una de las ramas con git checkout:

git checkout
Después de acceder a cada rama con git checkout

git branch nos muestra que ya tenemos todas las ramas en local. Esto es porque al ir a una rama que no existe en el repositorio local, Git la buscará entre las copias de las ramas remotas. Si encuentra una con el mismo nombre, crea la rama local y además la deja vinculada con la rama remota.

push y pull sin nombre de rama

Una vez que tenemos todas las ramas vinculadas con sus correspondientes ramas remotas, podemos usar git push y git pull sin tener que escribir el nombre de la rama. Git se conectará a la rama remota a la que está vinculada la actual:

git push
git push envía a la rama remota correspondiente

Puede que después de usar git push sin el nombre de la rama, os salga un aviso muy largo explicando que en las nuevas versiones de Git el comportamiento por defecto cuando no escribimos un nombre de rama ha cambiado. Para que no os salga más, escribid:


git config --global push.default simple

Nuevas ramas remotas durante el proyecto

¿Y si ya tenemos el repositorio clonado, llevamos un tiempo trabajando en él, y un día un miembro del equipo sube una rama nueva al repositorio remoto? ¿Nos tiene que avisar? ¿Tenemos que saber cómo se llama la nueva rama? No es necesario, vamos a ver cómo tener siempre actualizadas las copias locales de las ramas remotas.

Más arriba decíamos que, una vez que las ramas locales están vinculadas con las remotas, podemos usar git push y git pull sin necesidad de escribir el nombre de una rama. ¿Qué ocurre cuando yo escribo git pull a secas? Sabemos que el comando git pull en realidad lanza dos comandos secuencialmente: primero hace git fetch y luego git merge. Ese primer comando es el que nos interesa: ese fetch nos actualizará todas las copias locales de las ramas remotas, copiando las que haya nuevas. Es decir, cada vez que hacemos un git pull sin nombre de rama, estamos sincronizando nuestras copias de las remotas con las ramas remotas reales.

git pull
git pull nos baja las ramas remotas nuevas

En la captura anterior partíamos de un repositorio local con las ramas masterrama1rama2rama3rama4. Al hacer git pull, lo primero que hace es actualizarnos las copias locales de las ramas remotas. Como en el repositorio remoto hay una rama nueva que no teníamos en local (rama5), nos baja la copia y ya la tenemos en el repositorio local.

Para crear la rama local correspondiente, sólo tenemos que entrar en ella, como hacíamos justo después del git clone, y Git nos la creará a partir de la copia remota:

git checkout
git checkout nos crea la nueva rama

Conclusiones

Hemos visto qué sencillo es mantener sincronizadas nuestras ramas locales con las remotas, sin tener que estar pendientes de cuándo aparecen ramas nuevas. Si estábais hasta el gorro de usar la nada intuitiva fórmula de git fetch origin nueva_rama:nueva_rama, ya podéis olvidaros de ella y empezar a usar este método.

¿Qué opinas?

Tu dirección de correo electrónico no será publicada. * Campos obligatorios