मैं आसानी से एक अतीत के वचन को कैसे तय कर सकता हूं?

Question

मैंने अभी-अभी गिट में एक पिछली फाइल में संशोधन करते हुए पढ़ा, लेकिन दुर्भाग्य से स्वीकृत समाधान 'कमिटमेंट' को कमिट करता है, जो कि मैं नहीं चाहता। तो यहाँ मेरा सवाल है:

हर अब और फिर, मैं एक (असंबंधित) सुविधा पर काम करते समय अपने कोड में एक बग को नोटिस करता हूं। एक त्वरित git blameतब पता चलता है कि बग को कुछ समय पहले शुरू किया गया है (मैं काफी कमिट करता हूं, इसलिए आमतौर पर यह सबसे हालिया कमिट नहीं है जिसने बग को पेश किया है)। इस बिंदु पर, मैं आमतौर पर ऐसा करता हूं:

git stash                      # temporarily put my work aside
git rebase -i <bad_commit>~1   # rebase one step before the bad commit
                               # mark broken commit for editing
vim <affected_sources>         # fix the bug
git add <affected_sources>     # stage fixes
git commit -C <bad_commit>     # commit fixes using same log message as before
git rebase --continue          # base all later changes onto this

हालांकि, ऐसा अक्सर होता है कि उपरोक्त अनुक्रम कष्टप्रद हो रहा है। विशेष रूप से 'इंटरएक्टिव रिबेस' उबाऊ है। क्या उपरोक्त अनुक्रम का कोई शॉर्टकट है, जो मुझे पूर्व में किए गए परिवर्तनों के साथ एक मनमाने ढंग से संशोधन करने देता है? मैं पूरी तरह से जानता हूं कि यह इतिहास को बदल देता है, लेकिन मैं इतनी बार गलतियाँ कर रहा हूं कि मुझे वास्तव में कुछ पसंद आएगा

vim <affected_sources>             # fix bug
git add -p <affected_sources>      # Mark my 'fixup' hungs for staging
git fixup <bad_commit>             # amend the specified commit with staged changes,
                                   # rebase any successors of bad commit on rewritten 
                                   # commit.

हो सकता है कि एक स्मार्ट स्क्रिप्ट जो प्लंबिंग टूल्स का उपयोग करके फिर से लिख सकती है?

Comments

क्या आप "सीमाओं" का मतलब है? आप तो इतिहास बदल रहे हैं सब बदल प्रतिबद्ध के बाद से करता है अलग अलग हो सकता है, लेकिन जुड़ा हुआ सवाल का जवाब स्वीकार किए जाते हैं फिर से आदेश नहीं है किसी भी सार्थक अर्थों में करता है।

— सीबी बेली

@Charles: मेरा मतलब है कि इस तरह से पुन: व्यवस्थित करना: अगर मुझे लगता है कि HEAD ~ 5 टूटी हुई प्रतिबद्ध है, तो जुड़े हुए प्रश्न में स्वीकृत उत्तर का निम्नलिखित HEAD (शाखा का सिरा) तय करेगा। हालाँकि, मैं चाहता हूँ कि HEAD ~ 5 फिक्स्ड कमिट हो - जो कि आपको एक इंटरेक्टिव रिबेस का उपयोग करते समय और फिक्सिंग के लिए सिंगल कमिट को एडिट करने पर मिलता है।

— फ्रेरिच राबे

हां, लेकिन फिर रिबेट कमांड मास्टर को री-चेक करेगा और बाद के सभी कमिट्स को फिक्स्ड कमिट पर रिबेट करेगा। यह नहीं है कि तुम कैसे चला रहे हो rebase -i?

— सीबी बेली

वास्तव में, उस उत्तर के साथ एक संभावित मुद्दा है, मुझे लगता है कि यह होना चाहिए rebase --onto tmp bad-commit master। जैसा कि लिखा गया है कि यह खराब प्रतिबद्ध राज्य को लागू करने की कोशिश करेगा।

