जीयूआई में गिट इंटरैक्टिव रीबेस: स्क्वैश, फिक्सअप, रीवर्ड, रीऑर्डर और ड्रॉप कमिट

एक इंटरैक्टिव रिबेस जीयूआई आपको टेक्स्ट फ़ाइल के बजाय एक सूची से अपनी शाखा पर कमिट को फिर से लिखने की सुविधा देता है: एक प्रारंभिक कमिट चुनें, इसके ऊपर प्रत्येक कमिट को एक क्रिया दें (पिक, स्क्वैश, फिक्सअप, रीवर्ड, एडिट या ड्रॉप), उन्हें एक नए क्रम में खींचें, और गिट को उन्हें फिर से चलाने दें। यह git rebase -i के समान ही ऑपरेशन चलाता है, इसलिए परिणाम कमांड लाइन के समान है। GitTree में आप जिसे बदलना चाहते हैं उसके ठीक नीचे कमिट पर राइट-क्लिक करें, उपरोक्त कमिट का इंटरैक्टिव रीबेस... चुनें, क्रियाएं सेट करें और Start Rebase पर क्लिक करें। यदि परिणाम गलत है, तो पूर्ववत करें शाखा को वापस रख देता है।

यह इंटरैक्टिव रीबेस ट्यूटोरियल प्रत्येक क्रिया, कमिट को स्क्वैश करने के तीन तरीके, मिलान आदेश, ऑटोस्क्वैश और सुरक्षा जाल को कवर करता है। स्क्रीनशॉट में GitTree का इंटरैक्टिव रीबेस एडिटर, macOS, Windows और Linux के लिए एक Git क्लाइंट दिखाया गया है, लेकिन Git का व्यवहार किसी भी टूल में समान है।

Git इंटरैक्टिव रीबेस क्या करता है, और इसका उपयोग कब करना है

एक सामान्य रीबेस कमिट की एक श्रृंखला को एक नए बेस पर ले जाता है। एक इंटरैक्टिव रीबेस आपको उस श्रृंखला को रास्ते में संपादित करने की सुविधा भी देता है: Git उन कमिट्स को दिखाता है जिन्हें वह फिर से चलाने वाला है, आप सूची बदलते हैं, और Git मिलान के लिए शाखा का पुनर्निर्माण करता है। प्रत्येक पुनः लिखित प्रतिबद्धता को एक नई आईडी मिलती है, यही कारण है कि इंटरैक्टिव रीबेस आपके काम को साझा करने से पहले के चरण से संबंधित होता है। इस तक पहुँचने के विशिष्ट कारण:

• आपके द्वारा पुल अनुरोध खोलने से पहले "वाइप", "टाइपो ठीक करें" और "एड्रेस रिव्यू" का एक रन स्क्वैश एक सार्थक प्रतिबद्धता में बदल जाता है।
• एक प्रतिबद्ध संदेश को दोबारा लिखें जिसमें कोई टाइपो, गुम टिकट नंबर या अस्पष्ट सारांश हो।
• किसी भूले हुए परिवर्तन को उस कमिट में मोड़ें, जिससे वह संबंधित है, ताकि प्रत्येक कमिट अपने आप बन जाए।
• पुनः व्यवस्थित करें ताकि एक रिफैक्टर उस सुविधा से पहले लैंड हो जाए जो उस पर निर्भर है।
• एक डिबगिंग कमिट या एक प्रयोग छोड़ें जो कभी भी मुख्य शाखा तक नहीं पहुंचना चाहिए।

चुनें, स्क्वैश करें, ठीक करें, दोबारा लिखें, संपादित करें और छोड़ें: रीबेस क्रियाओं की व्याख्या की गई

इंटरैक्टिव रीबेस योजना की प्रत्येक पंक्ति एक प्रतिबद्धता प्लस एक कार्रवाई है। ये वे हैं जिनका आप दिन-प्रतिदिन उपयोग करेंगे (Git की टूडू फ़ाइल में स्क्रिप्टिंग के लिए कुछ और हैं, जैसे कि exec और break):

ऑर्डर मायने रखता है, और यह `git log` के विपरीत है। योजना रीप्ले क्रम में सबसे पुराने कमिट को शीर्ष पर सूचीबद्ध करती है, जबकि git log और अधिकांश कमिट ग्राफ सबसे पहले नवीनतम दिखाते हैं। एक स्क्वैश या फ़िक्सअप हमेशा सीधे उसके ऊपर, पुराने वाले कमिट में मिल जाता है। यदि एक स्क्वैश शीर्ष पर पहुंच जाता है और मोड़ने के लिए कुछ भी नहीं होता है, तो GitTree तब तक शुरू करने से इंकार कर देता है जब तक कि आप इसे अपने द्वारा रखी गई प्रतिबद्धता से नीचे नहीं ले जाते।

