git merge: கிளைகளை இணைப்பது மற்றும் முரண்பாடுகளைத் தீர்ப்பது

git merge என்ன செய்கிறது

git merge குறிப்பிட்ட கிளையின் மாற்றங்களை நீங்கள் இப்போது இருக்கும் கிளைக்குள் சேர்க்கிறது. திசை முக்கியம்: கிளைகள் "தங்களுக்குள்" இணைக்கப்படுகின்றன. feature/login-ஐ main-இல் இணைக்க, முதலில் main-க்கு மாறி பின்னர் இணைப்பை இயக்குங்கள்.

git switch main
git pull                 # подтянуть свежий main с сервера
git merge feature/login

Git வரிகளை கைமுறையாக நகலெடுப்பதில்லை. இரண்டு கிளைகளுக்கும் பொதுவான மூதாதையரைக் (merge base) கண்டுபிடித்து, இரு பதிப்புகளையும் அதனுடன் ஒப்பிட்டு மாற்றங்களை ஒன்றிணைக்கிறது. இரு பக்கங்களும் வெவ்வேறு இடங்களைத் திருத்தியிருந்தால் முடிவு தானாகவே கிடைக்கும். ஒரே இடத்தைத் திருத்தியிருந்தால் முரண்பாடு உருவாகும், முடிவு உங்கள் கையில்.

இரண்டு முறைகள்: fast-forward மற்றும் மூன்று-பக்க இணைப்பு

Fast-forward — இணைப்பு commit தேவையில்லாதபோது

வைத்துக்கொள்ளுங்கள்: main-இலிருந்து feature-ஐ பிரித்து மூன்று commit செய்தீர்கள், அதற்குள் main-இல் யாரும் எதையும் சேர்க்கவில்லை. அப்போது main-இன் வரலாறு என்பது feature-இன் வரலாற்றின் தொடக்கம் மட்டுமே. Git main சுட்டியை feature-இன் கடைசி commit-க்கு முன்னோக்கி நகர்த்தும்; புதிய commit உருவாகாது.

$ git merge feature
Updating 3f2a1c4..9b7e0d2
Fast-forward
 src/auth.js | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

வரலாறு நேர்கோட்டிலேயே இருக்கும், ஆனால் «இங்கே feature கிளை இருந்தது» என்ற தகவல் அதில் தொலைந்துவிடும். சில நேரங்களில் அது நல்லது, சில நேரங்களில் இல்லை — அதைப் பற்றி கீழே --no-ff பகுதியில்.

மூன்று-பக்க இணைப்பும் merge commit-உம்

இரு கிளைகளும் பொதுவான மூதாதையரிலிருந்து முன்னேறியிருந்தால், சுட்டியை நகர்த்த முடியாது. Git மூன்று-பக்க இணைப்பைச் செய்கிறது: அடிப்படை, «எங்கள்» பக்கம் (நடப்புக் கிளை) மற்றும் «அவர்களின்» பக்கம் (இணைக்கப்படும் கிளை). முடிவு இரண்டு பெற்றோர்களைக் கொண்ட தனி merge commit-ஆகப் பதிவாகும்.

$ git merge feature
Merge made by the 'ort' strategy.
 src/auth.js   | 42 ++++++++++++++++++++
 src/router.js |  3 +-
 2 files changed, 44 insertions(+), 1 deletion(-)

Git Merge branch 'feature' போன்ற செய்தியுடன் எடிட்டரைத் திறக்கும். அதை அப்படியே வைக்கலாம் அல்லது ஏன் இணைத்தீர்கள் என்று சேர்க்கலாம். உருவான «பிரிவை» பார்க்க:

git log --oneline --graph --all

Git 2.34-இலிருந்து இயல்பு உத்தி ort; அதற்கு முன் recursive இருந்தது. அன்றாட வேலைக்கு உத்தியை மாற்ற வேண்டியதில்லை.

git merge-இன் பயனுள்ள கொடிகள்

--no-ff: அம்சத்தின் எல்லைகளைக் காக்க

பல குழுக்கள் அம்சங்களை --no-ff உடன் மட்டுமே இணைக்கின்றன. அப்போது வரைபடத்தில் ஒவ்வொரு பணியும் ஒரு «குமிழாக» தெரியும், அதை ஒரே git revert -m 1 <merge-commit> மூலம் திரும்பப் பெறலாம். fast-forward-இல் அப்படி ஒரு புள்ளி இல்லை; ஒவ்வொரு commit-ஐயும் தனித்தனியாக ரத்து செய்ய வேண்டியிருக்கும்.

--squash: பத்துக்குப் பதில் ஒரு commit

git switch main
git merge --squash feature/login
git commit -m "Вход по e-mail и паролю"