— CB बेली

— फ़िक्सअप

Answer 1

अद्यतन किए गए उत्तर

कुछ समय पहले, एक नया --fixupतर्क जोड़ा गया था git commitजिसका उपयोग लॉग संदेश के लिए एक कमिट बनाने के लिए किया जा सकता है git rebase --interactive --autosquash। तो अतीत की प्रतिबद्धता को ठीक करने का सबसे सरल तरीका अब है:

$ git add ...                           # Stage a fix
$ git commit --fixup=a0b1c2d3           # Perform the commit to fix broken a0b1c2d3
$ git rebase -i --autosquash a0b1c2d3~1 # Now merge fixup commit into broken commit

मूल ANSWER

यहाँ थोड़ी देर की पाइथन लिपि है जो मैंने कुछ समय पहले लिखी थी जो इस git fixupतर्क को लागू करती है जिसकी मुझे अपने मूल प्रश्न में उम्मीद थी। स्क्रिप्ट मानती है कि आपने कुछ परिवर्तनों का मंचन किया है और फिर उन परिवर्तनों को दिए गए वचन पर लागू होता है।

नोट : यह स्क्रिप्ट विंडोज-विशिष्ट है; यह पर्यावरण चर का उपयोग करके खोजता है git.exeऔर सेट करता GIT_EDITORहै set। अन्य ऑपरेटिंग सिस्टम के लिए आवश्यकतानुसार इसे समायोजित करें।

इस स्क्रिप्ट का उपयोग करके मैं ठीक से 'टूटे हुए स्रोतों को ठीक कर सकता हूं, स्टेज को ठीक कर सकता हूं, गिट फिक्स को चला सकता हूं' वर्कफ़्लो मैंने पूछा:

#!/usr/bin/env python
from subprocess import call
import sys

# Taken from http://stackoverflow.com/questions/377017/test-if-executable-exists-in python
def which(program):
    import os
    def is_exe(fpath):
        return os.path.exists(fpath) and os.access(fpath, os.X_OK)

    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            if is_exe(exe_file):
                return exe_file

    return None

if len(sys.argv) != 2:
    print "Usage: git fixup <commit>"
    sys.exit(1)

git = which("git.exe")
if not git:
    print "git-fixup: failed to locate git executable"
    sys.exit(2)

broken_commit = sys.argv[1]
if call([git, "rev-parse", "--verify", "--quiet", broken_commit]) != 0:
    print "git-fixup: %s is not a valid commit" % broken_commit
    sys.exit(3)

if call([git, "diff", "--staged", "--quiet"]) == 0:
    print "git-fixup: cannot fixup past commit; no fix staged."
    sys.exit(4)

if call([git, "diff", "--quiet"]) != 0:
    print "git-fixup: cannot fixup past commit; working directory must be clean."
    sys.exit(5)

call([git, "commit", "--fixup=" + broken_commit])
call(["set", "GIT_EDITOR=true", "&&", git, "rebase", "-i", "--autosquash", broken_commit + "~1"], shell=True)

Comments

आप उपयोग कर सकते हैं git stashऔर git stash popअपने छूट के आसपास अब एक साफ काम कर रहे निर्देशिका की आवश्यकता नहीं है

— टोबियास किन्ज़लर

@TobiasKienzler: उपयोग करने के बारे में git stashऔर git stash pop: आप सही कह रहे हैं, लेकिन दुर्भाग्य git stashसे विंडोज पर यह स्लो या ओएस / एक्स की तुलना में बहुत धीमा है। चूंकि मेरी कामकाजी निर्देशिका आमतौर पर साफ है, इसलिए मैंने कमांड को धीमा नहीं करने के लिए इस कदम को छोड़ दिया।

— Frerich Raabe

मैं इसकी पुष्टि कर सकता हूं, खासकर जब नेटवर्क शेयर पर काम कर रहा हो: - /

