Git, lo Básico

Contexto

Los Estados de los archivos

Los archivos adentro de una carpeta que usa Git pueden estar tracked o no, esto significa que están asociados al control de versión o no. Los archivos tracked pueden estar en uno de tres estados:

Commited ("Comprometido")

El archivos ya quedó guardado en la base de datos local.

Modified (Modificado)

El archivo se ha modificado pero no se ha commited (comprometido) aún.

Staged ("En Escenario")

Se ha marcado el archivo para agregarlo al próximo commit.

Un flujo común de Git

1. Se obtiene el proyecto desde un directorio de git
2. Se modifican archivos
3. Se preparan para el commit, se hacen staged
4. Se hace el commit

Flujo común de Git

Instalar Git

Obtener Git

Git se puede instalar desde diferentes fuentes, esta es la oficial. Desde ahí se pueden descargar los comandos y clientes gráficos.

Además hay más programas en Internet que se pueden usar para trabajar con Git. Por ejemplo NetBeans lo soporta.

Nota: Es posible que Git ya esté instalado en el sistema. Si se reinstala podría causar algún conflicto. Revisar si está instalado, si la función instalada es suficiente no hacer nada, sino buscar la forma de instalar la versión deseada.

Configuración

Antes de empezar a usar Git se configuran algunas variables para el uso de un usuario. Estas variables se usan para guardar en los repositorios información de quien hace el commit y configurar cosas como el editor a usar. Quedan almacenadas en uno de tres directorios, ordenados por relevancia siendo más relevante el último:

• /etc/gitconfig contiene configuración para todos los usuarios del sistema en todos los repositorios
• ~/.gitconfig contiene configuración para el usuario actual
• .git/config contiene configuración para el repositorio en el que se está trabajando actualmente

A continuación algunas configuraciones básicas pero existen más configuraciones no documentadas aquí:

Configuración Personal

Esta información se usa a la hora de hacer commits.

git config --global user.name "John Flat"	     # Setea el nombre del usuario
git config --global user.email john.flat@empresa.com # Setea el mail del usuario

Configuración Ambiente de Trabajo

git config --global core.editor emacs  # Setea el editor por defecto
git config --global merge.tool vimdiff # Setea el visualizador de diferencias

Revisar configuraciones

git config --list    # Lista todas las configuraciones, pueden repetirse si se repiten en varios archivos de configuración
git config {key}     # Muestra el valor de una variable en específico
git config user.name # Muestra el valor del nombre de usuario guardado en la configuración

Instalar en un servidor

Instalar en un servidor es sencillo conceptualmente. Hay que permitir acceso a un directorio con un proyecto Git. El directorio es igual al que hay en un proyecto localmente. También hay que definir para cada usuario si puede hacer pull y push. Para esto, una forma sencilla de hacerlo es usando acceso SSH (aunque existen otra formas, ver setting up your own git server), de esta forma también se le puede dar permiso al usuario de lectura y escritura.

Para crear el repositorio hay que ingresar al servidor remoto y ejecutar algunos comandos. Lo siguiente es un ejemplo, la ubicación y el nombre del proyecto pueden cambiar. Por convención se usa el nombre de la carpeta del proyecto con .git. El comando --bare, al inicializar el proyecto, indica que se crea sin la estructura de directorio de trabajo, este directorio queda con archivos como los que quedan adentro de la carpeta .git de un repositorio de trabajo local.

cd /opt/git	  # Se navega a la ubicación donde se quiere dejar el repositorio
mkdir project.git # Se crea una carpeta donde va a quedar el repositorio
cd project.git    # Se ingresa a la carpeta del proyecto
git --bare init   # Se inicializa el proyecto

Lo mismo del código anterior se puede lograr así:

cd /opt/git		     # Se navega a la ubicación donde se quiere dejar el repositorio
git --bare init project.git  # Se crea el directorio del proyecto y se inicializa

Para obtener el repositorio el usuario puede hacer:

git clone usuario@servidor.com:/directorio/donde/esta/el/proyecto

Si se desea hacer usuarios que solo puedan interactuar con Git en este servidor, es buena idea dejar que solo usen un shell desarrollado para este propósito. Esto significa que no pueden moverse a través de los directorios, crear archivos, ver archivos y más. Para esto, hay que editar el archivo /etc/passwd (en Ubuntu por ejemplo), en el usuario que solo va a usar Git, pasar de esto:

nombreUsuario:x:1000:1000::/home/nombreUsuario:/bin/sh

a esto:

nombreUsuario:x:1000:1000::/home/nombreUsuario:/usr/bin/git-shell

Para más información de cómo interactuar con el servidor remoto, ver Git, Branching, la sección de remotes.

