path: root/introduzione_a_git.rest

Introduzione a GIT
==================

.. footer:: LIFO

.. contents::
   :class: handout

Un nuovo progetto
-----------------

.. class:: handout

   Iniziamo un nuovo progetto che vogliamo salvare sotto git: non serve 
   preoccuparsi di avere un server, e neanche un nome pubblicabile 
   per il progetto, basta creare una directory (che potremo rinominare 
   in futuro), dire a git di crearci un repository e poi si può inizare 
   subito a lavorare.

::

   $ mkdir greeter
   $ cd greeter/
   $ git init
   Initialized empty Git repository in /home/[...]/greeter/.git/

Qualche file
------------

.. class:: handout

   Creiamo i nostri file, in questo caso un programma in python 
   che saluterà le persone.

::

   $ mkdir greeter
   $ touch greeter/__init__.py
   $ cat > greeter/greeter.py
   class Greeter:
       """ """
   $ cat > greeter.py
   #!/usr/bin/env python

   def main():
       pass

   if __name__ == '__main__': main()
   $ chmod 755 greeter.py


GIT
---

.. class:: handout

   Con ``git status`` possiamo vedere che git si è accorto dell'esistenza 
   di alcuni file, ma sono *untracked*, ovvero non considerati 
   dal controllo delle revisioni.

::

   $ git status
   # On branch master
   #
   # Initial commit
   #
   # Untracked files:
   #   (use "git add <file>..." to include in what will be committed)
   #
   #       greeter.py
   #       greeter/
   nothing added to commit but untracked files present (use "git add" to track)


In staging
----------

.. class:: handout

   Aggiungiamo quel che abbiamo fatto alla *staging area*, ovvero 
   diciamo a git di prendere in considerazione quella versione 
   del file perché venga successivamente salvata.

::
   
   $ git add greeter.py greeter/
   $ git status
   # On branch master
   #
   # Initial commit
   #
   # Changes to be committed:
   #   (use "git rm --cached <file>..." to unstage)
   #
   #       new file:   greeter.py
   #       new file:   greeter/__init__.py
   #       new file:   greeter/greeter.py
   #

Altre mod
---------

.. class:: handout

   Facendo altre modifiche e riguardando ``git status`` ci possiamo 
   accorgere di come git non salvi automaticamente tutti i cambiamenti 
   presenti nei file di cui tiene traccia, ma solo quelli che gli
   vengono indicati esplicitamente da salvare.

::

   $ cat > greeter/__init__.py
   from greeter import Greeter
   $ git status
   # On branch master
   #
   # Initial commit
   #
   # Changes to be committed:
   #   (use "git rm --cached <file>..." to unstage)
   #
   #       new file:   greeter.py
   #       new file:   greeter/__init__.py
   #       new file:   greeter/greeter.py
   #
   # Changes not staged for commit:
   #   (use "git add <file>..." to update what will be committed)
   #   (use "git checkout -- <file>..." to discard changes in working directory)
   #
   #       modified:   greeter/__init__.py
   #

Ultimi preparativi
------------------

.. class:: handout

   A questo punto possiamo aggiungere anche le ultime modifiche:

::
   
   $ git add greeter/__init__.py
   $ git commit


.. class:: handout

   Se è la prima volta che usiamo git su questo computer salviamo qualche 
   informazione su di noi, nel mio caso:

::

   $ git config --global user.name "Elena ``of Valhalla'' Grandi"
   $ git config --global user.email valhalla@trueelena.org

Commit
------

.. class:: handout

   E finalmente possiamo creare il nostro primo commit, un insieme 
   di file in una loro determinata versione al quale vengono associati 
   alcuni metadati (autore, data, ...) e soprattutto un identificativo 
   che è un hash crittografico dei contenuti.

   Il comando ``git commit`` apre un editor con il quale scrivere 
   un commento da associare al commit. Di solito si scrive una descrizione 
   breve da una riga (una 60ina di caratteri), e poi eventualmente 
   altre informazioni più approfondite.

::

   Skeleton for the new project.
   # Please enter the commit message for your changes. Lines starting
   # with '#' will be ignored, and an empty message aborts the commit.
   # On branch master
   #
   # Initial commit
   #
   # Changes to be committed:
   #   (use "git rm --cached <file>..." to unstage)
   #
   #       new file:   greeter.py
   #       new file:   greeter/__init__.py
   #       new file:   greeter/greeter.py
   #

