Control de versiones con GIT


Cuando realizamos proyectos más de alguna vez hemos hecho cambios que nos han producido errores o accidentalmente hemos eliminado archivos necesarios para su funcionamiento. A veces, quizá encontramos la solución rápidamente, en otras ocasiones es más conveniente recurrir a un respaldo de alguna versión anterior. Así es como llegamos a tener carpetas con nombres como "proyecto1", "final", "final2", "finaldefinitivo" o archivos duplicados con distintos números y no se sabe a ciencia cierta cuál corresponde.

Sin saberlo, de esta manera estamos aplicando control de versiones manual, pero de una manera muy poco eficiente. Para solucionar esto nace el sistema de control de versiones GIT

Entonces, ¿Qué es GIT?

Según wikipedia, GIT es un software de control de versiones diseñado por Linus Torvalds, pensando en la eficiencia y la confiabilidad del mantenimiento de versiones de aplicaciones cuando éstas tienen un gran número de archivos de código fuente. Su propósito es llevar registro de los cambios en archivos de computadora y coordinar el trabajo que varias personas realizan sobre archivos compartidos.

¿Cómo funciona?

Antes de detallar cómo utilizarlo, es necesario empezar a pensar a desarrollar de una manera diferente. A cada proyecto que desarrollemos lo llamamos repositorio, en el que trabajará todo el equipo.

Podemos tener un repositorio local y uno remoto. Generalmente se trabaja localmente en el repositorio, para luego subir tus cambios al remoto (push) y que lo pueda ver o descargar (pull) todo el grupo de trabajo. Así, a medida que vamos haciendo cambios importantes hacemos commits, que son nada más que actualizaciones en las que deberemos incluir un comentario declarando los cambios que hemos realizado localmente, para posteriormente llevarlo a la nube. De este modo, si surge algún problema podremos volver a uno de esos estados sin problemas recordando los mensajes que hemos ido dejando y de paso el equipo también puede saber qué fue lo que hicimos.

También tenemos las ramas (Branches), que nos ayudan a separar las distintas características del proyecto. Una buena idea es dejar la rama master para una versión estable, otra de desarrollo, otra para cada nueva característica que vayamos añadiendo y por último una para solucionar errores de extrema urgencia. Una vez están listos los cambios en alguna rama para ser integrados en la de desarrollo o estable las unimos (merge).

Instalando GIT

Si tu sistema operativo es Unix, ya sea una distribución x de Linux o Mac OS, lo más probable es que ya tengas GIT.

En el caso de Windows hay que descargar GIT Bash, pero lo más recomendable es que uses Windows Subsystem for Linux (WSL) y puedas tener la terminal Unix sin salir de Windows. (tutorial próximamente)

Otra alternativa es usar GIT con los editores de código que lo traen integrado, como por ejemplo VS Code, o la interfaz gráfica de GIT, pero en este caso usaremos la terminal.

Creando un repositorio local

Nos vamos a la terminal y nos dirigimos a alguna carpeta donde queramos crear nuestro proyecto, por ejemplo /home/user/test, usando el comando cd

[user@pc ~]$ cd [user@pc ~]$ git init test Initialized empty Git repository in /home/user/test/.git/ [user@pc ~]$ cd test

Ahora deberemos indicar nuestro nombre y email para poder identificarnos cuando hagamos commits.

user@pc:~/test$ git config user.name "Nombre Apellido" user@pc:~/test$ git config user.email mail@example.com

Creando un repositorio remoto

Existen muchos servicios donde tener nuestro repositorio en la nube, incluso podríamos montarlo en algún servidor propio, pero en este caso recomendamos usar Gitlab probehido por el LabComp.

Así que iremos a gitlab.labcomp.cl e ingresamos con nuestras credenciales del departamento de informática. Una vez adentro, pulsamos en "New project", a la derecha.

En este caso, crearemos un proyecto en blanco. Le damos nombre test, automáticamente la URL o slug quedará escrita y podemos modificarla opcionalmente, al igual que podemos insertar una descripción no obligatoria, aunque siempre recomendamos hacerlo. Finalmente, elegimos si queremos que el repositorio sea privado (solo para usuarios definidos por nosotros), interno (para cualquier usuario del departamento) o público y presionamos el botón "Create project".

Para agregar miembros al proyecto en caso de que sea privado, una vez en la página del repositorio, podemos ir a Settings, members y buscar el usuario a añadir.

Integrando ambos repositorios

Para conectar ambos repositorios lo hacemos de la siguiente manera: "git remote add origin "

user@pc:~/test$ git remote add origin https://gitlab.labcomp.cl/user/test.git

Existen muchas formas, por ejemplo, también lo podríamos haber hecho del modo inverso, primero creando el repositorio remoto y luego clonándolo, sin necesidad de haber creado un repositorio local. Esto es útil también si se suma un nuevo integrante:

user@pc:~$ git clone https://gitlab.labcomp.cl/user/test.git user@pc:~$ cd test Cloning into 'test'... Username for 'https://gitlab.labcomp.cl': user Password for 'https://user@gitlab.labcomp.cl': warning: You appear to have cloned an empty repository.

Haciendo algunos cambios

Cada vez que hayamos modificado o agregado archivos y estemos listos para hacer un nuevo commit, primero debemos indicar cuáles han sido los nuevos ficheros agregados o modificados, para ello usamos el comando "git add ", o si queremos agregar todos los del repositorio usamos el punto, "git add .".

Creemos un archivo "README.md" en la carpeta principal del proyecto:

  1. # Test

  2. Aprendiendo a usar GIT

  3. ### Usage

  4. TO-DO

Una vez guardado, ejecutamos cualquiera de las dos maneras posibles:

user@pc:~/test$ git add "README.md" user@pc:~/test$ git add .

Ya solo nos falta indicar qué fue lo que hicimos con un commit:

user@pc:~/test$ git commit -m "Added README.md with the description" [master (root-commit) 38c0de3] Added README.md with the description 1 file changed, 7 insertions(+) create mode 100644 README.md

Podemos revisar el estado con "git status":

user@pc:~/test$ git status On branch master nothing to commit, working tree clean

Integrando los cambios en el repositorio remoto

Para actualizar los cambios en el repositorio remoto ejecutamos "git push origin ", que en este caso es master

user@pc:~/test$ git push origin master Username for 'https://gitlab.labcomp.cl': user Password for 'https://user@gitlab.labcomp.cl': Counting objects: 6, done. Delta compression using up to 8 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (6/6), 458 bytes | 114.00 KiB/s, done. Total 6 (delta 1), reused 0 (delta 0) To https://gitlab.labcomp.cl/user/test.git ** [new branch] master -> master

Si queremos traer al repositorio local cambios que hayan hecho otras personas del equipo o que simplemente no estén en el repositorio local, usamos "git pull origin "

user@pc:~/test$ git pull Username for 'https://gitlab.labcomp.cl': user Password for 'https://user@gitlab.labcomp.cl': From https://gitlab.labcomp.cl/user/test ** branch master -> FETCH_HEAD Already up to date.

En este caso no hay cambios.

Revertir cambios

Para volver a la versión anterior de un fichero, puedes ejecutar "git checkout -- ".

Para deshacer los commits locales y regresar a la última versión que está en el repositorio remoto ejecutamos:

  • git fetch origin
  • git reset --hard

Trabajando con ramas

Próximamente

Fecha: 07 Oct, 2019
Autor: bprieto