Tema: Utilizarea GIT pentru lucru colaborativ și controlul versiunii

Scopul: Lucrul cu Git Local. Lucrul cu branch-urile Git la nivel local. Lucrul cu repozitoriu Git
distant
De reținut :
Raportul trebuie să fie făcut în format electronic (format doc sau pdf) și trebuie trimis prin e-mail la adresa
viorel.rusu@ffi.utm.md cu subiectul "[NumePrenume]_lab_TIDPP_[N]". Răspundeți în raport la toate
întrebările scrise cu culoarea roșu închis.

GIT – noțiuni teorretice

Ca și cu multe alte lucruri bune din viață, Git a început cu puțină distrugere creativă și multe controverse.
Kernelul Linux este un proiect open source cu o gamă de aplicabilitate destul de mare. În marea parte a vieții
proiectului (1991- 2002), schimbările din cadrul kernelului Linux erau trimise ca și patches sau fișiere arhivate.
În 2002, kernelul Linux a început să folosească un DVCS proprietar numit BitKeeper.
În 2005, relațiile dintre comunitatea care dezvolta kernelul și firma care dezvolta BitKeeper s-au stricat, și
statutul de gratuit al aplicației a fost revocat. Această schimbare a impus comunității (și în special lui Linus
Torvalds, creatorul Linux) să dezvolte propriul sistem bazat pe unele din lucrurile învățate în timpul utilizării
BitKeeper. Unele din scopurile noului sistem au fost:
• Rapiditate
• Design simplu
• Suport puternic pentru dezvoltare nelineară (mii de branch-uri paralele)
• Complet distribuit
• Abilitatea de a gestiona proiecte mari similare cu kernelul Linux într-un mod eficient (din punct de vedere al
vitezei și mărimii datelor) Începând cu nașterea sa din 2005, Git a evoluat și s-a maturizat pentru a deveni ușor
de folosit dar păstrându-și toate aceste calități inițiale. Git este incredibil de rapid, este foarte eficient cu
proiecte mari, și deține un sistem incredibil pentru crearea de branch-uri utilizate in dezvoltarea neliniară.

Principala diferență dintre Git și oricare alte sisteme de versionare (Subversion și prietenii săi inclusiv) este
modul în care Git își gestionează datele. Conceptual, majoritatea celorlalte sisteme își stochează informațiile ca
o listă de schimbări asupra fișierelor. Aceste sisteme (CVS, Subversion, Perforce, Bazaar și altele) văd
informațiile ca o mulțime de fișiere și schimbările asupra fișierelor în timp.

Git nu vede și nici nu stochează datele în acest mod. În schimb, Git consideră datele sale mai mult ca o mulțime
de instantanee ale unu mini sistem de fișiere. De fiecare dată când faceți commit, sau salvați starea proiectului
dumneavoastră în Git, acesta practic salvează o poză a stării curente a tuturor fișierelor din acel moment și
stochează o referință la acel instantaneu.
Pentru a fi eficient, dacă există fișiere care nu s-au schimbat, Git nu stochează fișierul iarași ci doar o legătură
către fișierul anterior stocat identic cu cel din prezent.
Aceasta este o distincție importantă dintre Git și aproape toate celelalte VCS.

Git este un proiect free si open-source disponibil aici. Pentru a instala Git pe o masina Linux, rulati comanda:

sudo apt-get install git

Pentru a configura git local sau global puteti folosi utilitarul git-config.
Spre exemplu:

git config --global user.name "John Doe"

git config --global user.email johndoe@example.com

O alta varianta este sa editati fisierul ~/.gitconfig. Un exemplu de astfel de fisier de configurare este ilustrat
mai jos:
# User name & email
[user]
name = John Doe
email = johndoe@example.com
# Smtp email
[send-email]
smtpserver = smtp.example.com
# Activate coloring
[color]
ui = true
# Core variables
[core]
filemode = false
# Our diff algorithm
[diff]
external = /usr/local/bin/diff-wrapper
renames = true
[branch "devel"]
remote = origin
merge = refs/heads/devel
# Proxy settings
[core]
gitProxy="ssh" for "kernel.org"
gitProxy=default-proxy ; for the rest
[include]
path = /path/to/foo.inc ; include by absolute path
path = foo ; expand "foo" relative to the current file
path = ~/foo ; expand "foo" in your $HOME directory

