Git and Git Flow Cheat Sheet

Índice

• Configuración
• Archivos de Configuración
• Crear
• Cambios locales
• Buscar
• Historial de Commits
• Ramas & Etiquetas
• Actualizar & Publicar
• Fusionar & Rebasar
• Deshacer
• Git Flow

---

Configuración

Mostrar la cofiguración actual:

$ git config --list

Mostrar la configuración local:

$ git config --local --list

Mostrar la configuración global:

$ git config --global --list

Mostrar la configuración del sistema:

$ git config --system --list

Establecer un nombre que es identificable de crédito cuando se revise el historial de versiones:

$ git config --global user.name “[nombre apellido]”

Establecer una dirección de email que será asociada con cada marca histórica:

$ git config --global user.email “[email-válido]”

Establecer coloreado automático de la línea de comandos de Git para una fácil revisión:

$ git config --global color.ui auto

Establecer el editor global para commits:

$ git config --global core.editor vi

---

Archivos de Configuración

Archivo de configuración específico del repositorio [--local]:

<repo>/.git/config

Archivo de configuración específico del usuario [--global]:

~/.gitconfig

Archivo de configuración del sistema [--system]:

/etc/gitconfig

---

Crear

Clonar un repositorio existente:

Existen dos maneras:

Vía SSH

$ git clone ssh://usuario@dominio.com/repo.git

Vía HTTP

$ git clone http://dominio.com/usuario/repo.git

Crea un nuevo repositorio local:

$ git init

---

Cambios Locales

Cambios en el directorio de trabajo:

$ git status

Cambios en archivos rastreados:

$ git diff

Agregar todos los cambios actuales al siguiente commit:

$ git add .

Agregar algunos cambios de <archivo> para el siguiente commit:

$ git add -p <archivo>

Realizar un commit de todos los cambios locales en los archivos rastreados:

$ git commit -a

Realizar un commit de los cambios previamente almacenados en el área de pruebas (stage area):

$ git commit

Realizar un commit con un mensaje:

$ git commit -m 'aquí el mensaje'

Realizar un commit saltándose el área de pruebas y agregando un mensaje:

$ git commit -am 'aquí el mensaje'

Realizar un commit a alguna fecha anterior:

git commit --date="`date --date='n day ago'`" -am "Mensaje del commit"

Cambiar último commit:

_{¡No modificar commits ya publicados!}

$ git commit -a --amend

Cambiar fecha del último commit:

GIT_COMMITTER_DATE="date" git commit --amend

Cambiar fecha del autor del último commit:

git commit --amend --date="date"

Mover cambios no confirmados (uncommitted changes) de la rama actual a otra rama:

git stash
git checkout branch2
git stash pop

Restaurar cambios del área de pruebas (stage area) a la rama actual:

git stash apply

Eliminar la última serie de cambios del área de pruebas (stage area):

git stash drop

---

Buscar

Un texto en todos los archivos del directorio:

$ git grep "Hola"

Un texto en cualquier versión:

$ git grep "Hola" v2.5

---

Historial de Commits

Mostrar todos los commits, empezando por los más recientes (se mostrará el hash, información sobre el autor, fecha y título del commit):

$ git log

Mostrar todos los commits (sólo se mostrará el hash y el mensaje del commit):

$ git log --oneline

Mostrar todos los commits de un usuario específico:

$ git log --author="usuario"

Mostrar los cambios a través del tiempo de un archivo específico:

$ git log -p <archivo>

Mostrar commmits que están presentes sólamente en remote/branch al lado derecho:

$ git log --oneline <origin/master>..<remote/master> --left-right

Quién cambió, qué y cuándo en <archivo>:

$ git blame <archivo>

Mostrar reference log:

$ git reflog show

Borrar reference log:

$ git reflog delete

---

Ramas & Etiquetas

Listar todas las ramas locales:

$ git branch

Listar todas las ramas remotas:

$ git branch -r

Cambiar rama HEAD:

$ git checkout <rama>
$ git switch <rama>

Crear nueva rama y cambiar a esta:

$ git checkout -b <rama>
$ git switch -c <rama>

Crear nueva rama basada en la rama HEAD actual:

$ git branch <nueva-rama>

Crear nueva rama de seguimiento basada en una rama remota:

$ git branch --track <nueva-rama> <rama-remota>

Eliminar una rama local:

$ git branch -d <rama>

Forzar eliminación de una rama local:

_{¡Perderás los cambios sin fusionar!}

$ git branch -D <branch>

Marcar el commit actual con una etiqueta:

$ git tag <tag-name>

Marcar el commit actual con una etiqueta que incluye un mensaje:

$ git tag -a <etiqueta>

---

Actualizar & Publicar

Listar todos los remotos configurados actuales:

$ git remote -v

Mostrar información sobre un remoto:

$ git remote show <remoto>

Agregar un nuevo repositorio, nombrado <remoto>:

$ git remote add <remoto> <url>

Quitar el repositorio <remoto> agregado previamente:

$ git remote rm <remoto>

Descargar todos los cambios de <remoto>, pero no integrarlos al HEAD:

$ git fetch <remoto>

Descargar cambios y fusionarlos/integrarlos directamente al HEAD:

$ git remote pull <remote> <url>

Obtener todos los cambios del HEAD al repositorio local:

$ git pull origin master

Obtener todos los cambios del HEAD al repositorio local sin fusionar:

git pull --rebase <remote> <branch>

Publicar cambios locales en un remoto:

$ git push remote <remoto> <rama>

Eliminar una rama en el remoto:

$ git push <remoto> :<rama> (desde Git v1.5.0) ó $ git push <remoto> --delete <rama> (desde Git v1.7.0)

Publicar tus etiquetas:

$ git push --tags

---

Fusionar y Rebasar

Fusionar en tu HEAD actual:

$ git merge <rama>

Rabasar tu actual HEAD sobre <rama>:

_{¡No rebasar commits ya publicados!}

$ git rebase <rama>

Aborta un rebase:

$ git rebase --abort

Continuar un rebase después de resolver conflictos:

$ git rebase --continue

Usar tu herramienta de fusión configurada para resolver conflictos:

$ git mergetool

Usar tu editor para manualmente resolver conflictos y (después de resueltos) marcar el archivo como resuelto:

$ git add <archivo-resuelto>

$ git rm <archivo-resuelto>

Aplastando commits (squashing):

$ git rebase -i <commit-just-before-first>

Ahora reemplazando esto,

pick <commit_id>
pick <commit_id2>
pick <commit_id3>

con esto,

pick <commit_id>
squash <commit_id2>
squash <commit_id3>

---

Deshacer

Descartar todos los cambios locales en tu directorio de trabajo:

$ git reset --hard HEAD

Sacar todos los archivos del área de pruebas (es decir, deshacer el último git add):

$ git reset HEAD

Descartar cambios locales de un archivo específico:

$ git checkout HEAD <archivo>
$ git restore <archivo>

Revertir un commit (produciendo un nuevo commit con los cambios contrarios):

$ git revert <commit>

Reestablecer tu puntero HEAD a un commit anterior y descartar todos los cambios desde entonces:

$ git reset --hard <commit>

Reestablecer tu puntero HEAD al estado actual de una rama remota.

$ git reset --hard <remote/branch> es decir, upstream/master, origin/my-feature

Reestablecer tu puntero HEAD a un commit anterior y preservar todos los cambios en el área de pruebas (stage area):

$ git reset <commit>

Reestablecer tu puntero HEAD a un commit anterior y preservar los cambios locales sin confirmar (uncommitted changes):

$ git reset --keep <commit>

Remover los archivos que fueron accidentalmente agregados al commit antes de ser añadidos al .gitignore:

$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"

---

Git-Flow

Índice

• Configuración
• Iniciando
• Features (características)
• Hacer un lanzamiento
• Hotfixes (revisiones)
• Comandos

---

Configuración

Necesitas tener Git instalado como prerequisito. Git flow trabaja en OSX, Linux y Windows.

