Git es un sistema rápido de control de versiones escrito en C y que se ha hecho popular sobre todo a raíz de ser el elegido para el kernel de Linux.
git supone una partida total de los conceptos tradicionales de otros sistemas de control de versiones tales como CVS o Subversion. En realidad, se organiza como un sistema de ficheros distribuido, que puede tener o no un repositorio central. Por eso, está optimizado sobre todo para grandes árboles de directorios, siendo capaz de reconocer dónde se encuentra en ese árbol y sin tener problemas a la hora de mover directorios, ficheros o lo que sea
En fin, que git se está convirtiendo hoy en día en uno de los sistemas de control de código más populares. Y no tiene mucho material para aprender, así que merece la pena dedicarle unos minutos a aprender a manejarlo.
Supongamos que ya tenemos un repositorio git creado en algún
sitio; habitualmente un sitio remoto. Lo primero que hay que hacer
es instalarse el susodicho git; lo que puedes hacer bajándotelo de
su sitio web o de tus repositorios
preferidos. Únicamente tienes que tener cuidado de buscar el
paquete git-core, porque git a secas son
las GNU Interactive Tools.
Una vez hecho esto, tendremos que hacer un checkout. El equivalente a esto en git-speak es clone. Vamos a usar el repositorio público de proyectos para este tutorial, que además, está alojado ahí mismo. Si queremos bajárnoslo:
bash$ git clone git://github.com/JJ/tutorial.git
donde tenéis es el git propiamente dicho, el comando clone, y el
git url, que contiene el "sitio" en el que está
almacenado el tutorial. Esa orden te creará un directorio llamado
tutorial, donde meterá los poquillos ficheros que
hay.
A partir de ahí, funciona poco más o menos igual que los
demás. Para añadir un fichero al repositorio, tal como uno llamado
ejemplo.1:
git add ejemplo.1
Git no contesta nada, se queda calladito. En realidad, lo que hace esta orden es simplemente decirle a git que debe prestarle atención también a este fichero. Si ahora escribimos
git status
nos dirá algo así
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: ejemplo.1
#
pero hasta que no se haga un commit , no se modificará
el repositorio local, es decir, no se hará el cambio
definitivo. Vamos a ello:
git commit -m "Fichero ejemplo añadido"
lo que dará una contestación similar a esta:
-bash-3.2$ git commit -m "Fichero ejemplo añadido"
Created commit 3c3d643: Fichero ejemplo añadido
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 ejemplo.1
Pero todavía no se ha propagado ese cambio a todos los
repositorios. A diferencia de los otros sistemas, donde el commit
es ya definitivo, git sirve para desarrollar de forma distribuida,
así que commit sólo hace un cambio en la versión local del
repositorio. Para enviarlo al repositorio global, y que los demás
se lo puedan bajar, se usa push
git push git@github.com:JJ/tutorial.git
Si os dais cuenta, el URL que hemos usado es diferente; mientras que antes habíamos usado un URL genérico, que no permite cambiar lo que hay, habrá que usar este de aquí para subir los cambios; para lo que tendremos que tener permiso, claro.
Si no tenemos permiso para modificar, siempre nos queda el consuelo
de actualizar lo que otros hayan cambiado. Y si subir los cambios
de llama pull, ¿cómo será para bajárselo?
> git pull
que responderá algo así por este estilo
remote: Generating pack...
remote: Done counting 5 objects.
remote: Result has 3 objects.
remote: Deltifying 3 objects...
remote: 100% (3/3) done
remote: Total 3 (delta 1), reused 0 (delta 0)
Unpacking 3 objects...
100% (3/3) done
* refs/remotes/origin/master: fast forward to branch 'master' of git://github.com/JJ/tutorial
old..new: 608f3d3..e3eb172
Merge made by recursive.
index.mhtml | 187 ++++++++++++++++++++++++++---------------------------------
1 files changed, 82 insertions(+), 105 deletions(-)
lo que, por cierto, se hace bastante rápido. Git tiene en cuenta cuáles son los cambios por fichero, y en este momento, si hay algún cambio local que entre en conflicto con la actualización, también lo diría.
Con esto más o menos se puede manejar con git: clone-add-commit-pull-push y listo
Tampoco es que sea demasiado complicado lo de crear un repositorio,
y es equivalente a como se hace con otros sistemas. Siplemente
git init seguido por lo que se ha comentado
anteriormente: add (si es necesario), commit y push. En este tutorial explica
también como hacer un puñaillo de cosas más, como añadir varias
personas al desarrollo. La idea es que no es necesario un
repositorio central: dos personas pueden ir fusionando sus
repositorios, sin necesidad de recurrir a uno central.
Un tutorial de git en el mismo sitio donde se desarrolla git, git para usuarios de cvs, y una escueta introducción con unos 20 comandos. Git tiene varias decenas de comandos, e incluso un interfaz gráfico (o a través de web), así que por un lado no resulta difícil de usar, pero resulta un poco más complicado de dominar.