जब मैं कर रहा हूँ, तो मैं क्यों टकराव कर रहा हूँ, मुझे गट-रिबास क्यों मर्ज करता है?


146

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

यहां उन लिपियों का संशोधित संस्करण दिया गया है, जिनका मैं उपयोग कर रहा हूं:


repo_squash.sh (यह वास्तव में चलाई जाने वाली स्क्रिप्ट है):


rm -rf repo_squash
git clone repo repo_squash
cd repo_squash/
GIT_EDITOR=../repo_squash_helper.sh git rebase --strategy theirs -i bd6a09a484b8230d0810e6689cf08a24f26f287a

repo_squash_helper.sh (यह स्क्रिप्ट केवल repo_squash.sh द्वारा उपयोग की जाती है):


if grep -q "pick " $1
then
#  cp $1 ../repo_squash_history.txt
#  emacs -nw $1
  sed -f ../repo_squash_list.txt < $1 > $1.tmp
  mv $1.tmp $1
else
  if grep -q "initial import" $1
  then
    cp ../repo_squash_new_message1.txt $1
  elif grep -q "fixing bad import" $1
  then
    cp ../repo_squash_new_message2.txt $1
  else
    emacs -nw $1
  fi
fi

repo_squash_list.txt: (यह फ़ाइल केवल repo_squash_helper.sh द्वारा उपयोग की जाती है)


# Initial import
s/pick \(251a190\)/squash \1/g
# Leaving "Needed subdir" for now
# Fixing bad import
s/pick \(46c41d1\)/squash \1/g
s/pick \(5d7agf2\)/squash \1/g
s/pick \(3da63ed\)/squash \1/g

मैं आपकी कल्पना में "नया संदेश" सामग्री छोड़ दूंगा। प्रारंभ में, मैंने "--strstryss" विकल्प के बिना ऐसा किया था (यानी, डिफ़ॉल्ट रणनीति का उपयोग करके, जिसे अगर मैं समझता हूं कि दस्तावेज़ सही रूप से पुनरावर्ती है, लेकिन मुझे यकीन नहीं है कि कौन सी पुनरावर्ती रणनीति का उपयोग किया जाता है), और यह भी नहीं था ' t काम। इसके अलावा, मुझे यह इंगित करना चाहिए कि, repo_squash_helper.sh में टिप्पणी किए गए कोड का उपयोग करके, मैंने मूल फ़ाइल को सहेज लिया है कि sed स्क्रिप्ट काम करती है और इसके खिलाफ sed स्क्रिप्ट चलती है यह सुनिश्चित करने के लिए कि यह वही कर रही थी जो मैं इसे करना चाहता था ( ये था)। फिर, मैं भी नहीं जानता कि क्यों हैं , विरोध हो तो यह इतना जो रणनीति प्रयोग किया जाता है कोई फर्क ही नहीं होता। किसी भी सलाह या अंतर्दृष्टि मददगार होगी, लेकिन ज्यादातर मैं सिर्फ इस स्क्वाश को काम करना चाहता हूं।

Jefromi के साथ चर्चा से अतिरिक्त जानकारी के साथ अद्यतन:

हमारे बड़े पैमाने पर "वास्तविक" रिपॉजिटरी पर काम करने से पहले, मैंने परीक्षण रिपॉजिटरी पर समान स्क्रिप्ट का उपयोग किया। यह एक बहुत ही सरल भंडार था और परीक्षण ने सफाई से काम किया।

यह विफल होने पर मुझे मिलने वाला संदेश है:

Finished one cherry-pick.
# Not currently on any branch.
nothing to commit (working directory clean)
Could not apply 66c45e2... Needed subdir

यह पहली स्क्वैश कमिटमेंट के बाद पहली पिक है। रनिंग git statusएक क्लीन वर्किंग डायरेक्टरी देता है। यदि मैं तब करता हूं, तो git rebase --continueमुझे कुछ और आने के बाद एक समान संदेश मिलता है। यदि मैं इसे फिर से करता हूं, तो मुझे एक दर्जन के बाद एक और समान संदेश मिलता है। अगर मैं इसे अभी तक फिर से करता हूं, तो इस समय यह लगभग सौ कमिट्स के माध्यम से जाता है, और इस संदेश को देता है:

Automatic cherry-pick failed.  After resolving the conflicts,
mark the corrected paths with 'git add <paths>', and
run 'git rebase --continue'
Could not apply f1de3bc... Incremental