कमांड-लाइन समतुल्य: git rebase -i

कमांड लाइन पर आप कमिट को उन लोगों के ठीक नीचे नाम देते हैं जिन्हें आप बदलना चाहते हैं: HEAD से वापस गिनती करें, या उस बिंदु का उपयोग करें जहां से आपकी शाखा छूटी थी main।

# rewrite the last 5 commits
git rebase -i HEAD~5

# rewrite everything since the branch left main, without moving its base
git rebase -i $(git merge-base main HEAD)

Git आपके संपादक को कार्य सूची के साथ खोलता है। यह स्क्रीनशॉट के समान ही योजना है: दूसरे कमिट को पहले में कुचल दिया जाता है, और चौथे को एक नया संदेश मिलता है।

pick f2cd67d chore(deps): upgrade Next.js and React
squash 19a1104 ci: cache pnpm store and run tests in parallel
pick f52edc8 refactor(api): extract repository layer from handlers
reword 05dfac2 feat(api): rate limit public endpoints
pick bf2385e fix(web): focus trap in the invite dialog

फ़ाइल को सहेजें और बंद करें और Git पुनः चलना शुरू कर देगा। यह स्क्वैश संदेश और दोबारा लिखे गए संदेश के लिए पूछता है, और किसी भी edit कदम या संघर्ष पर रुकता है, जहां आप आगे बढ़ते हैं या हार मान लेते हैं:

git rebase --continue   # after amending or resolving a conflict
git rebase --abort      # stop and put the branch back where it was

GUI यह बदलता है कि आप योजना कैसे लिखते हैं, न कि Git इसके साथ क्या करता है। GitTree आपके कंप्यूटर पर पहले से इंस्टॉल किए गए Git (संस्करण 2.39 या नया) के साथ एक ही योजना चलाता है, इसलिए ऐप और एक टर्मिनल समान कमिट उत्पन्न करते हैं। व्यापक ट्रेड-ऑफ़ के लिए, Git GUI बनाम कमांड लाइन पढ़ें।

Git GUI में कमिट को कैसे ख़त्म करें

स्क्वैश कमिट कैसे करें इसका संक्षिप्त उत्तर: उन्हें एक-दूसरे के बगल में रखें, पहले को पिक के रूप में छोड़ दें, बाकी को स्क्वैश या फिक्सअप के रूप में चिह्नित करें और फिर से खेलें। GitTree आपको वहां पहुंचने के तीन रास्ते देता है।

रिबेस एडिटर में कमिट्स के एक समूह को स्क्वैश करें

समूह के नीचे कमिट से संपादक खोलें, इसकी पहली कमिट को चुनने के लिए और अन्य को स्क्वैश करने के लिए सेट करें, या यदि आप उनके संदेश नहीं चाहते हैं तो फिक्सअप के लिए सेट करें। यदि समूह सन्निहित नहीं है तो स्ट्रे कमिट्स को जगह पर खींचें। GitTree प्रत्येक समूह का पूर्वावलोकन करता है जिसमें एक स्क्वैश शामिल होता है क्योंकि यह प्रतिबद्ध हो जाएगा, एक बॉक्स में संयुक्त संदेश के साथ जिसे आप संपादित कर सकते हैं।

ग्राफ़ में कमिट चुनें और स्क्वैश कमिट चुनें

त्वरित स्क्वैश के लिए, ग्राफ़ में वर्तमान शाखा के दो या अधिक लगातार कमिट्स का चयन करें, राइट-क्लिक करें और स्क्वैश कमिट्स चुनें। GitTree आपके लिए रिबेस चलाता है, और पूर्ववत अलग-अलग कमिट को वापस रख सकता है। वही मेनू एक चरण में एकल कमिट को फिर से लिखता है: कमिट संदेश संपादित करें..., कमिट ड्रॉप करें..., कमिट को ऊपर ले जाएं और कमिट को नीचे ले जाएं। ये शॉर्टकट उन कमिट्स पर काम करते हैं जो अभी तक रिमोट पर नहीं हैं; पुश किए गए कमिट के लिए, संपादक का उपयोग करें, जो आपसे पहले पुष्टि करने के लिए कहता है।

जब आप पुल अनुरोध को मर्ज करते हैं तो स्क्वैश करें

यदि आपकी टीम प्रति पुल अनुरोध के लिए एक प्रतिबद्धता रखती है, तो आपको शाखा को फिर से लिखने की आवश्यकता नहीं होगी: GitTree का पुल अनुरोध दृश्य स्क्वैश के साथ विलय हो सकता है, और आपकी स्थानीय शाखा वैसी ही बनी रहेगी जैसी वह थी।