Un tool grafic util pentru Git, este gitk. Pentru a il instala, rulati

sudo apt-get install gitk

Rezultatul afisat la rularea gitk in interiorul unui proiect Git este similar cu cel de mai jos:
Atunci cand doriți sa lucrați cu Git, veti dori fie sa obtineti o clona locala a unui proiect remote, fie sa incepeti
un nou proiect Git.
In primul caz, pentru a obtine o clona locala a unui proiect remote, rulati:

git clone git://project_domain.com/project.git

In al doilea caz, vom crea un proiect Git local, pe care apoi sa il share-uim cu alti utilizatori. Pentru aceasta
trebuie sa:

 cream proiectul:

mkdir my_project
cd my_project

 initializam proiectul git in folderul creat:

git init

 realizam modificarile necesare:

 daca dorim sa ignoram anumite cai din cadrul proiectului (eg. .class, etc.)
o cream un fisier cu numele .gitignore in radacina proiectului si adaugam pattern-uri de shell care
indica fisierele pe care git le va ignora la commit(eg.: bin/*.class)
 verificam statusul proiectului git folosind:

git status

 veti putea observa fisierele adaugate pentru a fi comise, pe cele ne-adaugate precum si pe cele care nu au fost
track-uite:
 pentru a renunta la modificarile adaugate pentru commit, rulam:

git reset HEAD file

 pentru a readuce un fisier modificat la versiunea remote/initiala, rulam:

git checkout -- file

 adaugam fisierele modificate:

git add .

 verificam logul proiectului:

git log

 commitem modificarile facute(cu semnatura utilizatorului curent):

git commit -s -m "mesajul de commit"

 verificam logul proiectului pentru a ne asigura ca noul commit apare acum in log:
 in cazul in care am uitat sa ignoram anumite fisiere, si acestea au ajuns in ultimul commit, rulam:

git rm --cached file

 pentru a modifica ultimul commit, putem folosi:

git commit --amend

 daca dorim sa verificam branch-ul curent(in mod predefinit, branchul curent este master):
git branch

 daca dorim sa cream un nou branch din branchul curent:

git checkout -b new_branch_name

 daca dorim sa stergem un branch(care nu este branchul curent):

git branch -D branch_name

 daca dorim sa revenim la un alt branch, sau commit_id:

git checkout branch_name(commit_id)

 pentru a comite remote:

git push origin master

 pentru a downloada ultimele modificari remote dar fara a le merge-ui cu repository-ul local:

git fetch

 pentru a lua ultimele modificari din repository-ul remote:

git pull origin master

 pentru a vedea diferentele intre versiuni de fisiere/branch-uri

git diff file

Pentru mai multe comenzi utile pentru lucrul cu Git, vizitati tutorialul Git.

Egit
Este un plugin pentru Eclipse, ce permite interactiunea in mod grafic cu repository-ul.

Instalare
Verificati ca aveti instalata ultima versiune de Eclipse (4.2.1).
Pentru instalare: din meniul Help alegeti Install new software, pentru a porni managerul de actualizari.
Introduceti in campul Work with adresa: http://download.eclipse.org/egit/updates.
Bifati prima optiune, „Eclipse Git Team Provider“, apoi Next. Acceptati termenii de licentiere si apasati din nou Next.
Apasati, in final, Finish, pentru a incepe descarcarea si instalarea componentei.

Exemplu

Creati un nou proiect Git. Adaugati in acest proiect o noua clasa Git“:
public class Git {

public static void main(String[] args) {

System.out.println("Git");
}

Pentru a creea un repository local: Click dreapta proiect → Team → Share Project → Git. Alegeti Create
Repository → Finish.
In acest moment s-a creat un repository local. Repository-ul git se va stoca in proiect, in folderul .git
 MERSUL LUCRĂRII :
I. Lucrul cu Git local
Vom crea primul repertoriu Git și vom folosi linia de comandă Git pentru a gestiona actualizările de fișiere. Un depozit
este un loc în care fișierele sunt stocate. În cazul lui Git, stocăm codul sau fișierele și istoricul modificărilor pe care le
facem. Vom lucra într-un depozit de cod sursă local și, pentru acest prim exercițiu, vom folosi un fișier text simplu. Să
începem!

1. Folosind un prompt de comandă sau o fereastră de terminal de pe computer, creați un dosar care va conține
toate fișierele de care aveți nevoie pentru acest exercițiu. Numiți-l local-repo:
$ mkdir local-repo
2. Când ați creat local-repo, navigați la directorul cu comanda local-repo.
Una dintre primele comenzi de învățat când se utilizează Git este comanda de stare, care indică starea
depozitului nostru. Deci, hai să mergem mai departe și tastați următoarea comandă la prompt și apăsați Enter.
$ git status
Oops!, Această comandă generează următoarea eroare:
fatal: Not a git repository (or any of the parent directories): .git

Întrebarea 1: Ce a cauzat eroarea pe care tocmai am văzut-o când am introdus statutul de git în fișierul
nostru?
3. Executați următoarea comandă pentru a inițializa folderul ca un depozit git. $ git init
Dacă totul a mers bine, veți primi un mesaj care să ateste că un depozit Git gol a fost inițializat în dosarul dvs.
4. Să încercăm din nou statul Git :
$ git status
De data aceasta ar trebui să vedeți o ieșire similară cu următoarea captură de ecran.

Ceea ce ne indică afișarea anterioară este că acum avem un depozit și că suntem în ramura principală (master) a
acestui depozit.

Ramura implicită se numește master și în acest exercițiu vom aborda doar această singură ramură pentru a
păstra lucrurile simple.

5. Creați un nou fișier text gol în folderul nostru local-repo. Denumiți fișierul hello.txt.
6. Executați din nou git status. Ar trebui să vedeți următorul răspuns:
În acest moment, Git a detectat un nou fișier în dosarul nostru și ne spune în mod clar că Git nu urmărește în
prezent acest fișier.
Din punctul de vedere al lui Git, fișierele pot fi într-una din următoarele stări:
untracked: Git nu urmărește încă acest fișier, indicând de obicei că fișierul este nou.
tracked: fișierul face parte din instantaneul Git, iar Git urmărește schimbările..
unstaged: un fișier urmărit are modificări, dar nu a fost pus în scenă pentru validare.
staged: fișierul este gata să fie commitat.
deleted: fișierul a fost șters și trebuie eliminat din Git.
Schimbarea stărilor e reprezentată de schema următoare:
În cazul nostru, fișierul nostru este nou și trebuie să-i spunem lui Git să înceapă să îl urmărească. În diagrama de mai jos,
vom arăta fișierul hello.txt de lângă starea netracked pentru a reprezenta starea sa actuală.

Deci, următorul lucru pe care trebuie să-l faceți este să mutați fișierul în stadiul Git staged, făcându-l fișier în scenă.
Facem acest lucru folosind comanda git git add.

Întrebarea 2: Ce comandă Git ar trebui să executăm pentru a verifica starea unui depozit?
7. Executați comanda următoare:
git add hello.txt
Un apel rapid la git status arată ce sa întâmplat cu fișierul nostru atunci când am executat această comandă,
așa cum se arată în următoarea imagine :

Comanda de adăugare nu validează actualizările depozitului, ci doar le pune pe scenă.

Astfel, fișierul nostru hello.txt se află în zona de transfer și este gata să fie validat în depozit, după cum se arată în
diagrama de mai jos.

8. Formatul comenzii de a efectua modificări la o ramură este git commit -m "<message validation>" unde înlocuiți
<message validation> cu o descriere semnificativă a modificării efectuate. În cazul nostru, să ne angajăm
modificările cu următoarea :
git commit -m "add a new file that will eventually contain my name"
Rezultatul va fi :

Atunci când executăm din nou git status, nu vedem mesajul nothing to commit, working tree
clean, ceea ce înseamnă că am commit-at totul.
Următoarea diagramă de stare afișează hello.txt în starea urmată după această validare.
9. Până în prezent, avem un fițier gol în branch-ul nostru. A fost o modalitate simplă de a demonstra comenzile de bază
GIT. Acum, să adăugăm un text în fișierul nostru și să urmăm aceiași pași pentru a valida schimbarea în branch-ul
noastră. Deschideți hello.txt în editorul dvs. preferat, adăugați-vă numele în fișier și salvați-l.
Fișierul se modifică de la starea urmărită la starea nesincronizată sau modificată, deoarece Git o urmărește și
notează aceste actualizări. Acest lucru este prezentat în următoarea diagramă.

10. Verificați starea curentă a dosarului cu git status. Vedem aici că Git ne spune că fișierul hello.txt a fost
modificat.
Întrebarea 3: Ce comandă Git ar trebui să executăm pentru a adăuga modificările noastre?
11. Executați git add hello.txt pentru a pune în scenă modificările făcute. Rulați git status.
De data aceasta, schimbările noastre au fost puse în aplicare și suntem gata să le valorificăm în branch-ul nostru.
După cum se arată în următoarea diagramă de stare, fișierul se află din nou în starea intermediară.

12. Să facem commit la modificări.

git commit -m "add my name to hello.txt"
13. Ați creat primul depozit Git pe mașina dvs., ați adăugat un fișier, ați editat fișierul și ați efectuat o serie de
acțiuni de validare și validare. Dacă doriți un rezumat bun despre ceea ce ați făcut în timpul acestui exercițiu,
tastați următoarea comandă:
git log

II. Lucrați cu branch-ul Git la nivel local

Diagrama următoare ilustrează conceptul de ramificare. Aici avem un trunchi principal, numit master. Aceasta
este ramura noastră principală. Când vrem să lucrăm pe un bloc de cod în siguranță, departe de master, vom
crea o ramură descendentă de master și este o instanță princiupală de lucru în momentul creării acestuia,
precum și pentru schimbările pe care le facem. Când suntem mulțumiți de funcționalitate și suntem gata să
validăm și să livrăm codul, vom pune codul în master și vom elimina branch-ul. Acest proces este repetat pe tot
parcursul ciclului de dezvoltare.

1. Prima comandă de învățat este git branch. Ea ne spune pe care ramură suntem în prezent. Să revenim la
exemplul anterior local-repo și să tastăm git branch. Introduceți în raport rezultatul.
2. Comutarea între ramuri în Git se numește checking out a branch și folosim comanda de verificare git
checkout. Pentru a crea:
git checkout -b new-feature
3. Mesajul rezultat în consola indică Switched to a new branch 'new-feature'. Putem confirma acest lucru
lansând din nou o filială git. Introduceți în raport rezultatul.
 4. Creați un nou fișier text și numiți-l new-feature-file.txt.
5. Listați toate fișierele din director (ls sub MacOS sau Linux, dir pe Windows). Ar trebui să vedeți fișierul afișat.
6. Să facem această schimbare pe ramura noastră, după cum urmează:
git add new-feature-file.txt
7. Verificați starea ramurei noastre cu un apel al git status. Introduceți în raport rezultatul
8. Odată cu schimbările noastre în ramura new-feature, să mergem la master git checkout master
9. Listați toate fișierele din director (ls în MacOS sau Linux, dir pe Windows). Introduceți în raport rezultatul
10. Confirmați că ați revenit din nou pe master cu comanda de verificare git checkout master.
11. Pentru a vedea care ramuri nu sunt fuzionate cu master, tastați următoarea comandă:
git branch --no-merged
12. În linia de comandă, fuzionați branch-ul folosind următoarea comandă
git merge --no-ff new-feature -m "merge new-feature branch"
13. În ramura principală (master), listați toate fișierele din director și confirmați că noul fișier new-feature-
file.txt este acum vizibil.
14. Ca regulă generală, odată ce am îmbinat proprietățile unei ramuri în master, eliminăm ramura. Acest lucru
se poate face cu următoarea comandă:
git branch -D new-feature
Introduceți în raport rezultatul
În diagrama următoare, rezumăm operațiile efectuate :

III. Lucrați cu Git și cu un depozit distant

În exemplele anterioare, am adăugat un fișier text direct în depozitul local Git. Puterea reală de gestionare a
sursei noastre folosind un serviciu precum GitHub care rulează pe Git este că toată lumea dintr-o echipă poate
recupera o instanță de cod local, să lucreze la o actualizare și apoi să trimită modificările la serverul distant.

Această parte presupune că aveți un cont GitHub. Vă rugăm să creați un cont GitHub gratuit înainte de a începe
lucrul.

Trebuie deja să cunoașteți comenzile :

 git status - checks the state of a repo

 git add - stages updates
 git commit - commits updates
 git checkout - switches branch
 git branch - lists existing branches
 git log - shows commit history

Un repositoriu distant este un depozit Git creat pe un server. Similar cu o partajare de fișiere, acesta permite
accesul mai multor persoane la depozit. Într-o echipă de software, fiecare dezvoltator poate accesa repozitoriul
de la distanță pentru a face schimbări. Deși este posibil să mergeți direct la server și să efectuați modificări în
depozit, de obicei, tragem o copie pe depozitul local de pe mașina noastră, facem schimbări și trimitem înapoi.
Acest lucru este ilustrat în următoarea diagramă. Avem aici un repozitoriu numit our-repo găzduit pe GitHub.
Fiecare membru al echipei face o clonă a acestui repo pe mașina sa locală. Se fac modificări la copia locală a
depozitului, iar apoi copia locală se trimite pe server. Desigur, cu atât de multă activitate pe cod, dezvoltatorii
 trebuie să-și păstreze clona actualizată locală la zi cu toate modificările efectuate de către toți pe server. Ei fac
acest lucru trăgând (pull) la intervale regulate și mergând dacă este necesar.

1. În contul dvs. GitHub, creați un depozit nou cu următoarele setări:

 Name = devTI161FR
 Description = remote for TIDPP labs
 Public or Private: Public
 Initialize this repository with a README: check
2. Odată ce depozitul este creat, trebuie să aveți o listă de comenzi care vă permit să îl accesați :

3. Executați liniile blocului … or create a new repository on the command line sau urmați pasul 4
Ca urmare, trebuie să ajungeți pe pagina similară cu:
4. În pagina principală a noului repo creat pe GitHub, apăsați butonul Clone or Download, apăsați și apoi selectați
acțiunea Copiere în Clipboard utilizănd rezultatul pentru comanda :
git clone [URL]
Înlocuiți [URL] prin datele din clipboard. De asemenea, puteți înlocui [URL] în comanda de mai sus cu o adresă
URL în formatul https://github.com/<your_github_username_here>/hello-remote.git.
În shell trebuie să aveți un răspuns similar cu:
$ git clone https://github.com/RVIOREL/devTI161FR.git
Cloning into 'devTI161FR'...
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
Operația de clonare copiază repo-ul distant pe calculatorul dvs. într-un dosar cu același nume ca și depozit, așa
cum se arată în captura de ecran anterioară.
Introduceți în raport rezultatul.
5. Accesați repertoriul devTI161FR. Ar trebui să conțină fișierul unic README.md și, desigur, fișierul .git ascuns.
6. Verificați starea repo-ului nostru cu git status. Introduceți în raport rezultatul. Comentați rezultatele
afișate utilizând această comandă.
7. Tot în clona noastră locală adăugăm un fișier text vid numit demo.txt.
8. Adăugați noul fișier în directorul nostru git utilizând:
git add demo.txt
9. Validați noul fișier pe master cu comanda:
git commit -m "ajoute un fichier texte"
10. Verificați starea reportoriului local cu comanda git status. Introduceți în raport rezultatul. Comentați
rezultatele afișate utilizând această comandă.
11. Pentru a trimite actualizările noastre la repo de la distanță, folosim comanda push sau mai exact:
git push -u origin master
Parametrul -u îi spune lui Git să stabilească origin/master ca depozit în amonte și înseamnă că nu trebuie să-l
specificăm de acum înainte. Introduceți în raport rezultatul.
12. Verificați starea reportoriului local cu comanda le git status. Introduceți în raport rezultatul. Comentați
rezultatele afișate utilizând această comandă.
13. Accesați depozitul pe GitHub. Confirmați că fișierul pe care l-ați adăugat se află în repozitoriu. Puneți în raport
print-screen-ul ce demonstrează faptul.
14. Selectați demo.txt din listă, apoi pictograma creion, evidențiată în următoarea captură de ecran:
15. În fereastra Edit file, introduceți text în fișierul demo.txt.
Derulați în partea de jos a paginii de editare și selectați Commit changes. Mesajul de validare implicit ("Update
demo.txt") este suficient aici și nu este nevoie să îl modificați. În acest moment, am actualizat demo.txt pe
depozit. Cu toate acestea, am făcut-o pe server, deci hai să vedem starea repo-ului nostru local. Puneți în raport
print-screen-ul ce demonstrează faptul.
16. Din linia de comandă, utilizați git status pentru a verifica starea repertoriului nostru local. Ar trebui să
vedeți mesajul Your branch is up-to-date with 'origin/master'. Acest lucru poate părea
surprinzător la început, dar amintiți-vă la început, am spus că aceasta înseamnă că ramura este la zi cu clona
master din origin. Deci, cum putem verifica dacă s-au făcut modificări pe server?
17. Pentru aceasta vom folosi git fetch. În linia de comandă, introduceți următoarea comandă:
git fetch origin
18. Comanda fetch actualizează în mod curent suita de urmărire la distanță, în acest caz original. Introduceți în
raport rezultatul.
Executarea comenzei git remote –v în linia de comandă va indica faptul că originea indică spre repozitoriul
dvs. distant devTI161FR sur github.com.
19. Verificați starea repertoriul cu git status. Introduceți în raport rezultatul. Comentați rezultatele afișate
utilizând această comandă.
20. În linia de comandă, tastați următoarele:
git pull
Introduceți în raport rezultatul.
21. Deschideți fișierul demo.txt din editorul dvs. preferat și verificați dacă modificările efectuate pe server sunt
acum disponibile în copia locală.
Modificați demo.txt, salvați modificările și validați modificările la nivel local. Introduceți în raport acțiunile
(comenzile) și rezultatele.
22. Verificați starea repertoriul cu git status. Introduceți în raport rezultatul. Comentați rezultatele afișate
utilizând această comandă.
23. În linia de comandă, publicați comitetele dvs. în contul dvs. github cu următoarea comandă
git push
Verificați dacă modificările apar în contul dvs. Github.
24. Schimbați cu unul dintre colegii dvs. adresele URL ale conturilor dvs. github. Creați clone ale acestora pe plan
local. Adăugați modificări la fișierele existente. Publicați modificările în contul colegului dvs. Puneți în raport
acțiunile (comenzile) și rezultatele. Ați avut probleme? Cum le-ați rezolvat?

Lucrarea se susține (după trimiterea raportului în format electronic) prin prezentarea lucrului efectuat la
calculator. Se răspunde la întrebarile puse pe subiect.