2008-09-24 9 views
71

मैं मर्कुरियल के लिए अपेक्षाकृत नया हूं और मेरी टीम अभी सबवर्सन के प्रतिस्थापन के रूप में इसे आजमा रही है।अकेले अन्य संशोधनों को छोड़कर एक फ़ाइल को प्रतिबद्ध करने और धक्का देने का सबसे आसान तरीका क्या है?

मेरी कार्य निर्देशिका में अन्य संशोधनों को छोड़कर मैं एक और फाइल को एक और फाइल को कैसे दबा सकता हूं (या कम से कम अन्य भंडार में नहीं धकेल दिया जाता है)?

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

तोड़फोड़ में, मैं बस करना चाहते हैं:

svn add my_migration.sql 
# commit only the migration, but not the other files I'm working on 
svn commit -m "migration notes" my_mygration.sql 

और स्थानीय स्तर पर काम जारी रखने के।

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

सबसे आसान बात यह है कि मैं समझ सकता हूं कि फ़ाइल को मेरे स्थानीय भंडार में फाइल करना है, मेरे स्थानीय भंडार को क्लोन करना, वास्तविक भंडार से कोई भी नया परिवर्तन प्राप्त करना, उन्हें मर्ज करना और विलय करना है, और वे मेरे परिवर्तनों को धक्का देते हैं।

hg add my_migration.sql 
hg commit -m "migration notes" my_migration.sql 
cd .. 
hg clone project project-clone 
cd project-clone 
hg fetch http://hg/project 
hg push http://hg/project 

यह काम करता है, लेकिन ऐसा लगता है कि मैं कुछ आसान याद कर रहा हूँ, किसी तरह से मेरी काम कर निर्देशिका में पहले से ही फाइलों को अनदेखा करने की अस्थिर बताने के लिए, बस मर्ज करते हैं और फ़ाइलों के साथ भेजने लगता है। मुझे संदेह है कि Mercurial कतार यह कर सकते हैं, लेकिन मैं पूरी तरह से mq पूरी तरह से grok नहीं है।

नीचे जोश मैथ्यूज के लिए धन्यवाद, शेल्व कमांड ठीक वही है जो मैं ढूंढ रहा हूं। मैं कुछ Googling के साथ किसी भी महान स्थापित निर्देशों को देखने नहीं किया, इसलिए यहां संयुक्त सामान मैं हो यह काम करने के लिए प्रयोग किया जाता है:

के साथ प्राप्त करें: परियोजना में

hg clone http://freehg.org/u/tksoh/hgshelve/ hgshelve 

केवल फ़ाइल (वर्तमान में) hgshelve.py फ़ाइल है।

अपने ~/टांड़ एक्सटेंशन जोड़ने के लिए .hgrc संशोधित है, जहां आप रेपो क्लोन की ओर इशारा करते:

[extensions] 
hgshelve=/Users/ted/Documents/workspace/hgshelve/hgshelve.py 

तो फिर तुम hg shelve और hg unshelve अस्थायी रूप से परिवर्तन दूर स्टोर करने के लिए कर सकते हैं। यह आपको सामानों को दूर करने के लिए चुनने और चुनने के लिए "पैच हंक" स्तर पर काम करने देता है। यह फ़ाइल को जोड़ने के लिए सूचीबद्ध फ़ाइल को शेल्व करने के लिए प्रकट नहीं हुआ था, केवल संशोधनों के साथ रेपो में पहले से ही फ़ाइलें।

+1

यह एक विशेषता यह है कि मैं वास्तव में Git में मूल्य (मैं इसे हर समय का उपयोग करें) है, और यह कठिन मुझे स्विच करने के लिए के लिए होगा ... –

+12

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

उत्तर

29

एक मर्क्यूरियल एक्सटेंशन है जो शेल्व और असफल आदेश लागू करता है, जो आपको बाद में समय तक स्टोर करने के लिए परिवर्तन निर्दिष्ट करने का एक इंटरैक्टिव तरीका देता है: Shelve

3

यदि आप एक्सटेंशन पर भरोसा नहीं करना चाहते हैं तो एक और विकल्प स्थानीय रूप से आपके अपस्ट्रीम रिपोजिटरी का क्लोन रखना है कि आप केवल इन एकीकरण कार्यों के लिए उपयोग करते हैं।

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

10

टीएल; डॉ: मेरा मूल स्पष्टीकरण जटिल दिखता है, लेकिन मुझे आशा है कि यह पूरी तरह से पैच कतार का उपयोग कैसे करें। यहाँ लघु संस्करण है:

$ hg qnew -m "migration notes" -f migration my_migration.sql 
$ hg qnew -f working-code 
# make some changes to your code 
$ hg qrefresh # update the patch with the changes you just made 
$ hg qfinish -a # turn all the applied patches into normal hg commits 

मर्क्युरियल कतार बात इस तरह की एक हवा बनाता है, और यह संभव changesets के और अधिक जटिल हेरफेर बनाता है। यह सीखने लायक है।

# create a patch called migration containing your migration 
$ hg qnew -m "migration notes" -f migration.patch my_migration.sql 
$ hg qseries -v # the current state of the patch queue, A means applied 
0 A migration.patch 
$ hg qnew -f working-code.patch # put the rest of the code in a patch 
$ hg qseries -v 
0 A migration.patch 
1 A working-code.patch 

अब काम कर रहा है कोड पर कुछ अतिरिक्त काम करते हैं:

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