OSX Homebrew:

$ brew install git-flow

OSX Macports:

$ port install git-flow

Linux (basado en Debian):

$ apt-get install git-flow

Windows (Cygwin):

Necesitas wget y util-linux para instalar git-flow.

$ wget -q -O - --no-check-certificate https://github.com/nvie/gitflow/raw/develop/contrib/gitflow-installer.sh | bash

---

Iniciando

Git flow necesita ser inicializado con el fin de personalizar la configuración de tu proyecto. Empieza usando git-flow inicializándolo dentro de un repositorio git existente:

Inicilizar:

Tendrás que responder un par de preguntas acerca de las convenciones de nombramiento de tus ramas. Es recomendable usar los valores por defecto.

git flow init

---

Features (características)

Desarrolla nuevos features para próximos lanzamientos. Típicamente sólo existen en los repositorios de desarrolladores.

Iniciar un nuevo feature:

Esta acción crea una nueva rama (feature branch) basada en la rama de desarrollo (develop branch) y cambia a esta.

git flow feature start MIFEATURE

Terminar un feature:

Finalizar el desarrollo de un feature. Esta accion realiza lo siguiente:

1) Fusiona MIFEATURE con la rama de desarrollo (develop branch).

2) Elimina la rama del feature (feature branch).

3) Cambia nuevamente a la rama de desarrollo (develop branch).

git flow feature finish MIFEATURE

Publicar un feature:

¿Estás desarrollando un feature colaborativamente? Publica un feature en el servidor remoto, así puede ser usado por otros usuarios.

git flow feature publish MIFEATURE

Obteniendo un feature publicado:

Obtener un feature publicado por otro usuario.

git flow feature pull origin MIFEATURE

Rastrear un origin feature:

Puedes rastrear un feature en origin usando:

git flow feature track MIFEATURE

---

Hacer un lanzamiento

Apoya la preparación de un nuevo lanzamiento a producción. Permite la corrección de pequeños bugs y la preparación de metadatos para un lanzamiento.

Empezar un lanzamiento:

Para empezar un lanzamiento, usa el comando "release" de git flow. Este crea una rama de lanzamiento (release branch) de la rama de desarrollo (develop branch). Opcionalmente puedes sustituir el hash sha-1 de un commit [BASE] para empezar el lanzamiento desde este. El commit debe estar en la rama de desarrollo (develop branch).

git flow release start RELEASE [BASE]

Es aconsejable publicar la rama de lanzamiento (release branch) después de crearla para permitir publicar commits de otros desarrolladores. Hazlo de manera similar a publicar un feature con el comando:

git flow release publish RELEASE

(Puedes rastrear un lanzamiento remoto con el comando: git flow release track RELEASE)

Terminando un lanzamiento:

Terminando un lanzamiento es uno de los grandes pasos en la ramificación de git. Realiza varias acciones:

1) Fusiona la rama de lanzamiento (release branch) con la rama master.

2) Etiqueta la publicación con su nombre.

3) Vuelve a fusionar la rama de lanzamiento (release branch) en la rama de desarrollo (develop branch).

4) Elimina la rama de lanzamiento (release branch).

git flow release finish RELEASE

No olvides de publicar tus etiquetas con git push --tags

---

Hotfixes (revisiones)

Los hotfixes surgen de la necesidad de actuar inmediatamente ante un estado indeseado en una versión de producción en vivo. Puede ser desramificada de la correspondiente etiqueta en la rama master que marca la versión de producción.

Emepezar un hotfix en git flow:

Como los otros comandos de git flow, un hotfix es inicializado con:

$ git flow hotfix start VERSION [BASENAME]

El argumento versión marca el nombre de publicación del nuevo hotfix. Opcionalmente puedes especificar un nombre base desde cual empezar.

Terminar un hotfix:

Al finalizar un hotfix este se fusiona nuevamente con la rama de desarrollo y la rama master. Adicionalmente la fusión master es etiquetada con la versión del hotfix.

git flow hotfix finish VERSION

---

Comandos

---

Esquema de git flow

---