Tutorial git

---

El contenido a continuación se mantiene por motivos históricos.

Por favor rediríjanse a NUEVO TUTORIAL: https://github.com/asrob-uc3m/tutoriales/blob/master/software/version-control/git.md

---

Esto es un tutorial básico para Git. Pincha aquí para un tutorial más extenso.

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 estas tienen un gran número de archivos de código fuente. Al principio, Git se pensó como un motor de bajo nivel sobre el cual otros pudieran escribir la interfaz de usuario o front end. Sin embargo, Git se ha convertido desde entonces en un sistema de control de versiones con funcionalidad plena. Hay algunos proyectos de mucha relevancia que ya usan Git, en particular, el grupo de programación del núcleo Linux.

Tutorial Git para Ubuntu

Los siguientes pasos funcionan para una máquina Ubuntu. Sin embargo, el procedimiento (orden de operaciones) es el mismo para cualquier otra Distribución o Sistema Operativo.

1. Lo primero es intalar un cliente Git. Aquí opté por el más básico, el de interfaz de texto.

$ sudo apt-get install git

2. Acto seguido deberéis descargar el repositorio sobre el que vais a trabajar. Por defecto descarga la última revisión ("HEAD").

$ git clone https://github.com/nburrus/nestk.git

3. A medida que generéis contenido, éste no se "agrega" al repositorio. Al comprobar el "status" del git tecleando:

$ git status
# On branch master  <-- Esta es la rama en la que actualmente te encuentras
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   README.md  <--  Este es el archivo que se ha modificado
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	fichero.cpp <--  Este es el archivo nuevo que se ha creado
#
no changes added to commit (use "git add" and/or "git commit -a")

4.a Podrás agregar un fichero:

$ git add fichero.cpp

4.b O solamente las últimas modificaciones sobre ficheros previamente añadidos:

$ git add -u

4.c O todos los ficheros añadidos y modificados:

$ git add .

5. Viendo el "status" veréis que:

$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	modified:   README.md
#	new file:   fichero.cpp
#

6. Ahora hay que subir todo al repositorio local que se encuentra en el propio ordenador. Este es un repositorio intermedio entre tu repositorio local y el repositorio global

$ git commit -m "He mejorado mi nivel de usuario Git!"

7. Por último hay que subir los cambios al repositorio global. Para poder hacer esto el administrador te tiene que dar permiso.

$ git push

8. Para descargar la última versión del server

$ git pull

Configuraciones Git

Configuraciones iniciales para poner tu nombre y email (git avisará si es necesario).

Para configurar tu usuario en todos los repositorios del PC:

$ git config --global user.name "ASROB admin"
$ git config --global user.email asrobuc3m@gmail.com

Para configurar tu usuario en un solo repositorio:

$ git config user.name "ASROB admin"
$ git config user.email asrobuc3m@gmail.com

Para ver el usuario y email configurados en el repositorio:

$ git config user.name
$ git config user.email

Manejo básico de ramas

Las ramas sirven para desarrollar de forma paralela al repositorio principal. Cuando se crea una nueva funcionalidad en el código se crea una rama. Se desarrolla la funcionalidad, se prueba y cuando ya funciona perfectamente se integra en la rama principal (llamada habitualmente rama master).

1. Ver el estado de las ramas

$ git branch  #-- Te dice las ramas que hay en tu repositorio local
$ git branch -a  #-- "all" te dice las ramas que hay en repositorios local y global (que figuran como remotes/origin/...)
$ git fetch -p  #-- Actualiza la lista de ramas teniendo en cuenta ramas remotas borradas por otras personas

2. Crear y subir/bajar una rama

$ git branch testing #-- Crea una nueva rama en el repositorio local llamada testing (se hace una vez para crear)
$ git checkout testing #-- Cambia de la rama actual a la rama testing (se puede hacer siempre que se quiera cambiar de rama)
$ git add new_file.cpp #-- Añadimos un nuevo archivo en la rama testing
$ git commit -m "añadido new_file.cpp a la rama testing" #-- hace commit al repositorio local
$ git push origin testing #-- sube los cambios al repositorio global (si te pide hacer algo más, hazlo)
$ git pull origin testing #-- ya puedes bajar los últimos cambios a tu ordenador

3. Si quieres juntar una rama (p.ej. testing) a la rama master (se podría a cualquier otra cambiando master por el nombre de la rama)

$ git checkout master  #-- cambia de la rama actual a la rama master
$ git merge testing  #-- junta la rama testing con la principal

4. Eliminar una rama (p.ej. testing, que tendría sentido despues del merge) hay que hacer los dos pasos siguientes

$ git branch -d testing  #-- borra localmente la rama testing
$ git push origin --delete testing  #-- borra en el repositorio global la rama testing

5. Otra buena práctica para localizar un punto importante de tu código es hacer un "tag"

$ git tag  #-- muestra una lista de todos los tags
$ git show v1.0  #-- muestra información detallada del tag llamado v1.0
$ git tag -a v1.0 -m "mi tag v1.0"  #-- crea un tag llamado v1.0 en el repositorio local
$ git push origin v1.0  #-- sube el tag al servidor remoto

Otros comandos

$ git commit -a -m="subiendo archivos cpp"-> Sube también los archivos marcados como modificados, sin necesidad de volver a hacer git add
$ git diff-> muestra diferencias entre un archivo modificado  y otro que se ha modificado anteriormente pero que está stagged, es decir, está en el repositorio local. 
$ git diff --cached -> differencias entre un archivo modificado y el mismo guardado en el HEAD
$ git rm file.txt -> borra un archivo
$ git log -> para ver el historial de commits
$ git log --since=2.weeks -> varianete del anterior
$ git push origin master-> Manda tu copia al servidor global
$ git push->idem
$ git pull-> actualizar tu repositorio local a la version más nueva
$ git config --global alias.ci commit -> alias para no tener que escribir git commit sino git ci
$ git config --global alias.st status -> alias para no tener que escribir git status sino git st
$ git config --global core.excludesfile ~/.gitignore -> dentro de .gitignore se meten los archivos a ignorar
$ git config --global credential.helper cache -> guarda tu contraseña en caché durante 15 min para que no la tengas que meter una y otra vez
$ git config --global credential.helper 'cache --timeout=3600' -> guarda tu contraseña durante una hora
$ git rev-list HEAD --count --> permite ver el número total de commits
$ git shortlog -sne --> permite ver el número de commits de cada desarrollador
$ git fetch origin --> este comando junto con el de más abajo elimina todos los cambios locales y pone la versión del servidor.
$ git reset --hard origin/master

Git submodules

• https://chrisjean.com/git-submodules-adding-using-removing-and-updating/