— टोबियास किन्ज़लर

अच्छा लगा। मैंने गलती से किया था git rebase -i --fixup, और यह निर्धारित बिंदु से शुरुआती बिंदु के रूप में प्रतिबद्ध था, इसलिए मेरे मामले में शा तर्क की आवश्यकता नहीं थी।

— fwielstra

--Autosquash का उपयोग करने वाले लोगों के लिए, यह डिफ़ॉल्ट व्यवहार करने के लिए इसे सेट करने के लिए उपयोगी हो सकता है: git config --global rebase.autosquash true

— taktak004

Answer 2

मैं क्या कर रहा हूँ:

git add ... # फिक्स जोड़ें।
git कमिटेड # कमिटेड, लेकिन गलत जगह पर।
git rebase -i HEAD ~ 5 # अंतिम 5 की जाँच करें पुनरावर्ती के लिए।

आपका संपादक अंतिम 5 कमिट्स की एक सूची के साथ खुलेगा, जिसे तैयार किया जाएगा। परिवर्तन:

08e833c अच्छा बदलाव चुनें 1।
9134ac9 अच्छा बदलाव 2 चुनें।
5adda55 बुरा परिवर्तन उठाओ!
400bce4 उठाओ अच्छा परिवर्तन 3।
2bc82n1 को चुनें खराब परिवर्तन का समाधान।

...सेवा:

08e833c अच्छा बदलाव चुनें 1।
9134ac9 अच्छा बदलाव 2 चुनें।
5adda55 बुरा परिवर्तन उठाओ!
f 2bc82n1 खराब परिवर्तन का समाधान। # ऊपर जाएँ, और 'पिक' के लिए 'पिक' को 'एफ' में बदलें।
400bce4 उठाओ अच्छा परिवर्तन 3।

अपने संपादक को सहेजें और उससे बाहर निकलें, और ठीक उसी स्थिति में वापस कर दिया जाएगा जिसके साथ वह संबंधित है।

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

Comments

जाहिर है आप आगे जाने के लिए HEAD ~ 5 को HEAD ~ n में बदल सकते हैं। आप किसी भी इतिहास के साथ ध्यान केंद्रित नहीं करना चाहेंगे जिसे आपने ऊपर की ओर धकेल दिया है, इसलिए मैं आमतौर पर यह सुनिश्चित करने के लिए 'git rebase -i उत्पत्ति / मास्टर' टाइप करता हूं कि मैं केवल अप्रकाशित इतिहास बदल रहा हूं।

— क्रिश जेनकिंस

यह बहुत कुछ ऐसा है जैसा मैंने हमेशा किया; एफडब्ल्यूआईडब्ल्यू, आप के लिए --autosquashस्विच में दिलचस्पी ले सकते हैं git rebase, जो आपके लिए संपादक में चरणों को स्वचालित रूप से फिर से व्यवस्थित करता है। एक स्क्रिप्ट के लिए मेरी प्रतिक्रिया देखें जो एक git fixupकमांड को लागू करने के लिए इसका लाभ उठाती है ।

— फ्रायरिच राबे

मुझे नहीं पता था कि आप बस फिर से ऑर्डर कर सकते हैं, अच्छा हैश!

— आरोन फ्रांके

यह बहुत बढ़िया बात है! केवल यह सुनिश्चित करने के लिए कि सभी रिबास कार्य किया जाता है अलग सुविधा शाखा है। और मास्टर की तरह आम शाखा के साथ गड़बड़ नहीं है।

— Jay मोदी

Answer 3

पार्टी के लिए थोड़ा देर से, लेकिन यहां एक समाधान है जो लेखक की कल्पना के रूप में काम करता है।

इसे अपने .gitconfig में जोड़ें:

[alias]
    fixup = "!sh -c '(git diff-files --quiet || (echo Unstaged changes, please commit or stash with --keep-index; exit 1)) && COMMIT=$(git rev-parse $1) && git commit --fixup=$COMMIT && git rebase -i --autosquash $COMMIT~1' -"