अगर मैं दौड़ता git statusहूं, तो मुझे मिलता है:

# Not currently on any branch.
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
# modified:   repo/file_A.cpp
# modified:   repo/file_B.cpp
#
# Unmerged paths:
#   (use "git reset HEAD <file>..." to unstage)
#   (use "git add/rm <file>..." as appropriate to mark resolution)
#
# both modified:      repo/file_X.cpp
#
# Changed but not updated:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
# deleted:    repo/file_Z.imp

"दोनों संशोधित" बिट मुझे अजीब लगता है, क्योंकि यह सिर्फ एक पिक का परिणाम था। यह भी ध्यान देने योग्य है कि अगर मैं "संघर्ष" को देखता हूं, तो यह एक एकल पंक्ति में उबलता है, जिसमें एक संस्करण इसकी शुरुआत [टैब] वर्ण के साथ होता है, और दूसरा चार स्थानों के साथ होता है। यह लग रहा था कि यह एक समस्या हो सकती है कि मैंने अपनी कॉन्फ़िग फ़ाइल कैसे सेट की है, लेकिन इसमें कुछ भी नहीं है। (मैंने ध्यान दिया कि core.ignorecase सही पर सेट है, लेकिन जाहिर तौर पर git-clone ने स्वचालित रूप से ऐसा किया है। मुझे यह देखकर बिल्कुल आश्चर्य नहीं होगा कि मूल स्रोत विंडोज मशीन पर था।)

यदि मैं मैन्युअल रूप से file_X.cpp को ठीक करता हूं, तो यह एक और संघर्ष के बाद शीघ्र ही विफल हो जाता है, इस बार एक फ़ाइल (CMakeLists.txt) के बीच है कि एक संस्करण का मानना ​​है कि मौजूद होना चाहिए और एक संस्करण को नहीं सोचना चाहिए। यदि मैं यह कहकर इस विरोध को ठीक कर दूं कि मुझे यह फ़ाइल चाहिए (जो मैं करता हूं), कुछ बाद में मुझे एक और संघर्ष (इसी फ़ाइल में) मिलता है जहां अब कुछ गैर-तुच्छ परिवर्तन हैं। यह अभी भी संघर्ष के माध्यम से लगभग 25% है।

मुझे यह भी इंगित करना चाहिए, क्योंकि यह बहुत महत्वपूर्ण हो सकता है, कि यह परियोजना एक svn रिपॉजिटरी में शुरू हुई थी। उस प्रारंभिक इतिहास को उस svn भंडार से आयात किया गया था।

अपडेट # 2:

एक लार्क पर (जेफ्रोमी की टिप्पणियों से प्रभावित), मैंने अपने repo_squash.sh को बदलने का फैसला किया:

rm -rf repo_squash
git clone repo repo_squash
cd repo_squash/
git rebase --strategy theirs -i bd6a09a484b8230d0810e6689cf08a24f26f287a

और फिर, मैंने अभी मूल प्रविष्टियों को स्वीकार किया है, जैसा कि है। यानी, "रिबेस" को एक चीज़ नहीं बदलनी चाहिए थी। यह पूर्व में वर्णित समान परिणामों के साथ समाप्त हुआ।

अपडेट # 3:

वैकल्पिक रूप से, यदि मैं रणनीति को छोड़ देता हूं और अंतिम कमांड को प्रतिस्थापित करता हूं:

git rebase -i bd6a09a484b8230d0810e6689cf08a24f26f287a

मुझे अब रिबास समस्याओं के लिए "कुछ भी नहीं करने के लिए" नहीं मिलता है, लेकिन मैं अभी भी अन्य संघर्षों के साथ बचा हुआ हूं।

खिलौना रिपॉजिटरी के साथ अद्यतन जो समस्या को फिर से बनाता है:

test_squash.sh (यह वह फ़ाइल है जिसे आप वास्तव में चलाते हैं):

#========================================================
# Initialize directories
#========================================================
rm -rf test_squash/ test_squash_clone/
mkdir -p test_squash
mkdir -p test_squash_clone
#========================================================