::
   
   ".git/COMMIT_EDITMSG" 14L, 377C written
   [master (root-commit) b54e94f] Skeleton for the new project.
    3 files changed, 9 insertions(+)
    create mode 100755 greeter.py
    create mode 100644 greeter/__init__.py
    create mode 100644 greeter/greeter.py


LOG
---

.. class:: handout

   Con il comando ``git log`` possiamo vedere l'identificativo 
   completo del commit appena fatto, e qualche metadato.

::

   $ git log
   commit b54e94fde972281ca31a56ef0d36204addd4906b
   Author: Elena ``of Valhalla'' Grandi <valhalla@trueelena.org>
   Date:   Thu Nov 15 19:05:42 2012 +0100

       Skeleton for the new project.

.. class:: handout

   E con ``git show`` possiamo vedere i dettagli del commit, con 
   tutte le modifiche che sono state introdotte (sotto forma 
   di diff dalla versione precedente).

   Possiamo vedere come non serva scrivere tutto l'identificativo 
   del commit, ma bastino i primi caratteri sufficienti ad 
   identificarlo univocamente nel repository.

::

   $ git show b54e
   commit b54e94fde972281ca31a56ef0d36204addd4906b
   Author: Elena ``of Valhalla'' Grandi <valhalla@trueelena.org>
   Date:   Thu Nov 15 19:05:42 2012 +0100

       Skeleton for the new project.

   diff --git a/greeter.py b/greeter.py
   new file mode 100755
   index 0000000..b96deee
   --- /dev/null
   +++ b/greeter.py
   @@ -0,0 +1,6 @@
   +#!/usr/bin/env python
   +
   [...]

Iniziamo a lavorarci
--------------------

.. class:: handout

   Iniziamo a lavorare al progetto, riempiendo qualche file.

``greeter/greeter.py``::

   class Greeter:
       """ """

       def greet(self):
           print "Hello World!"

``greeter.py``::

   #!/usr/bin/env python

   import greeter

   def main():
       grt = greeter.Greeter()
       grt.greet()

   if __name__ == '__main__': main()

Diamo in pasto a git
--------------------

.. class:: handout

   E vediamo di nuovo il workflow quotidiano: aggiungiamo le modifiche 
   fatte alla staging area con ``git add`` per poi darle in pasto 
   a ``git commit``.

   In questo caso anziché usare un editor per descrivere il commit 
   ci accontentiamo di una descrizione breve, passata per comodità 
   con l'opzione ``-m``.

::

   $ git add greeter.py greeter/greeter.py
   $ git commit -m 'Generic greetings'
   [master adfbc73] Generic greetings
    2 files changed, 8 insertions(+), 1 deletion(-)
   $ git status
   # On branch master
   nothing to commit (working directory clean)
   $ git log
   commit adfbc7340ac1af8b1dc80ebb1526c7b2b9ad4d1f
   Author: Elena ``of Valhalla'' Grandi <valhalla@trueelena.org>
   Date:   Thu Nov 15 19:08:29 2012 +0100

       Generic greetings

   commit b54e94fde972281ca31a56ef0d36204addd4906b
   Author: Elena ``of Valhalla'' Grandi <valhalla@trueelena.org>
   Date:   Thu Nov 15 19:05:42 2012 +0100

       Skeleton for the new project.

amend
-----

.. class:: handout

   Se ci si è accorti di aver sbagliato qualcosa nella descrizione 
   del commit lo si può cambiare con ``git commit --amend``.

::

   $ git commit --amend

::

   Generic greetings.

   # Please enter the commit message for your changes. Lines starting
   # with '#' will be ignored, and an empty message aborts the commit.
   # On branch master
   # Changes to be committed:
   #   (use "git reset HEAD^1 <file>..." to unstage)
   #
   #       modified:   greeter.py
   #       modified:   greeter/greeter.py

::

   [master 8cdccd9] Generic greetings.
    2 files changed, 8 insertions(+), 1 deletion(-)

.. class:: handout

   Notare come l'identificativo del commit sia cambiato: di fatto 
   ``git commit --amend`` cancella l'ultimo commit e ne crea 
   uno nuovo. 

   Questo significa che questo comando non si può usare nel caso 
   in cui si sia già distribuito in qualche modo il commit in questione, 
   dato che la cosa può causare problemi negli altri repository.

gitignore
---------

