• Working tree: Directorio de trabajo donde se crea un repositorio.
• Index: Índice de cambios que se han realizado entre un commit y otro en un proyecto o working tree.
• HEAD: Keyword para la última versión.

El repositorio (o working tree) se creará en el directorio donde se llame al siguiente comando:

$ git init

Una vez se tiene el repositorio se han de agregar elementos.

Para añadir un elemento haremos:

$ git add file.txt
$ git add directory

La acción de agregar se realiza recursivamente, por lo que si añadimos un directorio al working tree se añadirán también sus subdirectorios y ficheros.

Con el mismo parámetro add agregamos un cambio.
Por ejemplo, si hemos modificado file.txt que ya estaba en el repositorio:

$ git add file.txt

$ git mv file.txt directory

$ git rm file.txt

$ git commit -m "the 1st commit"

Un commit realiza un snapshot del working tree.
Cada commit se identifica mediante un hash.
Podemos realizar un commit de cambios y que actualice automáticamente los ficheros que ya existían en el working tree (pero no añadirá nuevos):

$ git commit -a -m "commit message"

$ git clone repo cloned_repo

Ver nombre del repositorio que viene.

$ git remote

Ver información de un repositorio remoto.

$ git remote show repo_name

$ git fetch

Esto sube los cambio pero no los actualiza, para ello debemos hacer:

$ git fetch
$ git merge origin/master

O, en un único comando:

$ git pull

Cada vez que se realiza un commit la versión actual apunta a la anterior y, en cascada, se van almacenando los cambios en el proyecto.

Sin haber realizado ningún cambio (add):

$ git checkout somefile.txt

Habiendo realizado algún cambio (sólo un fichero):

$ git reset HEAD somefile.txt

Habiendo realizado algún cambio (todo el proyecto):

$ git reset HEAD

Esto crearía un segundo commit idéntico al escogido pero posterior al actual.

$ git revert 068b9b9

Para identificarlos sin tener que referirse a ellos por el hash.
Taggear el último:

$ git tag broken

Taggear uno concreto:

$ git tag working 3720b35

Ahora podríamos haccer: git diff working..broken
Otro uso que tiene el tag de commits es taggear por versión: git tag 1.0.3

$ git tag

Para eliminar la tag broken:

$ git tag -d broken

Historial largo:

$ git log

Historial corto:

$ git log --pretty=oneline --abbrev-commit

Historial completo:

$ git log -p

Formatear el historial:

$ git log --all --pretty=format:"%h %cd %s (%an)" --since='7 days ago'
$ git log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short

$ git status

Comparar un commit con su predecesor:

$ git show 3720b35

Comparar dos commits:

git diff a2a1eb3..068b9b9

$ git config user.name "John Q. Public"
$ git config user.email "johnq@example.com"

Para todos los proyectos:

$ git config --global user.name "John Q. Public"
$ git config --global user.email "johnq@example.com"

Agregar colores (para acciones como diff, status…):

$ git config --global color.ui auto

Las branches permiten dividir el desarrollo de un proyecto separando los cambios que se realicen.

$ git branch

De las que aparezcan, la que tiene el asterisco es con la que estamos trabajando.
Podemos ver más info haciendo:

$ git branch -v

Ver todas las branches (remotas también):

$ git branch -a

Para crear una branch haremos git branch <name> <commit>

$ git branch newfeature

$ git checkout newfeature
$ git checkout master

$ git branch -d newfeature

Imaginemos que hemos desarrollado una nueva característica (en newfeature) a partir de un punto en el proyecto (3rd commit) y ahora queremos agregarlo a la branch principal.

$ git merge newfeature

En el directorio personal de tu usuario existirá un archivo denominado .gitconfig, este tendrá tu configuración.

[alias]
  co = checkout
  ci = commit
  st = status
  br = branch
  hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
  type = cat-file -t
  dump = cat-file -p

Si los agregramos, al hacer git co estaremos haciendo un git checkout (por ejemplo).

• Explicación

Podemos indicar reglas para ignorar los ficheros de un directorio con el fichero .gitignore del proyecto.
Podemos hacerlo globalmente con:

$ git config --global core.excludesfile ~/.gitignore_global

O haciendo que no se añadan al repositorio con desde .git/info/exclude.

• Gitignore recomendado para Python
• Repositorio

$ git hist --max-count=1

$ git reset

… Y dejarlo como estaba.

$ git reset --hard

• https://github.com/

$ git clone https://github.com/epintor/Hindoor.git

Realizar cualquiera de los comandos de modificación:

• git add
• git rm
• git mv

Hacer un commit.

$ git commit -a

Si (y sólo si) hay cambios en la branch 'master':

$ git pull origin master

Subir los cambios (a la branch 'master'):

$ git push origin master

git branch

La que sale con estrella es la activa.

$ git branch new_branch
$ git checkout new_branch

Para ver cambios realizados en un repositorio:

• web
• artículo

• web

Visor para GNOME:

• web

Plugin para eclipse:

• web
• tutorial

En Ubuntu existe el paquete gitosis que instala un servidor GIT.

• Libro de la comunidad de GIT: http://book.git-scm.com/
• Los 10 mejores tutoriales: http://sixrevisions.com/resources/git-tutorials-beginners/