#========================================================
# Create repository with history
#========================================================
cd test_squash/
git init
echo "README">README
git add README
git commit -m"Initial commit: can't easily access for rebasing"
echo "Line 1">test_file.txt
git add test_file.txt
git commit -m"Created single line file"
echo "Line 2">>test_file.txt 
git add test_file.txt 
git commit -m"Meant for it to be two lines"
git checkout -b dev
echo Meaningful code>new_file.txt
git add new_file.txt 
git commit -m"Meaningful commit"
git checkout master
echo Conflicting meaningful code>new_file.txt
git add new_file.txt 
git commit -m"Conflicting meaningful commit"
# This will conflict
git merge dev
# Fixes conflict
echo Merged meaningful code>new_file.txt
git add new_file.txt
git commit -m"Merged dev with master"
cd ..

#========================================================
# Save off a clone of the repository prior to squashing
#========================================================
git clone test_squash test_squash_clone
#========================================================

#========================================================
# Do the squash
#========================================================
cd test_squash
GIT_EDITOR=../test_squash_helper.sh git rebase -i HEAD@{7}
#========================================================

#========================================================
# Show the results
#========================================================
git log
git gc
git reflog
#========================================================

test_squash_helper.sh (test_sqash.sh द्वारा प्रयुक्त):

# If the file has the phrase "pick " in it, assume it's the log file
if grep -q "pick " $1
then
  sed -e "s/pick \(.*\) \(Meant for it to be two lines\)/squash \1 \2/g" < $1 > $1.tmp
  mv $1.tmp $1
# Else, assume it's the commit message file
else
# Use our pre-canned message
  echo "Created two line file" > $1
fi

पुनश्च: हाँ, मैं आप में से कुछ को जानता हूँ जब आप मुझे एक पतन-संपादक के रूप में emacs का उपयोग करते हुए देखते हैं।

पीपीएस: हम जानते हैं कि हमें रिबास के बाद मौजूदा रिपॉजिटरी के हमारे सभी क्लोन को उड़ाना होगा। ("प्रकाशित होने के बाद" आप किसी भंडार को पुन: प्रकाशित नहीं करेंगे ") की तर्ज पर।"

PPPS: क्या कोई मुझे बता सकता है कि इसमें कोई इजाफा कैसे किया जाए? मैं इस स्क्रीन पर कहीं भी विकल्प नहीं देख रहा हूं चाहे मैं संपादन मोड में हूं या दृश्य मोड में हूं।


उपयोग की जाने वाली लिपियों की तुलना में अधिक प्रासंगिक अंतिम प्रयास कार्रवाई है - यह इंटरमीक्स पिक और स्क्वैश की एक सूची होना निश्चित है, है ना? और क्या विद्रोही शाखा में कोई मर्ज है? (हालांकि आप rebase -pवैसे भी उपयोग नहीं कर रहे हैं )
Cascabel

मुझे यकीन है कि आप "अंतिम प्रयास की गई कार्रवाई" से क्या मतलब है नहीं कर रहा हूँ, लेकिन यह है सिर्फ intermixed पिकअप और स्क्वैश की एक सूची, पिछले 400 के साथ या तो सब ले जा रहा है। उस सूची में कोई मर्ज नहीं हैं, हालांकि रिबासिंग स्वयं अपने मर्ज का प्रदर्शन कर रहा है। मैंने जो पढ़ा है, उसके अनुसार, "रिबेस-पी" को इंटरएक्टिव मोड के साथ अनुशंसित नहीं किया जाता है (जो मेरे मामले में यह सब इंटरैक्टिव नहीं है, निश्चित रूप से)। से kernel.org/pub/software/scm/git/docs/git-rebase.html : "यह आंतरिक रूप से --interactive मशीनरी का उपयोग करता है, लेकिन --interactive विकल्प के साथ संयोजित स्पष्ट रूप से आम तौर पर एक अच्छा विचार नहीं है"
बेन

"अंतिम रूप से की गई कार्रवाई" से मेरा तात्पर्य पिक / स्क्वैश की सूची से है rebase --interactive- जो प्रयास करने के लिए गिट की कार्रवाई की सूची की तरह हैं। मैं उम्मीद कर रहा था कि आप इसे एक एकल स्क्वैश को कम करने में सक्षम हो सकते हैं जो संघर्ष पैदा कर रहा था, और आपकी सहायक लिपियों की सभी अतिरिक्त जटिलता से बचें। अन्य लापता जानकारी तब होती है जब संघर्ष होता है - जब गिट स्क्वैश बनाने के लिए पैच लागू करता है, या जब यह स्क्वैश पर आगे बढ़ने और अगले पैच को लागू करने की कोशिश करता है? (और क्या आपको यकीन है कि आपके GIT_EDITOR कीचड़ के साथ कुछ बुरा नहीं होता है? सरल परीक्षण के मामले में एक और वोट।)
Cascabel

उपयोगी टिप्पणियों के लिए धन्यवाद। मैंने अपने उत्तरों को प्रतिबिंबित करने के लिए प्रश्न को अपडेट किया है।
बेन हॉकिंग

2
टॉय रिपॉजिटरी का मामला आपकी लिपियों की तुलना में समझने में बहुत आसान है - और यह दर्शाता है कि स्क्रीप्ट का इससे कोई लेना-देना नहीं है, बस यह तथ्य है कि आप एक शाखा को फिर से जोड़ने की कोशिश कर रहे हैं जिसमें एक मर्ज है जिसमें संघर्ष का समाधान (एक मामूली बुराई मर्ज) है )।
कैस्केबेल