Comandos de Ayuda

Tres formas de obtener ayuda sobre un <verb> (verbo), es decir una acción de Git:

git help <verb>
git <verb> --help
man git-<verb>

Ejemplo de ayuda

git help config
git config --help
man git-config

Crear Repositorios

Formas de hacer que un proyecto tenga manejo de versiones usando Git. Todas las formas incluyen un directorio .git que guarda la información de versiones.

Empezar un proyecto con Git

Se crea un directorio nuevo, se navega hacia él y se inicializa Git.

mkdir nuevoProyecto # Crear nuevo directorio
cd nuevoProyecto    # Navegar a directorio
git init	    # Inicializar Git
touch x		    # Crea un archivo "x" vacío
git add x	    # Se pasa "x" al staging area, es decir, se prepara para el commit
git commit -m 'Commit inicial, solo un archivo en blanco' # Se hace el commit y queda guardado localmente

Agregar Git a un proyecto existente

Se navega al directorio donde está el proyecto exitente y se inicializa Git.

cd proyectoExistente	 # Se navega al proyecto existente
git init		 # Inicializar Git
git add archivoExistente # Se pasa "archivoExistente" al staging area, es decir, se prepara para el commit
git commit -m 'Commit inicial, se agrega archivo existente' # Se hace el commit y queda guardado localmente

Obtener un proyecto desde una fuente existente

Se obtiene una copia del repositorio y se guarda en una carpeta con el nombre del repositorio.

git clone [url]				    # Forma genérica
git clone /path/to/repository		    # Obtener copia localmente
git clone username@host:/path/to/repository # Obtener copia remotamente

Ignorar archivos

.gitignore

Git puede ignorar algunos archivos, esto se hace manualmente editando (creando) el archivo .gitignore. A continuación un ejemplo de este archivo:

