En unas entradas anteriores se explicó como trabajar con Git y la plataforma GitHub para gestionar el código. En esta entrada se va a presentar una de las características más útiles de los sistemas de control de versiones: las ramas. Conocer y comprender el funcionamiento de las ramas en Git permite mejorar gestión de los cambios. Evitando que modificaciones experimentales afecten a código que se encuentra en producción.

Ramas en sistemas de control de versiones

Una de las principales características de los sistemas de control de versiones es la posibilidad de trabajar con ramas. Una rama es una bifurcación del código original que puede evolucionar de forma independiente. Una vez evolucionadas, las ramas de un repositorio se pueden fusionar para combinar las características de ambas. Esto permite implementar cambios en una rama sin afectar a la estabilidad del resto del proyecto. Facilitando así la colaboración entre desarrolladores y permitiendo la realización de pruebas en el código.

Así una aplicación básica de las ramas es el desarrollo de nuevas características mientras se mantienen un código. Mediante la creación de una rama de producción, en la que se realiza únicamente el mantenimiento, y otras de desarrollo, en las que se prueban las nuevas funcionalidades. Una vez finalizadas estas se pueden fusionar con la rama principal. Sin necesidad de afectar a la estabilidad o la corrección de errores del proyecto durante el desarrollo. Por otro lado, en caso de que sea necesario desechar la nueva funcionalidad, simplemente se ha de abandonar la rama. Por lo que la principal nunca se vera afectada por los cambios fallidos.

Creación de un repositorio con ramas en Git

Para estudiar las ramas se ha de crear primero un repositorio Git. Para ello se han de seguir los pasos que se han visto en una entrada de introducción a Git. Crear una carpeta y dentro de ella ejecutar el comando git init.

$ mkdir proyecto_rama
$ cd proyecto_rama/
$ git init

Ahora se puede crear un fichero y agregarlo al repositorio

$ git add fichero.txt
$ git commit -a -m "Nuevo fichero"

Para crear una nueva rama se ha de ejecutar git branch <your-branch-name>, por ejemplo

$ git branch nuevarama

En este punto se ha creado una nueva rama llamada nuevarama. Si se ejecuta el comando git branch se mostrará el listado de todas las ramas existentes, indicando la rama actual mediante un asterisco.

$ git branch
* master
  nuevarama

El comando indica que la rama actual es master, la rama por defecto en los repositorios Git, y existe otra rama llamada nuevarama. Siendo esto lo que se esperaría en este momento. Ahora, para cambiar a la nueva rama se ha de ejecutar el comando git checkout <branch-name>.

$ git checkout nuevarama
Switched to branch 'nuevarama'
$ git branch
  master
* nuevarama

La tarea de crear y moverse a una nueva rama es una tarea habitual, por lo que existe un comando para realizar todos los pasos a la vez. Este es git checkout -b <branch-name>.

Ahora se dispone de una nueva rama en la que se pueden realizar pruebas. Se pueden realizar nuevos cambios y subir estos al repositorio sin afectar a la rama principal.

Deshaciendo cambios

En el proyecto se han creado tres commit en la rama nuevarama. Una vez aplicado el último se ha detectado que existe un error y se desea eliminar esta. El estado actual del repositorio se puede consultar con git log --oneline.

$ git log --oneline
8206868 (HEAD -> nuevarama) Cambio 3
99c809c Cambio 2
81aa831 Cambio 1
f6955b1 (master) Fichero

Para eliminar el cambio simplemente se ha de seleccionar el identificador de ultima subida para ejecutar el comando git revert <commit>, donde <commit> se ha de reemplazar por el id.

$ git revert 8206868
[nuevarama 850cfca] Revert "Cambio 3"
 1 file changed, 1 deletion(-)
$ git log --oneline
850cfca (HEAD -> nuevarama) Revert "Cambio 3"
8206868 Cambio 3
99c809c Cambio 2
81aa831 Cambio 1
f6955b1 (master) Fichero

Este comando ha creado un nuevo “commit” en el que se eliminar los últimos cambios. Por lo que Git ha solicitado un nuevo comentario para la subida.

Combinando las ramas

Se ha alcanzado un punto en el que se dispone de una nueva funcionalidad probada en una rama. Ahora es necesario incluir esta en la rama principal del proyecto. Lo que requiere unir las dos ramas en una mediante el comando git merge <branch-name>. Este comando se ha de ejecutar desde la rama receptora, en este caso master, por lo que primero se ha de cambiar de rama y luego ejecutar el comando.

$ git checkout master
Switched to branch 'master'
$ git merge nuevarama
Updating f6955b1..850cfca
Fast-forward
 fichero.txt | 3 +++
 1 file changed, 3 insertions(+)

Este proceso suele ser fácil la mayoría de las veces, pero en algunas ocasiones pueden aparecer conflictos si se ha modificado el mismo archivo en las dos ramas. En estos casos Git indicará que existe un conflicto en uno o varios archivos. El programador tendrá que editar estos y resolver manualmente los conflictos seleccionado el código que se va a conservar.

Conclusiones

En esta entrada se ha visto cómo trabajar con ramas en Git para compartimentar los desarrollos. Gracias a las ramas se puede realizar el mantenimiento de un proyecto mientras se desarrollan o evalúan nuevas características.

Ahora que se conocen las ramas se pueden aprender flujos de trabajo que basándose en el uso de ramas facilita el trabajo de los equipos. Uno de los flujos más populares es Gitflow que fue propuesto por Vincent Driessen en 2010.

Imágenes: Pixabay (RegalShave) | Pixabay (Michael Gaida)