##################################################

## Resumen comandos Git ##

## ==================== ##

## ##

## github.com/srus/taller-git ##

## ##

## Sergio Rus (sergiorus.com) ##

## ##

##################################################

Configuración de git

====================

# Para configuración específica del proyecto, quitar --global

# configuración del nombre

git config --global user.name "John Doe"

# configuración del email

git config --global user.email johndoe@example.com

# para activar el color en los diff

git config --global color.diff auto

Configuración de un repositorio privado (acceso SSH)

====================================================

# situarse en el directorio del proyecto y poner:

git clone --bare /home/usuario/proyecto/.git /home/usuario/repositorio/nombre-proyecto

# ya tenemos un repositorio remoto

# eliminar el proyecto y bajarse una copia del repositorio remoto

git clone usuario@maquina:repositorio/nombre-proyecto/

.gitignore (para ignorar archivos en git)

=========================================

Los archivos sólo se ignoran si previamente no se han añadido al index,

es decir, deben aparecer como "Untracked files".

# ejemplo de archivo .gitignore

===============================

# Ignorar los siguientes archivos

proyecto/archivo1.txt

proyecto/archivo2.txt

# Ignorar archivos ocultos de Eclipse

.classpath

.project

# No ignorar este archivo

!.gitignore

# Ignorar un directorio completo

directorio/*

Comandos generales en git

=========================

# inicializar repositorio

git init

# commit sobre el repositorio local

git commit -am "mensaje del commit"

# estado del repositorio local

git status

# Añadir nuevos archivos al index

git add *

# Eliminar archivos del index

git rm file1 file2

# Actualizar el index con los archivos eliminados.

# Evita tener que hacer git rm file1 file2 file3 ...

git add -u

# diferencias entre versiones

git diff --cached

# traer los cambios de todas las ramas remotas, sin actualizar ninguna rama local

git fetch

# comparar los cambios entre una rama local y una remota

git diff rama_local rama_remota

# efectuar los cambios en la rama local actual

git merge rama_remota

# actualizar (fetch + merge) la rama actual del repo local con la rama remota "experimental"

# (origin almacena la dirección del repositorio desde donde se hizo el clone)

git pull origin experimental

# o bien simplemente usar:

git pull

# Ejemplo:

# actualizar la rama actual del repositorio local con los últimos cambios

# de la rama "master" del repositorio remoto

git pull usuario@maquina:/ruta/al/repositorio master

# info del repositorio local

git config -l

# info del repositorio remoto (p.e. para ver ramas remotas)

git remote show origin

# Añadir un repositorio remoto

git remote add <nombre_repositorio>

# Ejemplo:

# Traer todos los cambios desde un repositorio remoto llamado "repo_ejemplo"

git fetch repo_ejemplo

# y luego aplicar los cambios de la rama remota "master" a la rama actual

git merge repo_ejemplo/master

# Eliminar un repositorio remoto (dejar de seguirlo)

git remote rm <nombre_repositorio>

# "congelar" y poner los cambios actuales a salvo, sin hacer commit, para volver más tarde a ellos

git stash

# recuperar los cambios

git stash apply

# limpiar el stash

git stash clear

Manejando ramas

===============

# crear un branch local

git branch nuevo_branch

# cambiar a otro branch

git checkout nombre_branch

# crear un branch y cambiarse a este inmediatamente

git checkout -b nuevo_branch

# crear un branch que apunte a uno remoto

git branch nuevo_branch origin/nombre_branch

# crear un branch que apunte a uno remoto y cambiarse a este inmediatamente

git checkout -b nuevo_branch origin/nombre_branch

# fusionar un branch con el actual

git merge nuevo_branch

# crear una rama remota o actualizarla:

git push origin nuevo_branch

# debe existir también una rama local "nuevo_branch"

# listar los branch locales

git branch

# listar los branch remotos

git branch -r

# listar todos los branch

git branch -a

# renombrar un branch

git branch -m oldname newname

# eliminar un branch

git branch -d nombre_branch

# eliminar un branch remoto (en el repositorio remoto)

git push origin :nombre_branch

# Nota:

# En las últimas versiones de Git, por defecto se impide hacer push a un branch remoto

# que no admite 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 con una variable que

# por seguridad se configura a un valor por defecto. Esta variable se puede modificar (por seguridad,

# 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 un remote-tracking branch (origin/nombre_branch)

git branch -r -d origin/nombre_branch

# hacer que un branch local haga un seguimiento de una rama remota,

# de forma que los push/pull sean más simples: ahora sólo sería

# necesario hacer "git pull" o "git push"

git branch --track nuevo_branch origin/nuevo_branch

# Elimina las ramas locales que ya no existen en el repositorio remoto.

# Usar --dry-run para hacer una simulación antes.

git remote prune origin

Eliminación de archivos / Volviendo atrás

=========================================

# descartar cambios en un archivo y volver a la última versión

git checkout -- ruta_archivo

# volver a una versión concreta de un archivo

git checkout HASH -- ruta_archivo

# modificar un antiguo commit (se modifica sólo ese commit):

git revert HASH

# Descartar todos los cambios (eliminando/añadiendo archivos) y

# volver a un estado concreto del proyecto:

# ¡Cuidado! ¡Esto elimina todos los commits hechos!

# No aplicarlo en commits anteriores a un git-push, ya que

# no podremos hacer push sobre el repositorio remoto.

git reset --hard HASH

# Para 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 reset --hard 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.

# Para modificar la duración, hacemos:

git config --add gc.reflogexpire [ 30.days | 30.minutes | 30.seconds ]

Manipulando commits

====================

# Modificar el último commit

git commit --amend

# Unir varios commits en uno. Se usa 'squash' para unir el commit con el anterior.

# ¡¡Sólo en el caso de no haber hecho ya un push al repositorio remoto!!

git rebase -i HASH

# Aplicar los cambios introducidos por uno o varios commit creando un nuevo commit

git cherry-pick HASH

# Crear patches con los cambios de la rama actual respecto de la rama develop

# Esto genera un archivo (patch) por cada commit, con el formato 00XX-<mensaje_commit>.patch

git format-patch develop

# 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)

================

# etiquetar un commit

git tag <nombre_etiqueta>

# eliminar una etiqueta

git tag -d <nombre_etiqueta>

# enviar etiquetas al repositorio remoto

git push <repositorio> --tags

# eliminar un tag remoto

git push <repositorio> :refs/tags/<nombre_etiqueta>

Git y Subversion (git-svn)

==========================

# commit

git svn dcommit

# Subir nuevo proyecto con subversion

svn import project http://host_name/svn_dir/repository_name/project -m "First Import"

# inicializar git-svn

git svn init http://host_name/svn_dir/repository_name/project

# recuperar la versión

git svn fetch -rREVISION

# Hasta aquí, los pasos para iniciar un proyecto

# actualizar proyecto local

git svn rebase