--squash-க்குப் பின் Git கிளையை இணைக்கப்பட்டதாகக் கருதாது: git branch -d feature/login "not fully merged" எச்சரிக்கையுடன் நீக்க மறுக்கும். எல்லாம் சரியாக இருப்பதை உறுதி செய்த பின் git branch -D மூலம் நீக்குங்கள். squash-க்குப் பின் அதே கிளையில் தொடர்ந்து வேலை செய்யாதீர்கள் — அடுத்த இணைப்பு ஏற்கனவே சேர்ந்த மாற்றங்களை மீண்டும் கொண்டுவந்து கிட்டத்தட்ட நிச்சயமாக முரண்பாடுகளை உருவாக்கும்.

இணைப்பு முரண்பாடு: எப்படித் தீர்ப்பது

முரண்பாடு ஒரு விபத்து அல்ல, இயல்பான வேலைச் சூழ்நிலை. அதன் பொருள் ஒன்றே: இரண்டு கிளைகளும் ஒரே வரிகளை மாற்றியுள்ளன (அல்லது ஒன்று மற்றொன்று திருத்திய கோப்பை நீக்கியுள்ளது); எந்தப் பதிப்பு சரி என்று Git ஊகிக்கத் துணியாது.

$ git merge feature/login
Auto-merging src/config.js
CONFLICT (content): Merge conflict in src/config.js
Automatic merge failed; fix conflicts and then commit the result.

படி 1. எது முரண்படுகிறது என்று பார்ப்பது

$ git status
On branch main
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both modified:   src/config.js

படி 2. கோப்பைத் திருத்துவது

முரண்பட்ட கோப்பில் Git குறிகளை வைக்கும்:

<<<<<<< HEAD
const TIMEOUT = 5000;
=======
const TIMEOUT = 10000;
>>>>>>> feature/login

மேல் பகுதி — நீங்கள் இருக்கும் நடப்புக் கிளை (HEAD), கீழ் பகுதி — இணைக்கப்படும் கிளை. சரியான பதிப்பை வைத்திருங்கள் (அல்லது இரண்டையும் இணைக்கலாம்), மூன்று குறி வரிகளையும் நீக்கி கோப்பைச் சேமியுங்கள். அடிக்கடி நடக்கும் தவறு: கோப்பின் நடுவில் ஒரு குறியை விட்டுவிடுவது; commit-க்கு முன் அவற்றைத் தேடுங்கள் — git diff --check மீதமுள்ள குறிகளைக் காட்டும்.

படி 3. தீர்வைக் குறித்து இணைப்பை முடிப்பது

git add src/config.js
git commit          # или git merge --continue

முரண்பாடு முழுவதும் ஒரு பக்கத்தைத் தேர்ந்தெடுப்பதால் தீர்ந்தால், கோப்பைக் கைமுறையாகத் திருத்தத் தேவையில்லை:

git checkout --ours   src/config.js   # оставить версию текущей ветки
git checkout --theirs src/config.js   # взять версию сливаемой ветки
git add src/config.js

எடிட்டரில் வசதியாக

VS Code, JetBrains IDE-கள் மற்றும் பிற எடிட்டர்கள் முரண்பாட்டை மூன்று நெடுவரிசைகளில் காட்டி «தற்போதையதை ஏற்கவும் / உள்வருவதை ஏற்கவும் / இரண்டையும் ஏற்கவும்» பொத்தான்களைத் தருகின்றன. git mergetool மூலம் வெளிப்புறக் கருவியையும் இணைக்கலாம். பயனுள்ள அமைப்பு: git config --global merge.conflictStyle zdiff3 — குறிகளில் பொதுவான மூதாதையரின் பதிப்பும் சேரும், யார் எதை மாற்றினார் என்று தெளிவாகும்.

மனம் மாறினால் — இணைப்பை ரத்து செய்வது

git merge --abort

இந்தக் கட்டளை வேலை அடைவையும் index-ஐயும் git merge-க்கு முந்தைய நிலைக்குத் திருப்பும். அதனால் இணைப்புக்கு முன் வேலை அடைவு சுத்தமாக இருப்பது நல்லது: முடிக்காத திருத்தங்களை commit செய்யுங்கள் அல்லது git stash-இல் ஒதுக்குங்கள்; இல்லையென்றால் அவற்றை இணைப்பின் முடிவுகளிலிருந்து பிரிப்பது கடினம்.

ஏற்கனவே செய்த merge-ஐ ரத்து செய்வது

Merge commit இன்னும் சேவையகத்திற்கு அனுப்பப்படவில்லையென்றால், கிளையைப் பின்னோக்கித் திருப்புவது எளிது:

git reset --hard ORIG_HEAD

ORIG_HEAD ஆபத்தான செயல்பாடுகளுக்கு முன் Git பதிவு செய்யும் சுட்டி, இணைப்புக்கு முன் கிளையின் நிலை இங்கே உள்ளது. --hard commit செய்யப்படாத மாற்றங்களை நீக்கும், அதனால் git status-ஐ சரிபாருங்கள்.

இணைப்பு ஏற்கனவே பகிரப்பட்ட களஞ்சியத்தில் இருந்தால், வரலாறு மீண்டும் எழுதப்படுவதில்லை. எதிர் commit உருவாக்குங்கள்:

git revert -m 1 a1b2c3d

-m 1 என்பது «முதன்மை» பெற்றோர் முதல் பெற்றோர் (இணைக்கப்பட்ட கிளை) என்று சொல்கிறது. ஒரு பொறி: இந்த revert-க்குப் பின் Git அம்சத்தின் commit-களை ஏற்கனவே இணைக்கப்பட்டதாகக் கருதும். பின்னர் திருத்தப்பட்ட அம்சத்தை மீண்டும் இணைக்க விரும்பினால், முதலில் revert commit-ஐ revert செய்ய வேண்டும்.

குழு வேலையில் merge

git pull — fetch மற்றும் merge

சாதாரண git pull மாற்றங்களைப் பதிவிறக்கி தொலைநிலைக் கிளையை உள்ளூர் கிளையுடன் இணைக்கும். நீங்களும் சக ஊழியரும் இணையாக commit செய்திருந்தால் «Merge branch 'main' of ...» commit தோன்றும். அத்தகைய தொழில்நுட்ப இணைப்புகளைத் தவிர்க்க git config --global pull.ff only அமைக்கலாம் (சுட்டி நகர்த்த முடியாவிட்டால் pull தோல்வியடையும், முடிவை நீங்களே எடுப்பீர்கள்) அல்லது git pull --rebase பயன்படுத்தலாம்.

Pull request மற்றும் Merge பொத்தான்

GitHub மற்றும் GitLab-இல் இணைப்பு பொதுவாக pull/merge request மூலம் நடக்கும். «Create a merge commit» பொத்தான் git merge --no-ff-க்குச் சமம், «Squash and merge» — squash இணைப்பு, «Rebase and merge» — மறுஅடிப்படை. முறையைத் தேர்வு செய்வது குழுவின் ஒப்பந்தம்; இயந்திர முறை கன்சோலில் உள்ளதே.

உங்கள் கிளையில் main-ஐ இணைப்பது

நீண்ட நாட்கள் வாழும் கிளை main-இலிருந்து விலகுகிறது, முரண்பாடுகள் சேர்கின்றன. முதன்மைக் கிளையை அவ்வப்போது உங்களிடம் இழுங்கள்:

git switch feature/login
git fetch origin
git merge origin/main

இப்படி முரண்பாடுகள் வரும்போதே சிறு பகுதிகளாகத் தீர்க்கப்படும், இறுதி இணைப்பு main-இல் சீராக நடக்கும்.

பொதுவான தவறுகள்

• தவறான திசையில் இணைத்தது. main-இல் நின்று git merge main இயக்கினீர்கள், அல்லது ஒரு அம்சத்தை இன்னொரு அம்சத்தில் இணைத்தீர்கள். இணைப்பதற்கு முன் git branch --show-current மூலம் நடப்புக் கிளையைச் சரிபாருங்கள்.
• பழைய கிளையுடன் இணைப்பு. ஒரு வாரமாகப் புதுப்பிக்கப்படாத உள்ளூர் main-ஐ இணைத்தீர்கள். முதலில் git pull, பின்னர் merge.
• «Your local changes would be overwritten by merge». வேலை அடைவில் அதே கோப்புகளில் commit செய்யாத மாற்றங்கள் உள்ளன. அவற்றை commit செய்யுங்கள் அல்லது stash-இல் வையுங்கள்.
• «refusing to merge unrelated histories». கிளைகளுக்குப் பொதுவான மூதாதையர் இல்லை — உதாரணமாக உள்ளூர் களஞ்சியம் git init மூலம் உருவாக்கப்பட்டது, தொலைநிலையில் ஏற்கனவே README உள்ளது. இணைப்பு உண்மையிலேயே தேவை என்றால் --allow-unrelated-histories சேர்க்கவும்.
• முரண்பாட்டுக் குறிகளை commit செய்தது. build <<<<<<<-இல் உடைகிறது. Commit-க்கு முன் git diff --check பாருங்கள், சோதனைகளை இயக்குங்கள்.

சுருக்கம்

git merge கிளைகளை இணைக்கும் பாதுகாப்பான வழி: அது ஏற்கனவே உள்ள commit-களை மீண்டும் எழுதுவதில்லை, புதிய commit ஒன்றைச் சேர்க்கிறது (அல்லது சுட்டியை நகர்த்துகிறது). நடப்புக் கிளையில் இணைக்கவும், வேலை அடைவை சுத்தமாக வைக்கவும், அம்சங்களின் எல்லைகள் முக்கியமானால் --no-ff பயன்படுத்தவும், ஒரே commit வேண்டுமானால் --squash. முரண்பாடுகள் மூன்று படிகளில் தீர்க்கப்படும்: கோப்பைத் திருத்துதல், git add, git commit; git merge --abort எப்போதும் உங்களை ஆரம்ப நிலைக்குத் திருப்பும். கிளை இணைப்பும் முரண்பாடு தீர்வும் Git பாடநெறியில் நடைமுறையில் பயிற்சி செய்யப்படுகின்றன.