# Esto es un comentario que empieza con '#'
# Omitir todos los archivos que terminan con .log
*.log
# Pero track super.log usando la negación
!super.log
# Ignorar la carpeta LOG, si existe una carpeta LOG adentro de otra carpeta no se va a ignorar
/LOG
# Ignorar todos los archivos en la carpeta error
error/
# Ignorar los archivos .txt adentro de la carpeta media
media/*.txt

Asumir que algún archivo no ha cambiado

El siguiente comando hace que Git no tome en cuenta los cambios del archivo en cuestión.

git update-index --assume-unchanged archivoParaNoTomarEnCuenta

Para deshacer esto:

git update-index --no-assume-unchanged archivoParaNoTomarEnCuenta

Git Local

Track nuevos archivos

Se dice que un archivo está siendo tracked cuando Git lo toma en cuenta. Para esto se ejecuta lo siguiente:

touch archivoNuevo   # Se crea nuevo archivo vacío
git add archivoNuevo # Se hace que Git lo agregue

Agregar archivos al staging area

Los archivos modificados no pasan directamente al siguiente commit, hay que pasarlos al staging area antes. El comando es el mismo que para agregar archivos nuevos.

echo nuevaLinea >> archivoYaEnGit # Se le agrega la línea nuevaLinea a un archivo que ya estaba en Git
git add archivoYaEnGit		  # Se pasa archivo al staging area

Mover (o renombrar) Archivos

git mv archivoViejoNombre archivoNuevoNombre # También se puede mover adentro de un directorio

Esta operación reemplaza los siguientes comandos:

mv archivoViejoNombre archivoNuevoNombre # Se mueve el archivo usando un comando del sistema operativo
git rm archivoViejoNombre		 # Se borra de Git el del nombre viejo
git add archivoNuevoNombre		 # Se agrega el del nombre nuevo

Borrar archivos

git rm archivoABorrar

Esta operación reemplaza los siguientes comandos:

rm archivoABorrar     # Borra el archivo usando un comando del sistema operativo
git rm archivoABorrar # Le avisa a Git que el archivo va a ser eliminado en el próximo commit

Borrar archivos en el staging area

git rm --cached archivoNoStaging

Quitar archivos del staging area

git reset HEAD archivoNoStaging

Revertir cambios de archivo

git checkout -- archivoAResetear

Revertir cambios en el directorio de trabajo

git reset --hard   # Deshace cambios del staging area y del directorio de trabajo
git clean -f -d    # Quita archivos no ''trackeados''
git clean -f -x -d # CUIDADO! Quita archivos no ''trackeados'' PERO ADEMÁS quita archivos ignorados (.gitignore)

Fuente: stackoverflow

Estado de Archivos

Para saber el estado de los archivos existen dos comandos posibles: git status y git diff.

git status

Muestra información del estado de los archivos que han cambiado. Puede mostrar archivos untracked, staged y modified. No muestra información de archivos que no han cambiado desde el último commit.

git status: ejemplo sin cambios

git status

Resultado:

# On branch master
nothing to commit (working directory clean)

git status: ejemplo de diferentes estados

En el siguiente ejemplo, archivoA y archivoB ya están siendo tracked y ya hicieron parte del commit anterior; ambos fueron modificados. archivoA no se agregó al staging area por lo que no va a hacer parte del commit. archivoB se agregó al staging area y se va a guardar en el próximo commit.

archivoC es un archivo nuevo que se va a guardar en el próximo commit y archivoD es un archivo nuevo no tracked por Git.

git status

Resultado:

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	modified:   archivoB
#	new file:   archivoC
#
# 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:   archivoA
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#	archivoD

git diff

git diff se usa para ver las diferencias que han tenido los archivos y no solo saber si han cambiado o no. git diff por si sólo muestra las diferencias en archivos que no están en el staging area. Para mostrar los cambios en los archivos que están en el staging area hay que usar el commando con la opción --staged: git diff --staged (para versiones anteriores a 1.6.1 cambiar --staged por --cached).

git diff: ejemplo

En archivoA se agregaron dos líneas con el mismo contenido, el nombre del archivo. En archivoB se agregó una línea con el nombre del archivo.

git diff

Resultado:

diff --git a/archivoA b/archivoA
index 7898192..c065858 100644
--- a/archivoA
+++ b/archivoA
@@ -1 +1,2 @@
-a
+archivoA
+archivoA
diff --git a/archivoB b/archivoB
index 6178079..df239cf 100644
--- a/archivoB
+++ b/archivoB
@@ -1 +1 @@
-b
+archivoB

Historial

Para ver el historial se usa el comando git log. Se puede usar con varios parámetros para obtener un output más preciso. Para obtener más información ver este link o usar git help log.

Algunos parámetros:

-(n)

(n) es la cantidad de commits a mostrar (ej: git log -3)

--since, --after

Se le entrega un valor de fecha y muestra commits solamente a partir de cierta fecha (ej: git log --since=2.weeks)

--until, --before

Se le entrega un valor de fecha y muestra commits solamente desde cierta fecha (ej: git log --until=2.weeks)

--author

Se le proporciona a Git el autor para la búsqueda

Git Remoto

Para poder colaborar en un proyecto, se necesitan servidores remotos, remotes.

Crear nuevo proyecto a partir de un remote

El siguiente comando crea una carpeta con el proyecto obtenido desde una fuente externa, crea la carpeta .git y obtiene los archivos del proyecto.

git clone username@host:/path/to/repository # Obtener copia remotamente

Agregar remote

El siguiente comando agrega un remote al proyecto Git actual, esto solo asocia un remote al proyecto pero no obtiene los archivos. nombreReferencia es un nombre arbitratio que se le da al remote para referenciarlo.

git remote add nombreReferencia username@host:/path/to/nombreRepositorio

Obtener archivos de remote

El siguiente comando obtiene los archivos desde un remote ya agregado pero no los deja en el directorio de trabajo, quedan escondidos en la base de datos de Git.

git fetch nombreReferencia

Obtener y Mezclar (merge) archivos de remote

Se obtienen los archivos y luego se mezclan con lo que hay en el directorio de trabajo.

git pull nombreReferencia HEAD # Si no especifico HEAD me pide una versión

Subir cambios a remote

Se suben los cambios al remote origin en la branch (rama) master.

git push origin master

Listar remotes

Listar remotos

git diff

Resultado:

origin
ticgit

Listar remotos con URLs

git remote -v

Resultado:

origin	/gitExample2/../gitExample (fetch)
origin	/gitExample2/../gitExample (push)
ticgit	git://github.com/schacon/ticgit.git (fetch)
ticgit	git://github.com/schacon/ticgit.git (push)

Obtener información de un remote

Con este comando se obtiene la información del remote y de las branches (ramas) que se están tracking.

git remote show ticgit

Renombre remote

git remote rename nombreViejo nombreNuevo

Quitar remote

git remote rm remoteName

Otras páginas utiles adentro del Wiki

• Git, Branching, branching es una forma de llevar el desarrollo por diferentes caminos sin que se pisen entre ellos.
• Git, Tagging, el tagging sirve para referenciar diferentes commits en el tiempo.
• Git, Stashing, el stashing sirve para limpiar las modificaciones actuales en el espacio de trabajo y guardarlas temporalmente fuera de vista. Se pueden recuperar luego.

Links útiles

• Hacer que Git autocomplete
• Hacer alias para comandos

Más información

• Git Cheat Sheet
• Git Cheatsheet • NDP Software
• Libro Oficial
• git - the simple guide