जवाबों:


69

सब ठीक है, मुझे यकीन है कि एक उत्तर को बाहर फेंकने के लिए पर्याप्त है। शायद इसे संपादित करना होगा, लेकिन मुझे विश्वास है कि मुझे पता है कि आपकी समस्या क्या है।

आपके टॉय रेपो टेस्ट के मामले में एक मर्ज है - इससे भी बदतर, यह संघर्ष के साथ एक मर्ज है। और आप मर्ज में पुन: प्रवेश कर रहे हैं। बिना -p(जो पूरी तरह से काम नहीं करता है -i), मर्ज को अनदेखा किया जाता है। इसका मतलब यह है कि आपने अपने संघर्ष के संकल्प में जो कुछ किया वह तब नहीं है, जब रिबेट अगले प्रतिबद्ध को चेरी-पिक करने की कोशिश करता है, इसलिए इसका पैच लागू नहीं हो सकता है। (मेरा मानना ​​है कि यह एक मर्ज संघर्ष के रूप में दिखाया गया है क्योंकि git cherry-pickमूल प्रतिबद्ध, वर्तमान प्रतिबद्ध और सामान्य पूर्वजों के बीच तीन-तरफ़ा मर्ज करके पैच लागू कर सकते हैं।)

दुर्भाग्य से, जैसा कि हमने टिप्पणियों में उल्लेख किया है, -iऔर -p(विलय को संरक्षित) बहुत अच्छी तरह से नहीं मिलता है। मुझे पता है कि संपादन / रीवॉडिंग कार्य, और वह पुन: व्यवस्थित नहीं करता है। हालांकि, मेरा मानना ​​है कि यह स्क्वैश के साथ ठीक काम करता है। यह प्रलेखित नहीं है, लेकिन इसने मेरे द्वारा वर्णित परीक्षण मामलों के लिए काम किया। यदि आपका मामला रास्ता है, तो अधिक जटिल है, आपको जो करना चाहते हैं उसे करने में बहुत परेशानी हो सकती है, हालांकि यह अभी भी संभव होगा। (कहानी का नैतिक: विलय rebase -i से पहले साथ में सफाई करें ।)

तो, मान लें कि हमारे पास एक बहुत ही सरल मामला है, जहाँ हम A, B और C को एक साथ स्क्वैश करना चाहते हैं:

- o - A - B - C - X - D - E - F (master)
   \             /
    Z -----------

अब, जैसे मैंने कहा, अगर एक्स में कोई संघर्ष नहीं था, तो git rebase -i -pआप की अपेक्षा के अनुसार काम करता है।

यदि संघर्ष हो, तो चीजें थोड़ी पेचीदा हो जाती हैं। यह ठीक स्क्वाशिंग करेगा, लेकिन फिर जब यह मर्ज को फिर से बनाने की कोशिश करता है, तो संघर्ष फिर से होगा। आपको उन्हें फिर से हल करना होगा, उन्हें सूचकांक में जोड़ना होगा, फिर git rebase --continueआगे बढ़ने के लिए उपयोग करना होगा। (बेशक, आप मूल मर्ज कमिट से संस्करण की जाँच करके उन्हें फिर से हल कर सकते हैं।)

