Ramuri și îmbinări în Git

Ramurile vă permit să lucrați în paralel la mai multe direcții ale aceluiași proiect, fără să vă încurcați reciproc. În acest articol veți afla ce sunt ramurile și la ce folosesc, veți învăța să le creați, să treceți de la una la alta, să îmbinați modificările și să rezolvați fără stres conflictele de merge cu instrumentele IDE. Acestea sunt noțiunile de bază de care aveți nevoie pentru a înțelege ce face Claude Code când lucrează cu repository-ul dumneavoastră într-o ramură separată.

Exemplele și capturile de ecran sunt din IDE-ul JetBrains; denumirile și amplasarea acțiunilor pot fi diferite în versiunea dumneavoastră. Pentru exerciții, folosiți un repository separat, de test. Într-un proiect de lucru, respectați regulile acestuia pentru ramuri, commit-uri și trimiterea modificărilor.

Ce sunt ramurile și la ce folosesc

O ramură dă un nume unei linii separate de commit-uri. Crearea unei ramuri nu copiază folderul proiectului și nu salvează fișierele fără commit. Într-un folder de lucru obișnuit, când schimbați ramura, Git actualizează fișierele în funcție de ramura selectată; modificările neterminate vă pot însoți sau pot împiedica schimbarea.

Din ramura principală main se desprinde o ramură nouă, feature/new-idea, pentru o direcție separată de dezvoltare. După ce terminați lucrul, o îmbinați înapoi în main.

Să presupunem că vreți să schimbați serios ceva în proiect sau să încercați o idee riscantă. Cum ați proceda fără Git? Cel mai probabil, ați copia întregul proiect într-un folder nou și ați lucra acolo. Dacă v-ar plăcea rezultatul, l-ați muta în folderul principal. Dacă nu, ați șterge pur și simplu copia.

Comparația cu o copie ajută să vă imaginați direcții separate de lucru, dar, tehnic, o ramură este un pointer către un commit. Să luăm ca exemplu o carte:

1. aveți un manuscris terminat (aceasta este ramura principală main);
2. vreți să scrieți un final alternativ (creați o ramură nouă, de exemplu feature/new-idea);
3. scrieți noul final fără să modificați textul principal al manuscrisului (lucrați în ramura nouă);
4. dacă noul final vi se pare mai bun, îl puneți în locul celui vechi (îmbinați ramurile cu merge);
5. puteți șterge ciorna veche, cu finalul de care nu mai aveți nevoie (ștergeți ramura).

Crearea unei ramuri noi și lucrul în ea

Pasul 1. Deschideți meniul ramurilor.

Pe bara principală de instrumente, lângă numele proiectului, se află un widget care afișează numele ramurii curente (implicit, main). Apăsați-l și alegeți + New Branch.

Pasul 2. Dați un nume ramurii.

Este o practică bună să denumiți ramurile după sarcina la care lucrați. De exemplu, feature/add-usage-examples.

Dacă ați selectat Checkout branch la creare, IDE-ul va trece la ramura nouă. Verificați-i numele în widget înainte să editați fișierele.

Pasul 3. Faceți modificările și creați un commit.

Adăugați în README.md o secțiune cu exemple de utilizare. Revizuiți modificările și creați un commit în modul obișnuit: în istoricul ramurii noi va apărea o versiune salvată.

Trecerea de la o ramură la alta

Modificările cu exemplele de utilizare sunt acum salvate în siguranță în ramura feature/add-usage-examples. Să revenim la ramura principală main și să vedem ce conține.

Pasul 1. Apăsați din nou widgetul cu numele ramurii curente, din colțul din stânga sus.

Pasul 2. În lista Local sau Recent, selectați ramura main, apoi apăsați Checkout în submeniul care apare.

Pasul 3. Verificați rezultatul.

După ce schimbați ramura, deschideți fișierul README.md. Veți vedea că secțiunea cu exemple de utilizare nu mai este acolo: a rămas în cealaltă ramură. Astfel puteți lucra la funcționalități noi fără să atingeți versiunea stabilă din ramura main.

Îmbinarea ramurilor

merge combină istoricul ramurii selectate cu cel al ramurii curente. Dacă main nu a avansat după desprinderea celeilalte ramuri, este posibil un fast-forward: main ajunge la C3 fără un commit nou. Dacă liniile s-au despărțit, o îmbinare obișnuită creează un commit cu doi părinți.

În cazul liniar ilustrat, main poate avansa până la C3. Deocamdată, și ramura feature/add-usage-examples indică spre C3; nu trebuie să-i ștergeți numele pentru a face îmbinarea.

Așadar, ați terminat lucrul la sarcina din ramura feature/add-usage-examples și vreți să adăugați modificările în proiectul principal.

Pasul 1. Treceți la ramura țintă.

Asigurați-vă că vă aflați pe ramura ÎN CARE vreți să adăugați modificările. În exemplul nostru, aceasta este main.

Pasul 2. Îmbinați ramura.

Apăsați din nou widgetul de gestionare a ramurilor. Din listă, alegeți ramura DIN CARE vreți să preluați modificările (feature/add-usage-examples), apoi selectați Merge 'feature/add-usage-examples' into 'main' din submeniu.

Pasul 3. Verificați rezultatul.

Acum, fișierul README.md din ramura main conține noua secțiune cu exemple. Ați îmbinat cu succes lucrul dumneavoastră în versiunea principală a proiectului.

Conflicte la îmbinare

Un conflict înseamnă că Git nu a putut îmbina automat modificările. Se întâmplă des când au fost editate diferit aceleași rânduri; un alt caz este ștergerea unui fișier într-o ramură și modificarea lui în alta. Soluția depinde de rezultatul dorit.