उदाहरण का उपयोग:

git add -p
git fixup HEAD~5

हालाँकि, यदि आपके पास अस्थिर परिवर्तन हैं, तो आपको रिबेस से पहले उन्हें रोकना होगा।

git add -p
git stash --keep-index
git fixup HEAD~5
git stash pop

आप चेतावनी देने के बजाय स्वचालित रूप से स्लैश करने के लिए अन्य को संशोधित कर सकते हैं। हालाँकि, यदि फ़िकअप साफ़-साफ़ लागू नहीं होता है, तो आपको संघर्षों को ठीक करने के बाद मैन्युअल रूप से स्टैश पॉप की आवश्यकता होगी। सेविंग और पॉपिंग दोनों मैन्युअल रूप से करना अधिक सुसंगत और कम भ्रामक लगता है।

Comments

यह काफी मददगार है। मेरे लिए सबसे आम usecase पिछले कमिट पर परिवर्तनों को ठीक करना है, इसलिए git fixup HEADमैंने इसके लिए एक उपनाम बनाया है। मैं इसके लिए संशोधन का उपयोग भी कर सकता हूं।

— टिड्डा

धन्यवाद! मैं भी अक्सर अंतिम प्रतिबद्ध पर इसका उपयोग करता हूं, लेकिन मेरे पास एक और संशोधन है एक त्वरित संशोधन के लिए। amend = commit --amend --reuse-message=HEADतब आप केवल टाइप संदेश के लिए संपादक को टाइप git amendया git amend -aस्किप कर सकते हैं ।

— dschlyter

संशोधन के साथ समस्या यह है कि मुझे याद नहीं है कि यह कैसे वर्तनी है। मुझे हमेशा सोचना पड़ता है, क्या यह संशोधन या संशोधन है और यह अच्छा नहीं है।

— टिड्डा

Answer 4

एक कमिट को ठीक करने के लिए:

git commit --fixup a0b1c2d3 .
git rebase --autosquash -i HEAD~2

जहाँ a0b1c2d3 यह प्रतिबद्ध है कि आप फ़िक्सअप चाहते हैं और जहाँ 2 +1 की संख्या +1 है जिसे आप बदलना चाहते हैं।

नोट: git rebase --autosquash without -i ने काम नहीं किया है, लेकिन -i ने काम किया है, जो अजीब है।

Comments

2016 और --autosquashबिना -iअभी भी काम नहीं करता है।

— जोनाथन क्रॉस

जैसा कि मैन पेज कहता है: यह विकल्प केवल तभी मान्य होता है जब - इन्टेनेटिव विकल्प का उपयोग किया जाता है। लेकिन संपादक को छोड़ देने का एक आसान तरीका है:EDITOR=true git rebase --autosquash -i

— joeytwield

दूसरा चरण मेरे लिए काम नहीं करता है, कह रहा है: कृपया निर्दिष्ट करें कि आप किस शाखा के खिलाफ फिर से खेलना चाहते हैं।

— djangonaut