फिक्सअप कमिट और ऑटोस्क्वैश: किसी पुराने कमिट को हाथ से दोबारा व्यवस्थित किए बिना ठीक करें

जब आप काम करते हैं, तो प्रत्येक छोटे सुधार को उस प्रतिबद्धता के फिक्सअप के रूप में करें जिससे वह संबंधित है; Git इसे fixup! <original title> शीर्षक देता है। बाद में, ऑटोस्क्वैश के साथ एक इंटरैक्टिव रिबेस हर फिक्सअप को सीधे उसके लक्ष्य के नीचे ले जाता है और इसे फिक्सअप के रूप में चिह्नित करता है, इसलिए आपको बस सूची की जांच करनी है और शुरू करना है।

# record a correction for an earlier commit
git commit --fixup=05dfac2

# correct the commit and replace its message too
git commit --fixup=amend:05dfac2

# later: fold every fixup! and amend! commit into its target
git rebase -i --autosquash main

# turn autosquash on for every interactive rebase
git config --global rebase.autoSquash true

GitTree में, उन आदेशों को ग्राफ़ के नीचे डॉक किए गए अंतर्निहित टर्मिनल में चलाएं, या कमिट संदेश बॉक्स में एक स्थान और मूल शीर्षक fixup! टाइप करें; Git शीर्षक के आधार पर फिक्सअप से मेल खाता है, इसलिए दोनों एक ही प्रतिबद्धता बनाते हैं। अरेंज फ़िक्सअप!, स्क्वैश के साथ! और संशोधन करें! कमिट्स विकल्प चालू करने पर, संपादक पहले से ही व्यवस्थित होकर खुलता है, और आप जो देखते हैं वही वास्तव में Git चलता है।

योजना में एक amend! कमिट फिक्सअप -सी बन जाता है ("फिक्सअप, इसके संदेश का उपयोग GitTree में करें"): इसके परिवर्तन जोड़ दिए जाते हैं और इसका संदेश लक्ष्य को प्रतिस्थापित कर देता है। गिट-कमिट डॉक्यूमेंटेशन के अनुसार, मूल कमिट को लिखने वाले का प्रकार नहीं बदलता है।

क्या इंटरैक्टिव रीबेस सुरक्षित है? पूर्ववत करें, रीफ्लॉग करें और पट्टे के साथ बल दें

रिबेस पुराने कमिट्स को तुरंत नहीं हटाता है: वे रीफ्लॉग से तब तक पहुंच योग्य रहते हैं जब तक कि गिट का कचरा संग्रह पहुंच योग्य वस्तुओं को बहुत बाद में साफ नहीं कर देता। वास्तविक जोखिम पुरानी शाखा का ट्रैक खोना और रिमोट पर किसी सहकर्मी के काम को ओवरराइट करना है।

समाप्त रिबेस को पूर्ववत करें

GitTree प्रत्येक रीबेस से पहले शाखा का स्नैपशॉट लेता है, इसलिए टूलबार में पूर्ववत करें इसे एक क्लिक में वापस रखता है, जिसमें अन्य शाखाएं भी शामिल होती हैं जिन्हें रीबेस अपडेट-रेफ के साथ स्थानांतरित करता है, जब तक कि शाखा को कुछ भी स्थानांतरित नहीं किया जाता है। गिट रीसेट, रिबेस या कमिट को कैसे पूर्ववत करें उस सुरक्षा जाल के बाकी हिस्से को कवर करता है। कमांड लाइन पर:

# still in the middle of the rebase
git rebase --abort

# already finished: go back to the tip from before the rebase
git reflog show --date=relative
git reset --hard ORIG_HEAD

रिबेस शुरू होने पर Git पुराने टिप पर ORIG_HEAD सेट करता है, लेकिन रिबेस के दौरान एक git reset रन (उदाहरण के लिए, किसी कमिट को विभाजित करने के लिए) इसे ले जाता है। रीबेस के ठीक बाद, @{1}, वर्तमान शाखा की पिछली स्थिति, अभी भी पुराने सिरे की ओर इशारा करती है, इसलिए git reset --hard @{1} भी काम करता है। git reset --hard अप्रतिबद्ध परिवर्तनों को फेंक देता है, इसलिए पहले उन्हें प्रतिबद्ध करें या संग्रहीत कर लें।

पुनर्लेखन प्रतिबद्धताओं को आप पहले ही धकेल चुके हैं