Aici se văd cu adevărat avantajele instrumentelor integrate în IDE-ul dumneavoastră (CLion sau IntelliJ IDEA). Rezolvarea conflictelor în terminal nu e tocmai plăcută, însă instrumentul de îmbinare în trei direcții (3-way merge) transformă operația într-un proces clar și simplu.

Ambele ramuri au primit commit-uri pornind de la strămoșul comun C1. Faptul că istoricul lor s-a ramificat nu garantează apariția unui conflict: acesta apare doar dacă Git nu poate combina automat modificările. În exercițiul de mai jos, texte diferite înlocuiesc același rând inițial.

Să provocăm un conflict:

1. asigurați-vă că sunteți în ramura main și că nu aveți modificări fără commit sau fișiere noi în fereastra Commit;
2. creați ramura feature/new-title, dar nu treceți încă la ea. Verificați ca opțiunea Checkout branch să nu fie bifată;
3. rămânând în ramura main, schimbați primul rând din README.md în "Proiectul meu minunat" și creați un commit;
4. treceți la ramura feature/new-title. Veți vedea că primul rând din README.md a rămas cel vechi: aceasta era starea fișierului când ați creat ramura. Schimbați același rând în "Proiectul meu grozav" și creați un commit;
5. reveniți la ramura main și îmbinați în ea feature/new-title.

Acum Git va vedea că ambele ramuri au modificări în același loc. Va afișa o fereastră pentru rezolvarea conflictului (Merge Conflicts).

Apăsați butonul Merge pentru a deschide instrumentul de rezolvare a conflictelor. Iată ce veți vedea:

• în stânga (Your changes) - versiunea fișierului din ramura curentă, cea în care îmbinați (main);
• în dreapta (Changes from branch) - versiunea fișierului din ramura pe care o îmbinați;
• în centru (Result) - versiunea finală a fișierului, pe care o alcătuiți manual.

Puteți apăsa săgețile >> sau << (sau cruciulițele pentru a anula), ca să preluați integral una dintre variante. Puteți și să introduceți textul corect direct în panoul central.

Verificați rezultatul din panoul central și apăsați Apply sau butonul echivalent de finalizare. Apoi verificați starea Git: dacă îmbinarea nu a fost încă înregistrată, creați un commit din IDE. Rezolvarea rândurilor aflate în conflict și încheierea operației merge sunt pași diferiți. Verificați și comportamentul codului rezultat.

De ce uneori nu apare niciun conflict

Dacă exercițiul nu produce un conflict, verificați din ce commit a fost creată a doua ramură și dacă ambele părți chiar au înlocuit diferit același rând. Git poate îmbina automat modificările compatibile chiar și în ramuri cu istorii divergente. Un alt caz este istoricul liniar, în care e posibil un fast-forward:

De exemplu:

1. aveți un commit oarecare în main (să zicem, C1);
2. creați un commit nou în ramura main, cu textul "Proiectul meu minunat". Acum ramura main indică spre commit-ul C2;
3. creați ramura feature/new-title din poziția curentă a lui main - și ramura nouă începe tot de la commit-ul C2;
4. creați un commit în feature/new-title, cu textul "Proiectul meu grozav". Ramura avansează și indică spre commit-ul C3;
5. reveniți la main (care este încă la commit-ul C2) și îmbinați în ea feature/new-title.

Git vede că ramura main este strămoșul direct al ramurii feature/new-title: în istoricul lui main nu au apărut commit-uri noi cât timp ați lucrat în cealaltă ramură. Așa că Git mută pur și simplu pointerul main înainte, până la commit-ul C3, fără conflicte.

Istoricul lui main continuă direct cu cel al ramurii feature/new-title, fără nicio ramificare. De aceea Git doar avansează main - nu apare niciun conflict.

Vizualizarea istoricului modificărilor

Ca să înțelegeți mai bine ce se întâmplă în proiectul dumneavoastră, merită să-i urmăriți istoricul.

Deschideți fereastra instrumentului Git (de obicei, pictograma se află în bara laterală din stânga sau în partea de jos a ferestrei IDE) și selectați fila Log sau Show Git Log din bara de instrumente Git. Veți vedea o reprezentare grafică a ramurilor și commit-urilor. Astfel puteți urmări ușor din ce ramură s-a desprins alta și unde au fost îmbinate.

Aici puteți apăsa pe orice commit ca să vedeți ce modificări include și cine l-a creat și când. E, practic, o mașină a timpului pentru codul dumneavoastră.

Cum funcționează împreună cu Claude Code

Acum, că înțelegeți ramurile, vă va fi mai ușor să urmăriți ce face Claude Code când lucrează cu repository-ul dumneavoastră. Iată ce face el cu ramurile în locul dumneavoastră și la ce merită să fiți atenți:

• creează o ramură separată, dacă sarcina și regulile proiectului prevăd asta;
• propune un commit în momentele-cheie - citiți diff-ul și decideți dacă îl acceptați sau îl ajustați;
• vă ajută să găsiți commit-ul salvat și să alegeți cum reveniți la el, ținând cont de modificările fără commit;
• dacă apare un conflict de merge, vă poate cere ajutorul - îl rezolvați cu același instrument IDE;
• poate pregăti și comenta un pull request (PR, o propunere de a îmbina o ramură în cea principală, de exemplu prin GitHub CLI).

Articolul anterior: Lucrul de zi cu zi cu Git · Articolul următor: Pull request-uri, de la creare la merge