आप की है, हो तो rerere(अपने रेपो में सक्षम rerere.enabledसच के लिए सेट), इस तरह से आसान हो जाएगा - Git में सक्षम हो जाएगा फिर से का उपयोग फिर से कोर्डेड फिर से जब आप मूल रूप से संघर्ष किया था समाधान, और आपके पास है निरीक्षण करने के लिए यह सुनिश्चित करने के लिए कि यह सही काम करता है, फाइलों को इंडेक्स में जोड़ें, और जारी रखें। (आप एक कदम भी आगे बढ़ सकते हैं, चालू कर सकते हैं rerere.autoupdate, और यह उन्हें आपके लिए जोड़ देगा, इसलिए मर्ज भी विफल नहीं होगा)। हालांकि, मैं अनुमान लगा रहा हूं कि आप कभी भी सक्षम नहीं हुए हैं, इसलिए आप संघर्ष समाधान स्वयं करने जा रहे हैं। *

* या, आप rerere-train.shस्क्रिप्ट को git-contrib से आज़मा सकते हैं , जो मौजूदा मर्ज कमिट्स से "प्राइम [] रीयर डेटाबेस" करने का प्रयास करता है - मूल रूप से, यह सभी मर्ज कमिट्स की जाँच करता है, उन्हें मर्ज करने का प्रयास करता है, और यदि मर्ज विफल हो जाता है, यह परिणामों को पकड़ता है और उन्हें दिखाता है git-rerere। यह समय लेने वाली हो सकती है, और मैंने वास्तव में इसका उपयोग कभी नहीं किया है, लेकिन यह बहुत उपयोगी हो सकता है।


PS मेरी टिप्पणियों को देखते हुए, मुझे लगता है कि मुझे इसे जल्द ही पकड़ लेना चाहिए। मैंने पूछा कि क्या आप मर्ज वाले किसी ब्रांच को रिबास कर रहे हैं, और आपने कहा कि इंटरएक्टिव रिबेस लिस्ट में कोई मर्ज नहीं थे, जो कि एक ही बात नहीं है - वहाँ कोई मर्ज नहीं थे क्योंकि आप -pविकल्प की आपूर्ति नहीं करते थे ।
कैस्केबेल

मैं यह निश्चित रूप से एक जाना होगा। इसे पोस्ट करने के बाद से, मैंने कुछ मामलों में भी ध्यान दिया है , मैं बस टाइप कर सकता हूं git commit -a -m"Some message"और git rebase --continue, और यह जारी रहेगा। यह -pविकल्प के बिना भी काम करता है , लेकिन यह -pविकल्प के साथ और भी बेहतर काम करता है (क्योंकि मैं कोई पुन: आदेश नहीं दे रहा हूं, ऐसा लगता है कि -pयह ठीक है)। वैसे भी, मैं तुम्हें तैनात रखेंगे।
बेन हॉकिंग

परीक्षण उदाहरण को चलाने git config --global rerere.enabled trueऔर स्थापित git config --global rerere.autoupdate trueकरने से पहले प्राथमिक समस्या का समाधान किया जाता है। दिलचस्प रूप से पर्याप्त है, हालांकि, यह निर्दिष्ट करते हुए भी मर्ज को संरक्षित नहीं करता है --preserve-merges। हालांकि, अगर मेरे पास वे सेट नहीं हैं, और मैं टाइप करता हूं git commit -a -m"Meaningful commit"और git rebase --continueनिर्दिष्ट करते समय --preserve-merges, यह मर्ज को संरक्षित करता है। वैसे भी, इस समस्या को हल करने में मेरी मदद करने के लिए धन्यवाद!
बेन हॉकिंग

84

यदि आपको एक नई शाखा बनाने में कोई आपत्ति नहीं है, तो मैंने इस समस्या से निपटा:

मुख्य होने के नाते:

# create a new branch
git checkout -b new_clean_branch

# apply all changes
git merge original_messy_branch

# forget the commits but have the changes staged for commit
git reset --soft main        

git commit -m "Squashed changes from original_messy_branch"

3
सबसे तेज और कुशल समाधान :)
इस्लामताह

2
यह एक बढ़िया सुझाव था! कई कमियों को जल्दी से मजबूत करने के लिए बहुत अच्छी तरह से काम किया।
फिलिप

3
यह एक अधिक सुरक्षित समाधान है। मैंने भी जोड़ा - मर्ज करने के लिए। बीइंग: गिट मर्ज
स्क्वैश ओरिजिनल_मेस_ब्रांच

1
मेरा दिन और जीवन बचाने के लिए धन्यवाद :) सबसे अच्छा समाधान कोई भी प्राप्त कर सकता है

जब आप करते हैं तो git diff new_clean_branch..original_messy_branchउन्हें समान होना चाहिए? मेरे लिए वे अलग हैं।
लियोनार्डकैल्ली

5

