दो मुख्य, समांतर शाखाओं के साथ एक मर्कुरियल रिपोजिटरी को पुन: स्थापित कैसे करें - संस्करण-नियंत्रण, मर्कुरियल, शाखा

मेरे भंडार का इतिहास इस तरह दिखता है:

A -- B -- C (branch "foo")

-- D (branch "bar")

दो शाखाएं "शिपिंग" दोनों शाखाएं हैं, और अनिवार्य रूप से एक आम बैकएंड के लिए अलग-अलग सीमाएं हैं।

सभी कोड एक शाखा में हुआ करते थे, के साथ foo या bar संकलक स्विच द्वारा सुविधाएँ चालू या बंद की जाती हैं, लेकिन मैंने प्रत्येक व्यक्ति के साथ काम करना आसान बना दिया है।

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

वर्तमान में, मैं केवल एक शाखा पर परिवर्तन करता हूं और फिर उपयोग करता हूं hg transplant उसी परिवर्तन को दूसरी शाखा में कॉपी करने के लिए।

इसके बजाय, मैं इस तरह से बदलाव करने में सक्षम होना चाहता हूं:

       __ C __ D"   (branch "foo")
/      /
A -- B -- D         (branch "backend")
      
-- E -- D""  (branch "bar")

यही है, शाखा पर काम करते हैं backend, और फिर शिपिंग शाखाओं में से प्रत्येक में (foo तथा bar), मैं उपयोग करता हूं hg merge backend.

वर्णन करने के लिए मेरी वर्तमान स्थिति से जाने के लिए सबसे अच्छा तरीका क्या है? मेरे सोचने का एकमात्र तरीका है:

1. सभी हटाएं foo तथा bar सुविधाएँ, और उस शाखा का नाम backend.

2. पुराने को हटाएं foo तथा bar शाखाओं.

3. मैन्युअल रूप से जोड़ें foo के लिए सुविधाएँ backend और उस शाखा का नाम बताइए foo, और इसी तरह के लिए bar.

क्या कोई बेहतर तरीका है?

इसके अलावा, क्या यह करना सही है?

उत्तर:

उत्तर № 1 के लिए 1

शाखाओं पर कितने परिवर्तन होते हैं foo तथा bar? बैकएंड (प्रत्यारोपित) परिवर्तन सीमांत परिवर्तनों से अलग किए गए हैं?

यदि परिवर्तन कई नहीं हैं, और वे साफ हैं, तो आप ऐसा करना चाह सकते हैं:

       C -- 1 -- 2 -- D -- 3   (branch "foo")
/
A -- B ----------- C" -- D"   (branch "backend")

C" -- 4 ------ D" --- 5   (branch "bar")

(यहां, बी, सी, डी बैकएंड-संबंधित हैं; 1, 2, 3 फू-संबंधित हैं; 4, 5 बार-संबंधित हैं।)

- यानी, अपना ब्रैक बनाएं backend के सबसे हाल के सामान्य पूर्वजों पर आधारित है foo तथा bar, फिर वहां सभी बैकएंड से संबंधित परिवर्तनों को ट्रांसप्लांट करें। इस बिंदु से, आप "विलय करने में सक्षम होंगे।" backend या तो शाखा में।

---

जवाब के लिए 0 № 2

मैंने इसे एक रिपॉजिटरी में कई शाखाओं के बजाय कई रिपॉजिटरी में विभाजित करने के लिए चुना, इस प्रकार है:

1. मैंने बंद कर दिया bar डाली।

2. मैंने मूल रिपॉजिटरी को एक नए रिपॉजिटरी में क्लोन किया backend.

3. मैंने सभी को हटा दिया foo-संबंधित कोड।

4. मैंने उन परिवर्तनों को मुख्य रिपॉजिटरी में खींच लिया, और फिर तुरंत उनमें से (इसलिए) वापस आ गया foo कोड रहता है)। यह मेरा बन गया foo भंडार।

5. मैंने क्लोन किया backend एक नए भंडार में भंडार bar.

6. मैंने अब बंद की गई सभी फाइलों को कॉपी-पेस्ट किया bar में शाखा bar भंडार।

इसने मेरे इतिहास को बनाए रखा foo, और इतिहास की निरंतरता खो दी bar (हालांकि सभी इतिहास अभी भी है, अगर मुझे इसकी आवश्यकता थी); और अब दोनों foo तथा bar क्लोन हैं, संशोधनों के साथ, के backend रिपॉजिटरी, जो वास्तव में मैं चाहता था।

---