git-cheatsheet-es.txt

# =============================================================================
#                                Chuleta Git
# =============================================================================
#
#
# Comandos básicos
# ================
#
# Inicializar repositorio Git:
#     git init
#
# Clonar un repositorio remoto:
#     git clone <ruta_repo>
#
#     Ejemplos (SSH, HTTPS y directorio local, respectivamente):
#         git clone git@github.com:srus/git-cheatsheet.git
#         git clone https://github.com/srus/git-cheatsheet.git
#         git clone /home/sergio/repos/git-cheatsheet.git
#
# Estado del repositorio:
#     git status
#
# Info del repositorio:
#     git config -l
#
# Nombre de la rama actual:
#     git branch
#
# Añadir nuevos archivos al repositorio:
#     git add <file1> <file2>
#
#     Ejemplo: Añadir todos los archivos:
#         git add *
#
# Ver modificaciones en los archivos:
#     git diff [<commit1>|<branch1>] [<commit2>|<branch2>] [--name-only]
#
#     Ejemplos:
#
#         Ver modificaciones en la rama actual antes de hacer commit:
#             git diff
#
#         Comparar el último commit (HEAD) con el anterior (HEAD^):
#             git diff HEAD^
#
#         Comparar la rama actual con la rama "master":
#             git diff master
#
#         Comparar dos ramas:
#             git diff <branch1> <branch2>
#
#         Comparar los cambios entre una rama local y otra remota:
#             git diff <rama_local> <repo>/<rama_remota>
#
# Commit con mensaje corto (la opción `-a` para añadir los cambios al "index" o
# "staging area"):
#     git commit -a -m "Resumen del commit"
#
# Commit con mensaje largo (la opción `-a` para añadir los cambios al "index" o
# "staging area"):
#     git commit -a
#
# Historial de commits:
#     git log
#
# Comparar dos ramas imprimiendo sólo la cabecera del mensaje del commit:
#     git log --oneline [--graph] <rama1>..<rama2>
#
# Filtrar historial de commit mostrando sólo aquellos con archivos eliminados:
#     git log --diff-filter=D --summary
#
# Ver commits que están en una rama y no en otra:
#     git log <rama1> ^<rama2>
#
#     Notación alternativa:
#         git log <rama2>..<rama1>
#
#     También se pueden omitir los merges:
#         git log --no-merges <rama1> ^<rama2>
#
#     Nota:
#         También se pueden ver con Gitk usando los mismos parámetros.
#
# Ver todos los cambios introducidos en un determinado commit:
#     git show [<commit>] [--name-only]
#
#     Con `--name-only` sólo se listan los archivos modificados.
#
#     Ejemplos:
#         git show
#         git show HEAD
#         git show 123456
#         git show --name-only 123456
#
# Ver el contenido de un archivo tal y como se vería en un determinado commit:
#     git show <commit>:<file>
#
#     Ejemplos:
#         git show master:path/to/file
#         git show foo_branch:path/to/file
#
# Inspeccionar cambios en un rango determinado de líneas de un archivo:
#     git blame -L <line_number>,+<length> <file_path>
#
#     Ejemplo:
#         git blame -L 123,+20 foo/bar.py
#
# Buscar texto en archivos del repositorio:
#     git grep <pattern> [<commit>]
#
#     Ejemplos:
#         git grep 'FooBar'
#         git grep 'FooBar' master
#         git grep 'FooBar' rama1
#         git grep -i 'foobar' 1234556789
#
# Eliminar archivos del repositorio:
#     git rm <file1> <file2>
#
# Actualizar el repositorio con los archivos eliminados (evita tener que hacer
# `git rm file1 file2 file3`):
#     git add -u
#
# Crear una rama:
#     git branch <nombre_rama>
#
# Cambiar de rama:
#     git checkout <nombre_rama>
#
# Incorporar (fusionar) una rama en la rama actual:
#     git merge <nombre_rama>
#
# Traer los cambios de una rama remota (sin actualizar ninguna rama local):
#     git fetch <repo> <nombre_rama>
#
#     Ejemplo:
#         git fetch origin master
#
# Traer los cambios de todas las ramas remotas, sin actualizar ninguna rama
# local:
#     git fetch --all
#
# Incorporar (fusionar) una rama remota en la rama actual:
#     git merge <rama_remota>
#
#     Ejemplo:
#         git merge origin/master
#
# Actualizar (fetch + merge) la rama actual con los cambios de una rama remota:
#     git pull <repo> <nombre_rama>
#
#     Ejemplo: actualizar la rama actual con los últimos cambios de la rama
#     "master" del repositorio remoto "origin":
#         git pull origin master
#
# Fusionar la rama actual en otra de un repositorio remoto (creando
# una nueva rama remota en caso de que no existiera):
#     git push <repo> <rama_remota>
#
#     Ejemplo:
#         git push origin master
#
# Fusionar la rama local especificada en otra rama remota:
#     git push <repo> <rama_local>:<rama_remota>
#
#     Ejemplo:
#         git push origin master:master
#
# Info de los repositorios remotos:
#     git remote -v
#
# Info detallada de un repositorio remoto:
#     git remote show <repo>
#
# Añadir un repositorio remoto:
#     git remote add <repo> <user>@<host>:<ruta_repo>
#
#     Ejemplo:
#         git remote add github git@github.com:srus/git-cheatsheet.git
#
# Eliminar un repositorio remoto:
#     git remote rm <repo>
#
# Renombrar un repositorio remoto:
#     git remote rename <nombre_actual> <nombre_nuevo>
#
# Cambiar URL de un repositorio remoto:
#     git remote set-url <repo_name> <repo_url>
#
# Agrupar varios repositorios remotos bajo un mismo nombre para actualizarlos
# todos con un único push:
#     git remote add <name> <repo1_url>
#     git remote set-url --all --push <name> <repo2_url>
#     git remote set-url --all --push <name> <repo3_url>
#
#
# Ramas
# =====
#
# Crear una rama local:
#     git branch <nombre_rama>
#
# Cambiar de rama:
#     git checkout <nombre_rama>
#
# Crear una rama y cambiarse a ésta:
#     git checkout -b <nombre_rama>
#
# Crear una rama que apunte a otra remota:
#     git branch <nombre_rama> <repo>/<nombre_rama>
#
# Crear una rama que apunte a otra remota y cambiarse a esta inmediatamente:
#     git checkout -b <nombre_rama> <repo>/<nombre_rama>
#
# Hacer que la rama actual apunte a otra remota:
#     git branch -u <repo>/<nombre_rama>
#
# Incorporar (fusionar) una rama en la actual. Si las ramas han divergido la
# historia de ambas ramas se mantendrán intactas: visualmente se puede ver cómo
# ambas ramas se unen en un nuevo commit creado por Git:
#     git merge <nombre_rama>
#
# Fusionar una rama en la actual incorporando los cambios en un solo commit:
#     git merge --squash <nombre_rama>
#     git commit [-c <commit_id>]
#
# Incorporar una rama A en la actual B re-aplicando los cambios introducidos por
# la rama B respecto a A. Git modifica la historia de la rama B:
#     git rebase <nombre_rama>
#
#     Nota:
#     Los commits introducidos en B por `git merge A` desaparecen.
#
# Enviar (fusionar) la rama actual en otra de un repositorio remoto (o crear
# una nueva rama remota en caso de que no existiera):
#     git push <repo> <nombre_rama>
#
#     Ejemplo:
#         git push origin master
#
#     Con la opción "-u" podemos indicar qué repositorio es el principal para
#     la rama actual, evitando tener que indicar el repositorio y la rama en
#     cada push/pull, pudiendo escribir simplemente `git push` y `git pull`:
#         git push -u origin master
#
# Listar las ramas locales:
#     git branch
#
# Listar las ramas remotas:
#     git branch -r
#
# Listar todas las ramas:
#     git branch -a
#
# Renombrar una rama:
#     git branch -m <nombre_actual> <nombre_nuevo>
#
# Establecer el repositorio principal para la rama actual, lo que evita tener
# que indicar el repositorio y la rama en cada push/pull, pudiendo escribir
# simplemente `git push` y `git pull`:
#     git branch -u <repo>/<nombre_rama>
#
# Eliminar una rama:
#     git branch -d <nombre_rama>
#
# Eliminar una rama remota (en el repositorio local):
#     git branch -r -d <repo>/<nombre_rama>
#
# Eliminar una rama remota (en el repositorio remoto):
#     git push <repo> :<nombre_rama>
#
#     En las últimas versiones de Git, por defecto se impide hacer push a una
#     rama remota que no admita "fast-forward" (aunque se use "--force"), por
#     ejemplo en el caso de que se trate de una rama "huérfana" cuya historia
#     ha sido modificada. Esto se hace mediante una variable que por seguridad
#     se configura a un valor por defecto. Esta variable se puede modificar (de
#     forma temporal). Para ello hay que moverse al directorio donde reside el
#     repositorio que se quiere configurar y poner:
#         git config receive.denyDeleteCurrent ignore
#
#     Ahora ya se puede hacer push sobre cualquier rama remota.
#     Para volver a activar la protección:
#         git config receive.denyDeleteCurrent refuse
#
# Eliminar las ramas remotas en el repositorio local que ya no existen en el
# repositorio remoto. Usar "--dry-run" para hacer una simulación.
#     git remote prune [--dry-run] <repo>
#
#
# Eliminación de archivos / Deshaciendo cambios
# =============================================
#
# Deshacer los cambios de un commit:
#     git revert <HASH>
#
# Deshacer los cambios de los últimos 3 commits. Con la opción "--no-commit"
# crea un único commit con todos los cambios a deshacer. Otra opción es usar el
# ID de los commits:
#     git revert --no-commit HEAD~3..HEAD
#
# Volver a una versión concreta de un archivo:
#     git checkout <HASH> <ruta_archivo>
#
#     Ejemplos:
#         git checkout -- src/foobar.txt      # última versión
#         git checkout HEAD src/foobar.txt    # última versión
#         git checkout HEAD^ src/foobar.txt   # penúltima versión
#         git checkout 123456 src/foobar.txt  # versión con commit 123456
#
# Volver a una versión concreta del repositorio:
#     git reset --hard <HASH>
#
#     ¡Cuidado! ¡Esto elimina los commits más recientes!
#     Sólo se debe usar con los commits anteriores a un `git push`, ya que
#     en otro caso no podremos hacer push sobre el repositorio remoto.
#
# Forzar el push en el repositorio remoto (NO RECOMENDABLE):
#     git push origin +master
#
# Recuperar commits eliminados:
#     git reflog
#
#     Una vez identificado el commit a recuperar, hacer:
#         git cherry-pick <HASH>
#
#     Por defecto reflog almacena los commits de los últimos 90 días. A partir
#     de esa fecha git-gc eliminará los commits de más de 90 días. Podemos
#     modificar la duración con:
#         git config --add gc.reflogexpire [30.days | 30.minutes | 30.seconds]
#
#
# Manipulando commits
# ===================
#
# Commit reutilizando el mensaje de otro commit:
#     git commit -c <commit_id>
#
# Modificar el mensaje del último commit:
#     git commit --amend
#
# Reset del author en el mensaje del último commit:
#    git commit --amend --reset-author
#
# Commit con mensaje corto saltándose el hook "pre-commit":
#     git commit -am "mensaje" --no-verify
#
# Abrir una sesión interactiva para manipular los cambios actuales. Por ejemplo
# para dividir los cambios en varios commits:
#
#     git add -p
#
#     Ejemplo de sesión para dividir los cambios en 2 commits:
#         > git add -p
#         > Stage this hunk [y,n,q,a,d,/,s,e,?]? s
#         >     => Split into 2 hunks.
#         >     => @@ -1,3 +1,2 @@
#         > Stage this hunk [y,n,q,a,d,/,j,J,g,e,?]? y
#         > Stage this hunk [y,n,q,a,d,/,K,g,e,?]? q
#         > git commit -m "Cambios 1"
#         > git commit -m "Cambios 2"  # commit del resto de cambios
#
# Modificar la historia (commits) del repositorio local, por ejemplo para unir
# (squash) varios commits, editarlos (edit) o reescribir (reword) el mensaje.
# ¡Sólo debe usarse `rebase` si aún no se ha hecho push al repositorio remoto!
#     git rebase -i <HASH>
#
#     Ejemplo: Cambiar la fecha de un commit:
#         git rebase -i 2dfd1127680
#         [marcar el commit para editar (e - edit)]
#         git commit --amend --date='Mon Mar 20 13:10:06 2017 +0100'
#         git rebase --continue
#
# Guardar temporalmente los cambios actuales sin hacer commit y volver a la
# última versión del repositorio:
#     git stash
#
# Ver las modificaciones de un stash:
#     git stash show -p stash@{<stash_id>}
#
#     Ejemplo:
#         git stash show -p stash@{0}
#
# Recuperar los cambios temporalmente guardados:
#     git stash apply
#
# Listar los "stash":
#     git stash list
#
# Limpiar los "stash":
#     git stash clear
#
# Aplicar los cambios introducidos por uno o varios commits creando nuevos
# commits:
#     git cherry-pick <ID>
#
#     Ejemplos:
#         git cherry-pick 2ja45fj3
#         git cherry-pick 34jga83...54as5gs7
#         git cherry-pick HEAD..foobar
#
#     Con la opción -n sólo aplica los cambios en el index, requiriendo un
#     commit manual. Esto es útil para crear un único nuevo commit con todos los
#     cambios introducidos por varios commits (por ejemplo, de una rama):
#
#         git cherry-pick -n HEAD..foobar
#
# Crear un único parche con todos los cambios en la rama actual respecto a otra:
#     git diff <rama> > patch.diff
#
# Aplicar cambios de un parche en el index:
#     git apply <parche>
#
# Crear "parches" con los cambios en la rama actual respecto de <ID>, donde
# <ID> puede ser un commit o el nombre de una rama. Esto genera un archivo
# "patch" por cada commit, con el formato 00XX-<mensaje_commit>.patch:
#     git format-patch <ID>
#
# Aplicar todos los parches almacenados en un directorio a la rama actual.
# Esto crea un commit por cada parche.
#     git am <ruta_directorio>/00*
#
#
# Etiquetas (tags)
# ================
#
# Listar etiquetas:
#    git tag
#
# Etiquetar un commit:
#     git tag <nombre_etiqueta>
#
# Eliminar una etiqueta:
#     git tag -d <nombre_etiqueta>
#
# Enviar etiquetas al repositorio remoto:
#     git push <repo> --tags
#
# Eliminar una etiqueta en el repositorio remoto:
#     git push --delete <repo> <nombre_etiqueta>
#
#
# Submódulos
# ==========
#
# Añadir un repositorio Git como un submódulo:
#     git submodule add <ruta_a_submódulo> <nombre_submódulo>
#
# Clonar un proyecto que contiene submódulos:
#     git clone --recursive <repo>
#
# Hacer que `git diff` muestre los cambios de los submódulos:
#     git config [--global] diff.submodule log
#
# Mostrar resumen de cambios (commits) en los submódulos:
#     git config [--global] status.submodulesummary 1
#
# Actualizar submódulo(s):
#     git submodule update --remote --merge [<nombre_submódulo>]
#
# Hacer un `git push` comprobando antes que todos los submódulos estén ya
# sincronizados con sus respectivos repositorios remotos:
#     git push --recurse-submodules=check <repo> <nombre_rama>
#
#
# Configuración de Git
# ====================
#
# Para configuración específica del proyecto, ignorar la opción `--global`.
#
# Configuración del nombre:
#     git config [--global] user.name "Sergio Rus"
#
# Configuración del email:
#     git config [--global] user.email sergio@example.com
#
# Activar el color en los diff:
#     git config [--global] color.diff auto
#
# Añadir un alias:
#     git config [--global] alias.supdate 'submodule update --remote --merge'
#
#
# Repositorios bare
# =================
#
# Crear un repositorio bare:
#     git clone --bare <repo> <repo.git>
#
# Añadir un working tree (worktree) a un repositorio bare:
#     git worktree add <worktree_path> <branch_name>
#
#     Nota:
#     Git permite enlazar varios worktree a un mismo repositorio, cada uno
#     asociado a una rama distinta.
#
# Cambiar la rama asociada a un worktree en un repositorio bare:
#     git --work-tree=<worktree_path> checkout --force --ignore-other-worktrees <branch_name>
#
#     Nota:
#     Por defecto sólo puede haber un worktree asociado a cada rama, pero esta
#     restricción se puede ignorar con la opción '--ignore-other-worktrees'.
#
#
# .gitignore (para ignorar archivos en Git)
# =========================================
#
# Los archivos sólo se ignoran si previamente no se han añadido al
# "repositorio", es decir, deben aparecer como "untracked files".
#
# Ejemplo de archivo ".gitignore":
#
#    # Ignorar los siguientes archivos
#    foobar.txt
#    proyecto/foobar.txt
#    proyecto/.foobar
#
#    # Ignorar archivos "log"
#    .log
#
#    # No ignorar "foobar.log"
#    !foobar.log
#
#    # Ignorar el directorio "tmp"
#    tmp
#
#
# Gitk (GUI para Git)
# ===================
#
# Mostrar todas las ramas:
#     gitk --all
#
# Inspeccionar cambios en un rango determinado de líneas de un archivo:
#     gitk -L<line_number>,+<length>:<file_path>
#
#     Ejemplo:
#         gitk -L123,+20:foo/bar.py