मैं इसी तरह की आवश्यकता की तलाश कर रहा था, यानी अपनी विकास शाखा के अंतर-संधि को त्यागना, मैंने पाया है कि यह प्रक्रिया मेरे लिए काम करती है।
मेरी कार्य शाखा पर

git reset –hard mybranch-start-commit
git checkout mybranch-end-commit . // files only of the latest commit
git add -a
git commit -m”New Message intermediate commits discarded”

viola हमने शाखा के आरंभिक कमेटी के साथ नवीनतम प्रतिबद्धता को जोड़ा है! कोई मर्ज नहीं है संघर्ष के मुद्दे! अपने सीखने के अभ्यास में मैं इस स्तर पर इस निष्कर्ष पर पहुंचा हूं, क्या इस उद्देश्य के लिए बेहतर दृष्टिकोण है।


FYI करें - मैं बस यही कोशिश कर रहा था और पाया कि mybranch-end-प्रतिबद्ध का चेकआउट करने से मुझे मध्यवर्ती कमिट में हुए डिलीट नहीं मिलते हैं। तो यह केवल उन फाइलों की जांच करता है जो mybranch-end-प्रतिबद्ध में मौजूद थीं।
अहांस

1

ऊपर @ hlidka के शानदार उत्तर पर निर्माण करना, जो मैनुअल हस्तक्षेप को कम करता है, मैं एक ऐसा संस्करण जोड़ना चाहता था जो मास्टर पर किसी भी नए कमिट को संरक्षित करता है जो कि स्क्वैश में नहीं हैं।

जैसा कि मेरा मानना ​​है कि ये git resetउस उदाहरण के चरण में आसानी से खो सकते हैं ।

# create a new branch 
# ...from the commit in master original_messy_branch was originally based on. eg 5654da06
git checkout -b new_clean_branch 5654da06

# apply all changes
git merge original_messy_branch

# forget the commits but have the changes staged for commit
# ...base the reset on the base commit from Master
git reset --soft 5654da06       

git commit -m "Squashed changes from original_messy_branch"

# Rebase onto HEAD of master
git rebase origin/master

# Resolve any new conflicts from the new commits

0

ध्यान दें कि -Xऔर एक इंटरेक्टिव रिबेस में उपयोग किए जाने पर रणनीति के विकल्पों को नजरअंदाज कर दिया गया था।

देखें प्रतिबद्ध db2b3b820e2b28da268cc88adff076b396392dfe (जुलाई 2013, git 1.8.4+)

इंटरैक्टिव रिबेस में मर्ज के विकल्पों को अनदेखा न करें

मर्ज की रणनीति और इसके विकल्पों को निर्दिष्ट किया जा सकता है git rebase, लेकिन इसके साथ -- interactive, उन्हें पूरी तरह से नजरअंदाज कर दिया गया।

साइन-ऑफ-बाय: अरनॉड फोंटेन

इसका मतलब है कि -Xरणनीति अब इंटरएक्टिव रिबास के साथ-साथ सादे रिबास के साथ भी काम करती है, और आपकी प्रारंभिक स्क्रिप्ट अब बेहतर काम कर सकती है।


0

मैं एक सरल लेकिन इसी तरह के मुद्दे पर चल रहा था, जहां मैंने 1) एक स्थानीय शाखा पर एक मर्ज संघर्ष को हल किया था, 2) बहुत अधिक कम हिट जोड़कर काम करता रहा, 3) मर्ज संघर्षों को फिर से शुरू करना और हिट करना चाहता था।

मेरे लिए, git rebase -p -i masterकाम किया। इसने मूल संघर्ष समाधान संकल्प को रखा और मुझे दूसरों को शीर्ष पर रखने की अनुमति दी।

आशा है कि किसी की मदद करता है!


मुझे अभी भी मैन्युअल रूप से हल करने के लिए कुछ विरोधाभास मिला जब -p के साथ रिबेस को अटेंड करने पर वहाँ बहुत कम संघर्ष थे और वे केवल उन सभी कोड फ़ाइलों के बजाय प्रोजेक्ट फ़ाइल तक सीमित थे जो मुझे पहले से संघर्ष कर रहे थे। जाहिरा तौर पर "कमिट मर्ज को हल करने के लिए मर्ज संघर्ष रिज़ॉल्यूशन या मैन्युअल संशोधन संरक्षित नहीं हैं।" - stackoverflow.com/a/35714301/727345
जॉनो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.