$ hg qtop # show the patch we're currently editing 
working-code.patch 
$ ...hack, hack, hack... 
$ hg diff # show the changes that have not been incorporated into the patch 
blah, blah 
$ hg qrefresh # update the patch with the changes you just made 
$ hg qdiff # show the top patch's diff 

क्योंकि अपने सभी काम अब पैच कतार में सहेजा जाता है, आप उन परिवर्तनों को unapply और उन्हें बहाल करने के बाद आप दूरस्थ परिवर्तन में खींच लिया गया है सकते हैं। आम तौर पर सभी पैच को अपनाने के लिए, बस hg qpop -a करें। पैच कतार पर प्रभाव दिखाने के लिए मैं उन्हें एक समय में बंद कर दूंगा।

$ hg qpop # unapply the top patch, U means unapplied 
$ hg qseries -v 
0 A migration.patch 
1 U working-code.patch 
$ hg qtop 
migration.patch 
$ hg qpop 
$ hg qseries -v 
0 U migration.patch 
1 U working-code.patch 

इस बिंदु पर, ऐसा लगता है कि आपकी निर्देशिका में कोई बदलाव नहीं है। hg fetch करें। अब आप अपने पैच कतार परिवर्तन को वापस धक्का दे सकते हैं, और यदि कोई विवाद हो तो उन्हें विलय कर सकते हैं। यह अवधारणात्मक रूप से कुछ हद तक गिट की वापसी के समान है।

$ hg qpush # put the first patch back on 
$ hg qseries -v 
0 A migration.patch 
1 U working-code.patch 
$ hg qfinish -a # turn all the applied patches into normal hg commits 
$ hg qseries -v 
0 U working-code.patch 
$ hg out 
migration.patch commit info... blah, blah 
$ hg push # push out your changes 

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

$ hg qpush 
$ hg qseries -v 
0 A working-code.patch 
$ hg export qtip > temp.diff 
$ rm -r .hg/patches # get rid of mq from the repository entirely 
$ hg import --no-commit temp.diff # apply the changes to the working directory 
$ rm temp.diff 

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

+0

+1, लेकिन यह * बहुत * जटिल दिखता है। इसकी तुलना "गिट रीबेज -आई" से करें, जिसके लिए कोई विचार या सेट अप की आवश्यकता नहीं है, और मैं अभी भी नहीं देख सकता कि एमक्यू "साफ पैच सेट" समस्या (प्राणियों के लिए!) के लिए एक व्यावहारिक समाधान कैसे है। ऐसा लगता है कि आपको वास्तव में अपने वर्कफ़्लो की योजना बनाना है। – richq

+20

मुझे यकीन नहीं है कि मैं अस्पष्ट कमांडलाइन की 20-चरणीय प्रक्रिया को "हवा" के रूप में संदर्भित करता हूं। – Crashworks

+1

हे, अच्छा कॉल। मैंने अपने समाधान के शीर्ष पर संक्षिप्त, मीठा उत्तर लिखा। – Kobold

38

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

hg commit -m "commit message" filename 

तो बस बाहर धक्का।

hg push 

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

hg push --rev . 

केवल एक फ़ाइल और उस संशोधन के विलय को धक्का देने के लिए परिवर्तनों को दबाएं। फिर आप उन दो सिरों को मर्ज कर सकते हैं जिन्हें आपने स्थानीय रूप से प्राप्त किया है।

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

+1

यह अच्छा लगता है। जब भी मैं Mercurial के पास कहीं भी 'q' अक्षर देखता हूं तो मैं क्रॉससीड जाना शुरू करता हूं। स्टीव लॉश के 'एचजी नज' द्वारा आपसे उत्साहित हो सकता है: http://hgtip.com/tips/advanced/2009-09-28- nudge-a-gentler-push/ –

2

क्या मैं आम तौर पर उपयोग करने के एक एकल फाइल करने के लिए उपयोग किया जाता है:

:

hg commit -m "commit message" filename 

मामले में बाद में, मैं किसी मर्ज संघर्ष किया है और मैं अभी भी अपने परिवर्तन के लिए प्रतिबद्ध नहीं कर रहा हूँ, इन चरणों का पालन

1) पैच फ़ाइल बनाएं।

hg diff > changes.patch 

2) अपने पैच फ़ाइल को जांचने के बाद ही अपने सभी बकाया अपूर्ण परिवर्तनों को वापस करें।

hg revert --all 

3) खींचो, अद्यतन और नवीनतम संशोधन

hg pull -u 
hg merge 
hg commit -m "local merge" 

4) को विलय अब बस अपने पैच वापस आयात करके आपके परिवर्तनों मिलता है।

hg import --no-commit changes.patch 

परिवर्तनों को स्वचालित करने से स्वत: से फ़्लैग का उपयोग करना याद रखें।

0

चूंकि आपने सबसे आसान कहा है, इसलिए मैं अक्सर पूरी फाइलें करते समय hg commit -i (--इंटरएक्टिव) का उपयोग करता हूं। --interactive के साथ आप कमांड लाइन पर अपने पूरे पथ टाइप करने के बजाय बस अपनी इच्छित फ़ाइल (ओं) का चयन कर सकते हैं। एक अतिरिक्त बोनस के रूप में आप फ़ाइलों के भीतर चुनिंदा रूप से शामिल/बहिष्कृत भी कर सकते हैं।

और फिर उस नव निर्मित प्रतिबद्धता को धक्का देने के लिए बस hg push

मैं इस सवाल का जवाब में hg commit --interactive के प्रयोग पर अधिक जानकारी के रख: https://stackoverflow.com/a/47931672/255961

संबंधित मुद्दे

 संबंधित मुद्दे