20 de comenzi GIT pentru lucrul de zi cu zi

Comenzi de bază pentru lucrul cu repozitoriile

Aceste comenzi sunt folosite pentru mentenanţa repozitoriilor git.

git-init(1) sau git-clone(1) pentru a crea un repozitoriu nou.
git-fsck(1) pentru a verifica dac repozitoriul conţine erori.
git-gc(1) pentru a optimizarea şi compactarea repozitoriului.

Exemple

Verificarea şi curăţarea repozitoriului.

$ git fsck (1)
$ git count-objects (2)
$ git gc (3)

Executat fără --full este de obicei mai ieftin ca consum de resurse şi asigură repozitorului o stare de "sănătate" destul de bună.
Enumeră obiecte orfane şi spaţiul consumat de ele.
Sterge obiectele orfane şi efectuează şi alte operaţiuni de optimizare a repozitoriului.

Comenzi pentru lucrul individual al programatorilor

Un programator individual nu face schimb de patch-uri cu alţii, şi lucrează singur într-un singur repozitoriu, folosind următoarele comenzi.

git-show-branch(1) pentru a vedea ramificarea curentă a directorului git.
git-log(1) pentru a vedea evoluţia directorului git.
git-checkout(1) şi git-branch(1) pentru a schimba ramificarea directorului git.
git-add(1) pentru a lucra cu index-ul git.
git-diff(1) şi git-status(1) pentru a vedea starea fişierelor din director.
git-commit(1) înregistrează modificările curente ale fişierelor în git.
git-reset(1) anulează schimbările necomise.
git-checkout(1) (cu parametrii căii de acces) pentru a anula schimbările.
git-merge(1) pentru a combina modificările a două sau mai multe ramificări.
git-rebase(1) schimbă ramificarea de bază a directorului git
git-tag(1) marchează starea curentă a directorului git.

Exemple

Folosirea unei arhive ca punct de start pentru un repozitoriu nou.

$ tar zxf frotz.tar.gz
$ cd frotz
$ git-init
$ git add . (1)
$ git commit -m "Imaporarea directorului frotz."
$ git tag v2.43 (2)

se iniţiază un repozitoriu git nou în directorul curent
se marchează starea curentă a directorului cu eticheta "v2.43"

Lucrul cu ramificările

$ git checkout -b alsa-audio (1)
$ edit/compile/test
$ git checkout -- curses/ux_audio_oss.c (2)
$ git add curses/ux_audio_alsa.c (3)
$ edit/compile/test
$ git diff HEAD (4)
$ git commit -a -s (5)
$ edit/compile/test
$ git reset --soft HEAD^ (6)
$ edit/compile/test
$ git diff ORIG_HEAD (7)
$ git commit -a -c ORIG_HEAD (8)
$ git checkout master (9)
$ git merge alsa-audio (10)
$ git log --since='3 days ago' (11)
$ git log v2.43.. curses/ (12)

Crează o ramificare nouă a directorului.
Întoarce curses/ux_audio_oss.c la starea iniţială
Notificaţi git că aţi adăugat un fişier nou; ştergerile şi modificările vor fi înregistrate dacă rulaţi comanda git commit -a mai tîrziu.
Arată diferenţa faţă de HEAD
Trimite.
Anulaţi ultima trimitere, lăsînd ce este în ramificarea curentă.
Arată diferenţa de la anularea ultimii trimiteri.
Retrimite ceea ce s-a anulat la pasul precedent folosind mesajul original.
Treceţi la ramura principală.
Combină ramificarea creată la primul pas cu ramificare principală.
Arată trmiterile (commit); alte moduri de selectare a înregistrărilor pot fi combinate: --max-count=10 - arată ultimile 10 trimiteri, --until=2005-12-10, etc.
Arată schimbările de la v2.43 încoace care au afectat fişierele din directorul curses/.

Comenzi pentru lucrul în echipă al programatorilor

Fiecare programator dintr-o echipă colaborează cu ceilalţi membri ai echipei folosind comenzi adăugătoare celor pentru lucrul individual al programatorilor.

git-clone(1) copiază un repozitoriu într-un director.
git-pull(1) and git-fetch(1) de la actualizează repozitorul curent cu alt repozitor sau altă ramificare.
git-push(1) trimite repozitorul curent spre un altul.
git-format-patch(1) pregăteşte un patch pentru timiterea prin e-mail

Exemple

Ia o copie a repozitoriului şi trimite modificările înapoi.