.. class:: handout

   Lavorando al progetto capita che si generino file che si vogliono 
   ignorare, ad esempio i risultati di compilazione: basta aggiungerli 
   al file ``.gitignore`` perché non vengano considerati.

::

   $ ./greeter.py 
   Hello World!
   $ git status
   # On branch master
   # Untracked files:
   #   (use "git add <file>..." to include in what will be committed)
   #
   #       greeter/__init__.pyc
   #       greeter/greeter.pyc
   nothing added to commit but untracked files present (use "git add" to track)
   $ echo "*.pyc" >> .gitignore
   $ git status
   # On branch master
   # Untracked files:
   #   (use "git add <file>..." to include in what will be committed)
   #
   #       .gitignore
   nothing added to commit but untracked files present (use "git add" to track)
   $ git add .gitignore
   $ git commit -m '.gitignore: ignore .pyc files.'

Aggiungere funzionalità
-----------------------

.. class:: handout

    Vogliamo aggiungere al nostro progetto la capacità di salutare 
    persone diverse; dato che dobbiamo fare un po' di modifiche, 
    perché non creare un nuovo *feature branch*?

    Questo è il workflow naturale per git: ogni nuova funzionalità 
    viene sviluppata a parte in un branch apposito, e poi 
    integrata nel branch principale, che in questo modo rimane 
    sempre funzionante.

::

    $ git checkout -b people

``greeter/greeter.py``::

    class Greeter:
        """ """

        def greet(self,greetee="World"):
            print "Hello %s!"%gretee

::

   $ git add greeter/greeter.py


Che bel sole là fuori!
----------------------

.. class:: handout

   Anche se non abbiamo finito di implementare la nuova feature, 
   ci accorgiamo che c'è un bel sole e vogliamo andare a lavorarci 
   al parco (o dobbiamo correre a prendere il treno), e vogliamo 
   spostarci a lavorare sul portatile.

   Niente di più semplice: committiamo quel che abbiam fatto fin'ora, 
   cloniamo il repository su una chiavetta usb, e possiamo lavorare 
   dal portatile senza problemi.

::

   $ git commit -m 'greeter/greeter.py: support for multiple greetees.'
   $ cd $USB_KEY
   $ git clone /home/[...]/greeter
   Cloning into 'greeter'...
   done.
   $ cd greeter
   $ git branch
   * people
   $ git branch -a
   * people
     remotes/origin/HEAD -> origin/people
     remotes/origin/master
     remotes/origin/people

.. class:: handout

   Con il comando ``git branch`` scopriamo che il clone ha già preso 
   come branch corrente quello che stavamo usando sul primo repository, 
   e con l'opzione ``-a`` possiamo vedere tutti i branch che abbiamo 
   a disposizione.

   Con git ogni copia comprende tutta la storia di tutti i branch 
   disponibili nel repository che si è copiato, e quindi è possibile 
   continuare a lavorare anche se ci si dovesse trovare senza connessione 
   ad internet. Inoltre ogni clone del repository è un backup completo, 
   utile nel caso in cui succeda qualcosa ad un hard disk.

Aggiunte successive
-------------------

.. class:: handout

   Finiamo le modifiche di cui ci stavamo occupando, committiamo.

``greeter.py``::

    #!/usr/bin/env python

    import sys

    import greeter

    def main():
        grt = greeter.Greeter()
        try:
            grt.greet(sys.argv[1])
        except IndexError:
            grt.greet()

    if __name__ == '__main__': main()

::

   $ git add greeter.py
   $ git commit -m 'greeter.py: support for a custom greetee.'
   [people 59b9d39] greeter.py: support for a custom greetee.
    1 file changed. 6 insertions(+). 1 deletion(-)

Ora di rientrare
----------------

.. class:: handout

   Riattacchiamo la chiavetta al PC, cerchiamo di riportare le modifiche 
   dal repository su chiavetta al repository su hard disk con 
   il comando ``git push``.

::

   $git push

.. class:: handout

   C'è un problema: 

Reintegriamo in master
----------------------

.. class:: handout


Un bel backup
-------------

.. class:: handout


Finalmente pubblichiamo
-----------------------

.. class:: handout

::

   $ $BROWSER http://gitorious.org

Non github?
-----------

Alternative:

* <http://repo.or.cz/>_
* gitolite_ + gitweb_ self-hosted
* ...

.. _gitolite: 
.. _gitweb: 

..
   vim: set filetype=rst: