1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
|
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à
-----------------------
Che bel sole là fuori!
----------------------
Ora di rientrare
----------------
Un bel backup
-------------
Finalmente pubblichiamo
-----------------------
::
$ $BROWSER http://gitorious.org
Non github?
-----------
Alternative:
* <http://repo.or.cz/>_
* gitolite_ + gitweb_ self-hosted
* ...
.. _gitolite:
.. _gitweb:
..
vim: set filetype=rst:
|