Trabajo en equipo con Git
Tags: git, contribute, tutorial
Published: 2021-01-17 04:32:02

**Git**: Sistema de control de versiones.

**Control de versiones**: Se llama así a la gestión de cambios realizados sobre un algo, (archivo o archivos, usualmente de código o diseño).

En palabras sencillas, ¿para qué utilizamos **git**? utilizamos **git** para no perder cambios, para hacer seguimiento de cambios sobre uno o varios archivos, para guardar el progreso de un algo que suele ser un proyecto de código o diseño.

Aunque podríamos utilizar **git**, para llevar notas personales o notas de la universidad, lo solemos utilizar para realizar trabajo en equipo, es por lo que es realmente conocido, *"Una herramienta que me permite poder organizarme con mi equipo y hacer seguimiento del trabajo que realizamos"*.

Debemos tener presente que al iniciar **git** lo hacemos en una carpeta, significa que aún si queremos hacer seguimiento de un solo archivo debemos iniciar **git** en la carpeta que contiene ese archivo.

A continuación algunos comandos útiles que utilizaremos en un ejemplo de trabajo en equipo:

`git init`: Inicializar un proyecto de git en una carpeta
`git fetch --all`: Actualizar ramas remotas
`git branch`: Mostrar ramas locales
`git branch -a`: Mostrar ramas locales y remotas

`git remote add origin https://gitlab.com/hijuliancode/demo-git-tutorial`: Agrega un remoto a nuestro repositorio al que podemos enviar cambios
`git remote add heroku https://git.heroku.com/demo-heroku-repo.git`: Agrega Heroku con un alias 'heroku' a nuestro repositorio

> Normalmente se trabaja solo con un remoto y a este, su alias por defecto es **"origin"**

`git remote remove heroku`: Eliminar el remoto 'heroku' de nuestro repositorio
`git remote -v`: Lista los remotos que tenemos agregados en nuestro repositorio local

`git pull origin master`: Descargar cambios a nuestro computador de la rama master del repositorio origin
`git push origin master`: Enviar cambios de nuestro repositorio local a la rama master del repositorio origin

`git status`: En la terminal puedo ver qué cambios he realizado

> +*"Instantánea preparada"**: Es el espacio donde guardanos nuestro código antes de enviarlo al repositorio

`git add nombre-archivo.html`: Agrega nombre-archivo.html a la **instantánea preparada**
`git add .`: Agrega todos los archivos a la **instantánea preparada**

`git reset nombre-archivo.html`: Quitar el archivo nombre.html de la **instantánea preparada**
`git reset .`: Quitar todos los archivos de la **instantánea preparada**

`git mv nombre-viejo.js nombre-nuevo.js`: Cambiar el nombre de un archivo
`git mv carpeta/nombre-viejo.js carpeta/nombre-nuevo.js`: Cambiar el nombre de un archivo situado dentro de una carpeta

`git stash`: Guardamos los cambios en un espacio temporal, donde podemos restaurarlos más adelante
`git stash apply`: Recuperar los cambios guardados cuando hacemos `git stash`

`git commit -m "Mensaje"`: Un `commit` es un comentario breve y descriptivo de los cambios que se realizaron.



## **Proceso de Trabajo**

**Personajes**: *Persona A*, *Persona B*, *Persona C*.

Tomaremos como ejemplo un proyecto que será la construcción de una casa.

*Persona A* inicia el repositiorio
- Crea una carpeta y accede a la carpeta 
- `git init`
- `git remote add origin git@gitlab.com:hijuliancode/demo-git-tutorial.git`

*Persona A* puede crear un archivo para enviar al repositorio, el ejemplo más común sería:
- `echo "## demo-git-tutorial" >> README.md`: Creamos un archivo README.md

*Persona A* publica el repositorio
- `git add README.md`
- `git commit -m "primer commit"`
- `git branch -M master`

*Persona B* y *Persona C* descargan el repositorio en local
- `git clone git@gitlab.com:hijuliancode/demo-git-tutorial.git`
- `cd demo-git-tutorial`

*Persona A* crea la rama `develop` y la envía al repositorio remoto
- `git checkout -b develop`
- `git push origin develop`

*Persona B* y *Persona C* actualizan su repositorio para poder tener la rama `develop`
- `git fetch --all`
- `git checkout develop`: Con `checkout` se cambia de la rama `master` a la rama `develop`

Ahora todos tienen el repositorio y pueden empezar a crear en el proyecto.

*Persona A* desea crear los planos de la casa, y desea que *Persona B* y *Persona C* tengan los planos. Aunque *Persona A* podría enviar los cambios directamente a `develop` desea que sus compañer@s primero aprueben el código y en cuanto el código este revisado y aprobado, agregarlo al proyecto.

Entonces: 

*Persona A* crea una nueva rama a partir de `develop`:
- `git checkout -b feature/planos`

*Persona A* crea los planos:
- Crea un archivo llamado planos-de-casa.js

*Persona A* envía los cambios para que las demás personas los puedan revisar:
- `git status`: Verifica que cambios ha hecho
- `git add planos-de-casa.js`: Agrega los cambios que quiere enviar
- `git push origin feature/planos`: Envía los cambios a la rama `feature/planos`

*Persona B* y *Persona C* actualizan su repositorio en local con las ramas a las que pueden acceder
- `git fetch --all`
- `git branch -a`
- `git checkout feature/planos`

Ahora *Persona B* y *Persona C* pueden ver los planos en su computador que fueron enviados por *Persona A*, ¿Pero qué pasa si *Persona B* quiere hacer una sugerencia o mejora de los planos?, ¿dónde lo pueden hacer?.

Para eso utilizamos PullRequest / MergeRequest, que es una solicitud de integrar la rama `feature/planos` en la rama `develop`, si se acepta esta integración, los planos ahora estarán en la rama `develop`.

¿Dónde hacemos el Pull Request?, En la página del proyecto en Github o Gitlab encontraremos las pestañas Pull Request y Merge Request.

Lo ideal es que la Persona que haga el PullRequest, asigne a su lider o compañero de trabajo comor revisor del código.

Allí el revisor o los compañeros pueden hacer comentarios sobre el código y solicitar cambios o también pueden directamente hacer los cambios en su computador y enviarlos al repositorio `origin`.

Enviando cambios a la rama `feature/planos`:
- Realizar cambios
- `git status`
- `git add planos-de-casa.js`
- `git commit -m "Mejora de planos de la casa"`
- `git push origin feature/cambios`

Después de integrar los cambios desde la rama que deseamos a `develop´`, podremos eliminar la rama en la que estábamos trabajando, en este caso `feature/cambios` y podremos actualizar nuestro `develop` local.

- `git checkout develop`
- `git pull origin develop
- `git branch -D feature/cambios`
- Volvemos a iniciar el proceso para crear otra rama