$ git clone git://git.kernel.org/pub/scm/.../torvalds/linux-2.6 my2.6
$ cd my2.6
$ edit/compile/test; git commit -a -s (1)
$ git format-patch origin (2)
$ git pull (3)
$ git log -p ORIG_HEAD.. arch/i386 include/asm-i386 (4)
$ git pull git://git.kernel.org/pub/.../jgarzik/libata-dev.git ALL (5)
$ git reset --hard ORIG_HEAD (6)
$ git gc --prune (7)
$ git fetch --tags (8)

Ciclu normal de dezvoltare repetat de una sau mai multe ori.
Extrage modificările în formă de patch pentru a fi trimise pe e-mail.
git pull actualizează ramura curentă.
Verifică ce s-a actualizat în directorul indicat.
Aduce dintr-o ramură anume a unui anume repozitoriu şi combină cu repozitoriul curent.
Anulează operaţiunea precedentă.
Curăţă rămăşiţele de la operaţiunea precedentă.
Actualizaţi periodic lista de tag-uri oficiale. Ele se stochează în .git/refs/tags/.

Trimiteţi în alt repozitoriu.

satellite$ git clone mothership:frotz frotz (1)
satellite$ cd frotz
satellite$ git config --get-regexp '^(remote|branch)\.' (2)
remote.origin.url mothership:frotz
remote.origin.fetch refs/heads/*:refs/remotes/origin/*
branch.master.remote origin
branch.master.merge refs/heads/master
satellite$ git config remote.origin.push \
           master:refs/remotes/satellite/master (3)
satellite$ edit/compile/test/commit
satellite$ git push origin (4)

mothership$ cd frotz
mothership$ git checkout master
mothership$ git merge satellite/master (5)

Copiază repozitoriul frotz de pe maşina mothership.
Clonarea face aceste setări ale variabilelor implicit (by default). Configurează git pull pentru a aduce şi stoca ramificările de pe mothership în remotes/origin/*.
Configurează git push să trimită modificările din ramificarea locală master în remotes/satellite/master pe mothership.
Modificările curente vor f itrimise în remotes/satellite/master pe mothership. Această manevră poate fi folosită ca o metodă de back-up.
Pe maşina mothership, fuzionaţi lucrul terminat pe satelit în ramificarea principală.

Crearea unei ramificări marcate cu o etichetă

$ git checkout -b private2.6.14 v2.6.14 (1)
$ edit/compile/test; git commit -a
$ git checkout master
$ git format-patch -k -m --stdout v2.6.14..private2.6.14 |
  git am -3 -k (2)

Crează o versiunea privată a repozitoriului.
Trimite toate schimbările din ramura private2.6.14, în ramura master fără o "fuziune" formală.

Comenzi pentru integrator

Integratorul într-un proiect primeşte schimbările făcute de echipă, le revizuieşte, le integrează şi publică rezultatul. În afară de comenzile folosite de ceilalţi, el mai are nevoie de următoarele comenzi.

git-am(1) Extrage şi integrează patch-urile primite pe e-mail.
git-pull(1) Aduce modificările de la alţi membri şi le integrează în ramificarea curentă.
git-format-patch(1) Pregăteşte patch-urile pentru a fi trimise pe e-mail.
git-revert(1) Anulează un commit în caz de necesitate.
git-push(1) Trimite/publică ramificare curentă.

Exemple

Comenzi de zi cu zi pentru integrator

$ git status (1)
$ git show-branch (2)
$ mailx (3)
& s 2 3 4 5 ./+to-apply
& s 7 8 ./+hold-linus
& q
$ git checkout -b topic/one master
$ git am -3 -i -s -u ./+to-apply (4)
$ compile/test
$ git checkout -b hold/linus && git am -3 -i -s -u ./+hold-linus (5)
$ git checkout topic/one && git rebase master (6)
$ git checkout pu && git reset --hard next (7)
$ git merge topic/one topic/two && git merge hold/linus (8)
$ git checkout maint
$ git cherry-pick master~4 (9)
$ compile/test
$ git tag -s -m "GIT 0.99.9x" v0.99.9x (10)
$ git fetch ko && git show-branch master maint 'tags/ko-*' (11)
$ git push ko (12)
$ git push ko v0.99.9x (13)

Văd starea curentă a repozitoriului.
Văd ramificările curente.
Verific cutia poştală şi repartizez patch-urile primite.
Le aplic interactiv şi adaug semnătura mea.
Creez o ramificare, aplic cealaltă parte de patch-uri şi adaug semnătura mea.
Trec una din ramificarile locale pe pe ramificarea de bază.
Trec pe ramificarea pu la starea next.
Combin ramificările pregătite.
Aduc un fix important dintr-o versiune anterioară.
Fac o etichetă.
Mă asigur că nu am întors accidental ramura master dincolo de ce era deja publicat. Ramura ko e o scurtătură pentru ce am în repozitoriul meu la kernel.org, şi arată cam aşa:
```
$ cat .git/remotes/ko
URL: kernel.org:/pub/scm/git/git.git
Pull: master:refs/tags/ko-master
Pull: next:refs/tags/ko-next
Pull: maint:refs/tags/ko-maint
Push: master
Push: next
Push: +pu
Push: maint
```
În lista afişată de git show-branch, master ar trebui să aibă tot ce are ko-master, şi next ar trebui să aibă tot ce are ko-next.
Publică cea mai recentă versiune.
Publică şi eticheta creată.

Administrarea repozitoriului

Administratorul repozitoriului foloseşte comenzile următoare pentru a seta menţine accesul la repozitoriu pentru brogramatori.

git-daemon(1) pentru a permite accesul la repozitoriu.
git-shell(1) poate fi folosit ca shell SSH pentru access-ul la repozitoriu.

update hook howto este un exemplu bun de menţinere a unui repozitoriu.

Exemple

Se presupune că există următoarea linie în /etc/services

$ grep 9418 /etc/services
git             9418/tcp                # Git Version Control System

Lansaţi serverul git din inetd pentru publicarea directorului /pub/scm.

$ grep git /etc/inetd.conf
git     stream  tcp     nowait  nobody \
  /usr/bin/git-daemon git-daemon --inetd --export-all /pub/scm

(De fapt e o singură linie)

Lansaţi serverul git din xinetd pentru publicarea directorului /pub/scm.

$ cat /etc/xinetd.d/git-daemon
# default: off
# description: Serverul git oferă acces la repozitoriile git
service git
{
        disable = no
        type            = UNLISTED
        port            = 9418
        socket_type     = stream
        wait            = no
        user            = nobody
        server          = /usr/bin/git-daemon
        server_args     = --inetd --export-all --base-path=/pub/scm
        log_on_failure  += USERID
}

Acesta este configurarea pentru Fedora. Vedeţi documentaţia xinetd(8) pentru alte sisteme de operare.

Daţi acces de push/pull pentru programatori.

$ grep git /etc/passwd (1)
alice:x:1000:1000::/home/alice:/usr/bin/git-shell
bob:x:1001:1001::/home/bob:/usr/bin/git-shell
cindy:x:1002:1002::/home/cindy:/usr/bin/git-shell
david:x:1003:1003::/home/david:/usr/bin/git-shell
$ grep git /etc/shells (2)
/usr/bin/git-shell

Shell-ul de log-in e setat la /usr/bin/git-shell, care nu permite nimic în afară de git push şi git pull.
în multe distribuţii /etc/shells trebuie să conţină căile spre shell-uri.

Repozitoriu în stil CVS.

$ grep git /etc/group (1)
git:x:9418:alice,bob,cindy,david
$ cd /home/devo.git
$ ls -l (2)
  lrwxrwxrwx   1 david git    17 Dec  4 22:40 HEAD -> refs/heads/master
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 branches
  -rw-rw-r--   1 david git    84 Dec  4 22:40 config
  -rw-rw-r--   1 david git    58 Dec  4 22:40 description
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 hooks
  -rw-rw-r--   1 david git 37504 Dec  4 22:40 index
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 info
  drwxrwsr-x   4 david git  4096 Dec  4 22:40 objects
  drwxrwsr-x   4 david git  4096 Nov  7 14:58 refs
  drwxrwsr-x   2 david git  4096 Dec  4 22:40 remotes
$ ls -l hooks/update (3)
  -r-xr-xr-x   1 david git  3536 Dec  4 22:40 update
$ cat info/allowed-users (4)
refs/heads/master       alice\|cindy
refs/heads/doc-update   bob
refs/tags/v[0-9]*       david

Pune programatorii în grupul git.
Şi dă acces de scriere în repozitoriu pentru acest grup.
Folosiţi exemplul update-hook al lui Carl din Documentation/howto/ pentru a stabili polica de acces la ramificări.
alice şi cindy pot publica în master, numai bob poate publica în doc-update. david este managerul de release şi este unica persoană care poate crea şi publica tag-uri.

Server HTTP pentru transfer simplu.

dev$ git update-server-info (1)
dev$ ftp user@isp.example.com (2)
ftp> cp -r .git /home/user/myproject.git

Asiguraţi-vă că info/refs şi obiectele/info/pachete sînt actualizate.
Încărcaţi directorul pe serverul HTTP.