git rebase --autosquash -i HEAD ~ 2 (जहाँ 2 कमिट +1 की संख्या को चिपकाया जाता है जिसे बदलना चाहते हैं।

— Sérgio

Answer 5

अद्यतन: स्क्रिप्ट का एक क्लीनर संस्करण अब यहाँ पाया जा सकता है: https://github.com/deiwin/git-dotfiles/blob/docs/bin/git-fixup ।

मैं कुछ इसी तरह की तलाश में था। हालांकि, यह पायथन लिपि बहुत जटिल लगती है, इसलिए मैंने अपने स्वयं के समाधान को एक साथ जोड़ा है:

सबसे पहले, मेरे गिट एलियाज़ जैसे दिखते हैं ( यहाँ से उधार लिया गया है ):

[alias]
  fixup = !sh -c 'git commit --fixup=$1' -
  squash = !sh -c 'git commit --squash=$1' -
  ri = rebase --interactive --autosquash

अब बैश फंक्शन काफी सरल हो गया है:

function gf {
  if [ $# -eq 1 ]
  then
    if [[ "$1" == HEAD* ]]
    then
      git add -A; git fixup $1; git ri $1~2
    else
      git add -A; git fixup $1; git ri $1~1
    fi
  else
    echo "Usage: gf <commit-ref> "
  fi
}

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

if [[ "$1" == HEAD* ]]भाग (से उधार यहाँ ), प्रयोग किया जाता है, क्योंकि यदि आप उपयोग करते हैं, उदाहरण के लिए, प्रमुख ~ 2 अपने रूप में प्रतिबद्ध (प्रतिबद्ध आप के साथ वर्तमान परिवर्तन अप को ठीक करना चाहते हैं) संदर्भ तो HEAD विस्थापित किया जाएगा के बाद Fixup बना दिया गया है प्रतिबद्ध और आपको उसी प्रतिबद्ध को संदर्भित करने के लिए HEAD ~ 3 का उपयोग करना होगा।

Comments

दिलचस्प विकल्प। +1

— VONC

Answer 6

आप "null" संपादक का उपयोग करके इंटरैक्टिव चरण से बच सकते हैं:

$ EDITOR=true git rebase --autosquash -i ...

यह /bin/trueसंपादक के रूप में उपयोग करेगा , के बजाय /usr/bin/vim। यह हमेशा जो भी सुझाव देता है, बिना संकेत दिए स्वीकार करता है।

Comments

वास्तव में, यह वही है जो मैंने अपने 'मूल उत्तर' पायथन लिपि के उत्तर में 30 सितंबर 2010 से किया था (ध्यान दें कि स्क्रिप्ट के निचले भाग में, यह कैसे कहता है call(["set", "GIT_EDITOR=true", "&&", git, "rebase", "-i" ...)।

— Frerich Raabe

Answer 7

फ़िक्सअप वर्कफ़्लो के बारे में वास्तव में मुझे जो परेशान किया गया था, वह यह था कि मुझे खुद को पता लगाना था कि मैं किस बदलाव को हर बार करना चाहता था। मैंने एक "गिट फिक्सअप" कमांड बनाया जो इसके साथ मदद करता है।

यह कमांड फ़िक्सअप कॉम्पट बनाता है, साथ में जोड़ा गया जादू कि यह संबंधित कमिट को स्वचालित रूप से खोजने के लिए git-dep का उपयोग करता है , इसलिए वर्कफ़्लो अक्सर नीचे आता है:

# discover and fix typo in a previously committed change
git add -p # stage only typo fix
git fixup

# at some later point squash all the fixup commits that came up
git rebase --autosquash master

यह केवल तभी काम करता है जब मंचित परिवर्तन कार्यशील पेड़ (मास्टर और HEAD के बीच) पर विशेष रूप से प्रतिबद्ध होने के लिए जिम्मेदार ठहराया जा सकता है। मुझे लगता है कि इस तरह के छोटे बदलावों के लिए मैं बहुत बार ऐसा होता हूं, उदाहरण के लिए टिप्पणियों में टाइपोस या नए शुरू किए गए (या नाम बदला हुआ) तरीकों के नाम। यदि यह मामला नहीं है, तो यह कम से कम उम्मीदवार की सूची प्रदर्शित करेगा।

मैं अपने दैनिक वर्कफ़्लो में इसका बहुत अधिक उपयोग करता हूं, मेरी कार्यशील शाखा पर पहले से परिवर्तित लाइनों में छोटे बदलावों को जल्दी से एकीकृत करने के लिए। यह पटकथा उतनी सुंदर नहीं है जितनी यह हो सकती है, और यह zsh में लिखी गई है, लेकिन यह मेरे लिए काफी अच्छा काम कर रही है, जबकि अब मुझे इसे दोबारा लिखने की जरूरत महसूस नहीं हुई:

https://github.com/Valodim/git-fixup

Answer 8

आप इस उपनाम का उपयोग करके किसी विशेष फ़ाइल के लिए एक फ़िक्अप बना सकते हैं ।

[alias]
...
# fixup for a file, using the commit where it was last modified
fixup-file = "!sh -c '\
        [ $(git diff          --numstat $1 | wc -l) -eq 1 ] && git add $1 && \
        [ $(git diff --cached --numstat $1 | wc -l) -eq 1 ] || (echo No changes staged. ; exit 1) && \
        COMMIT=$(git log -n 1 --pretty=format:"%H" $1) && \
            git commit --fixup=$COMMIT && \
            git rebase -i --autosquash $COMMIT~1' -"

यदि आपने कुछ बदलाव किए हैं, myfile.txtलेकिन आप उन्हें नई कमेटी में नहीं रखना चाहते हैं, git fixup-file myfile.txtतो fixup!उस कमिट के लिए बनाएंगे जहां myfile.txtपिछली बार बदलाव किया गया था, और फिर यह होगा rebase --autosquash।

Comments

बहुत चालाक, थियो मैं पसंद करूँगा कि git rebaseस्वचालित रूप से नहीं बुलाया गया था।

— आहतिखन hur

Answer 9

commit --fixupऔर rebase --autosquashमहान हैं, लेकिन वे पर्याप्त नहीं करते हैं। जब मेरे पास आवागमन का क्रम होता है A-B-Cऔर मैं अपने कामकाजी पेड़ में कुछ और परिवर्तन लिखता हूं जो उन मौजूदा प्रचलित तरीकों में से एक या अधिक में होता है, तो मुझे इतिहास को मैन्युअल रूप से देखना होगा, यह तय करना चाहिए कि कौन से परिवर्तन कमिट में हैं, उन्हें चरणबद्ध करें और बनाएं fixup!करता है। लेकिन git के पास पहले से ही पर्याप्त जानकारी उपलब्ध है, जो मेरे लिए वह सब करने में सक्षम है, इसलिए मैंने एक पर्ल स्क्रिप्ट लिखी है जो कि बस यही करती है।

git diffपटकथा में प्रत्येक हंक git blameके लिए उस प्रतिबद्ध का पता लगाने के लिए उपयोग किया जाता है जो अंतिम रूप से संबंधित लाइनों को छूता है, और git commit --fixupउपयुक्त fixup!कमिट लिखने के लिए कॉल करता है, अनिवार्य रूप से वही काम कर रहा है जो मैं पहले मैन्युअल रूप से कर रहा था।

यदि आप इसे उपयोगी पाते हैं, तो कृपया इसमें सुधार करने और इसे प्रसारित करने के लिए स्वतंत्र महसूस करें और हो सकता है कि एक दिन हमें ऐसी सुविधा मिल जाएगी git। मैं एक उपकरण देखना पसंद करूंगा जो यह समझ सकता है कि कैसे एक मर्ज संघर्ष को हल किया जाना चाहिए जब इसे एक इंटरैक्टिव रिबेस द्वारा पेश किया गया हो।

Comments

मुझे स्वचालन के बारे में भी सपने थे: जीआईटी को केवल इतिहास में इसे वापस लाने की कोशिश करनी चाहिए क्योंकि यह पैच के बिना हो सकता है। लेकिन आपकी विधि शायद अधिक समझदार है। यह देखने के लिए बढ़िया है कि आपने इसका प्रयास किया है। मुझे इसे आज़माना है! (निश्चित रूप से ऐसे समय होते हैं जब फ़ाइल में फ़िक्सअप पैच कहीं और दिखाई देता है, और केवल डेवलपर ही जानता है कि यह किसके साथ है। या शायद परीक्षण सूट में एक नया परीक्षण मशीन को काम करने में मदद कर सकता है जहां फिक्स जाना चाहिए।)

— joeytwiddle

Answer 10

मैंने एक छोटी सी शेल फ़ंक्शन लिखी है gcfजो फ़िक्सअप कमिट और रिबेस को स्वचालित रूप से करने के लिए कहते हैं :

$ git add -p

  ... select hunks for the patch with y/n ...

$ gcf <earlier_commit_id>

  That commits the fixup and does the rebase.  Done!  You can get back to coding.

उदाहरण के लिए, आप नवीनतम के साथ दूसरी प्रतिबद्ध करने से पहले पैच कर सकते हैं: gcf HEAD~~

यहाँ समारोह है । आप इसे अपने में पेस्ट कर सकते हैं~/.bashrc

git_commit_immediate_fixup() {
  local commit_to_amend="$1"
  if [ -z "$commit_to_amend" ]; then
    echo "You must provide a commit to fixup!"; return 1
  fi

  # Get a static commit ref in case the commit is something relative like HEAD~
  commit_to_amend="$(git rev-parse "${commit_to_amend}")" || return 2

  #echo ">> Committing"
  git commit --no-verify --fixup "${commit_to_amend}" || return 3

  #echo ">> Performing rebase"
  EDITOR=true git rebase --interactive --autosquash --autostash \
                --rebase-merges --no-fork-point "${commit_to_amend}~"
}

alias gcf='git_commit_immediate_fixup'

--autostashयदि आवश्यक हो तो यह किसी भी परिवर्तन को रोकने और पॉप करने के लिए उपयोग करता है।

--autosquashएक छूट की आवश्यकता है --interactive, लेकिन हम एक डमी का उपयोग करके बातचीत से बचते हैं EDITOR।

--no-fork-pointदुर्लभ स्थितियों (जब आप एक नई शाखा से दूर हो गए हैं, और किसी ने पहले से ही पिछले हंगामे को रोक दिया है) से चुपचाप गिरने से बचाता है ।

Answer 11

मैं एक स्वचालित तरीके से अवगत नहीं हूं, लेकिन यहां एक समाधान है जो मानव-बोटीज़ के लिए आसान हो सकता है:

git stash
# write the patch
git add -p <file>
git commit -m"whatever"   # message doesn't matter, will be replaced via 'fixup'
git rebase -i <bad-commit-id>~1
# now cut&paste the "whatever" line from the bottom to the second line
# (i.e. below <bad-commit>) and change its 'pick' into 'fixup'
# -> the fix commit will be merged into the <bad-commit> without changing the
# commit message
git stash pop

Comments

एक स्क्रिप्ट के लिए मेरी प्रतिक्रिया देखें जो एक git fixupकमांड को लागू करने के लिए इसका लाभ उठाती है ।

— फ्रायरिच राबे

@ फ़्रीचैक राबे: अच्छा लग रहा है, मैं इस बारे में नहीं जानता--autosquash

— टोबीस किंजलर

Answer 12

मैं https://github.com/tummychow/git-absorb सुझाऊंगा :

एलिवेटर पिच

आपके पास कुछ हिट के साथ एक सुविधा शाखा है। आपकी टीम के साथी ने शाखा की समीक्षा की और कुछ बगों की ओर इशारा किया। आपके पास बग्स के लिए फ़िक्सेस हैं, लेकिन आप उन सभी को एक अपारदर्शी कमिट में शट करना नहीं चाहते हैं जो फ़िक्सेस कहता है, क्योंकि आप परमाणु प्रतिबद्ध मानते हैं। मैन्युअल रूप से कम SHAs खोजने git commit --fixupया मैन्युअल इंटरएक्टिव छूट देने के बजाय , ऐसा करें:

• git add $FILES_YOU_FIXED

• git absorb --and-rebase

• या: git rebase -i --autosquash master

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