GitTree लेबल कमिट जो पहले से ही रिमोट पर हैं उन्हें "रिमोट पर" के साथ लेबल करता है और उन्हें दोबारा लिखने से पहले आपसे पुष्टि करने के लिए कहता है। बाद में सामान्य धक्का देने से इनकार कर दिया जाता है, इसलिए आपको बलपूर्वक धक्का देने की आवश्यकता है। लीज फॉर्म का उपयोग करें, जो केवल दूरस्थ शाखा को अधिलेखित करता है यदि यह अभी भी इंगित करता है कि आपने इसे आखिरी बार कहाँ देखा था:

git push --force-with-lease

# safer when something fetches in the background
git push --force-with-lease --force-if-includes

एक बैकग्राउंड फ़ेच आपकी रिमोट-ट्रैकिंग शाखा को ताज़ा कर सकता है और पट्टे को कमज़ोर कर सकता है, इसलिए गिट-पुश दस्तावेज़ --force-if-includes जोड़ने का सुझाव देता है। GitTree में एक फोर्स पुश हमेशा --force-with-lease का उपयोग करता है, जो आपके पुष्टि करने पर दिखाए गए रिमोट टिप पर पिन किया जाता है, और उस टिप को स्थानीय रूप से refs/ogt/trash के अंतर्गत रखा जाता है, इसलिए रिमोट से जो कमिट हटाता है वह खो नहीं जाता है। पूर्ववत किसी बल के धक्के को उलट नहीं सकता, क्योंकि इससे रिमोट बदल गया है।

जब कोई कदम रुकता है: संपादन और विरोध

एक edit कदम, या एक प्रतिबद्धता जो अब साफ-सुथरी रूप से लागू नहीं होती, रिबेस को रोक देती है। GitTree योजना की प्रगति और जारी रखने या निरस्त करने के लिए एक बैनर दिखाता है। तीन-तरफा संपादक में खुले विरोध, जीयूआई में मर्ज विवादों को हल करना में शामिल हैं। रिबेस के दौरान Git मर्ज के पक्षों की अदला-बदली करता है: "हमारा" वह शाखा है जिस पर आप रिबेसिंग कर रहे हैं और "उनकी" आपकी अपनी प्रतिबद्धता है, इसलिए GitTree उन्हें "रीबेसिंग ऑन" और "आपकी कमिट" लेबल करता है। पाठ सक्रिय ऑपरेशन को जारी रखें, छोड़ें या निरस्त करें प्रत्येक विकल्प का अभ्यास करता है, और एक शाखा को फिर से लिखने के बजाय एकल कमिट को कॉपी करने के लिए, चेरी-पिक देखें।

पुल अनुरोध से पहले साफ़ प्रतिबद्ध इतिहास के लिए युक्तियाँ

• प्रत्येक कमिट का निर्माण करें और उसके परीक्षणों को स्वयं पास करें, और असंबंधित परिवर्तनों को अलग रखें: एक कमिट रिफैक्टर के लिए, एक फीचर के लिए।
• पुल अनुरोध खोलने से पहले नवीनतम main पर रीबेस करें, ताकि समीक्षक केवल आपके परिवर्तन देख सकें।
• खड़ी शाखाओं के साथ काम करना? अपडेट-रेफ्स चालू करें ताकि आपके द्वारा बनाई गई शाखाएं पुनः लिखित प्रतिबद्धताओं के साथ आगे बढ़ें।
• यदि श्रेणी में मर्ज कमिट शामिल है, तो GitTree इसे दिखाता है लेकिन इसे फिर से नहीं लिखेगा; उस स्थिति के लिए git rebase -i --rebase-merges का उपयोग करें।
• पुश करने से पहले कमिट ग्राफ में परिणाम की जांच करें, और अपने स्वयं के एआई कोडिंग सीएलआई को संदेशों को ड्राफ्ट करने दें, जैसा कि क्लाउड कोड और कोडेक्स के साथ एआई कमिट संदेश में है।
• नि:शुल्क पाठ के साथ पहले एक थ्रोअवे रिपॉजिटरी पर अभ्यास करें अप्रकाशित कार्य को नए आधार पर पुनः आधार बनाएं।

GitTree के पास एक नि:शुल्क योजना है जो हर Git सुविधा को कवर करती है, जिसमें निजी रिपॉजिटरी भी शामिल है, macOS, Windows और Linux, English and Arabic में; Nour, एआई सहायक, GitTree प्रो के साथ आता है (देखें मूल्य निर्धारण)। इसे साइन इन करने के लिए Git 2.39 या नए और GitTree खाते की आवश्यकता है। इसे डाउनलोड पेज से प्राप्त करें, या पहले सर्वोत्तम Git GUI क्लाइंट की तुलना करें।