वास्तविक प्रकाशन योग्य परियोजना

Question

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

तरह

dir:root 
└ dir:feature-a 
└ dir:feature-b 
└ dir:feature-c 
└ dir:common 
└ file:build.gradle 
└ file:build.py 

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

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

उन्हें एक-एक करके प्रकाशित कर सकते हैं सबसे सुविधाजनक तरीका है

1. स्प्लिट के लिए मौजूदा रेपो ताकि मैं अपनी ही शाखा में प्रत्येक सुविधा चालू कर सकते हैं प्राप्त करना चाहते हैं (कुछ रिबेसिंग साथ, संभवतः) वर्तमान संस्करण इतिहास रखें

मैं पहले एक ऐसी ही उद्देश्य के लिए git filter-branch इस्तेमाल किया है, लेकिन एक प्रमुख वक्र गेंद है कि यहाँ भंडार जड़ वास्तव में एक और भंडार है है - मेटा स्तर पर भंडार है दो माता-पिता जो स्वीकार्य रूप से फंकी और v निर्माण स्क्रिप्ट को अद्यतित रखने के लिए उपयोगी है, लेकिन अगर मैंने filter-branch के साथ जो करना चाहते हैं, उसे करने की कोशिश की तो परियोजना की जड़ पर बिल्ड स्क्रिप्ट हटा दी जाएंगी जो निश्चित रूप से मैं नहीं चाहता हूं।

अंत में common निर्देशिका एक विशेष विशेष है - मुझे इसकी संस्करण इतिहास काटने में कोई फर्क नहीं पड़ता, जब तक इसकी सामग्री वहां न हो।

Answer 1

सारांश

आप कुछ सामान्य संसाधनों (build.*) के इतिहास को बनाए रखने और उन संसाधनों को आसानी से एकत्रित करने लायक भविष्य में, रखने के लिए और आप के पुनर्लेखन के लिए/फिल्टर/एक उप-समूह को हटाने के लिए चाहते हैं चाहते हैं

• सभी आम करता proje पहले से: भंडार में अन्य पेड़ (feature-a, common) git filter-branch का उपयोग कर के लिए, आपको पहले अपने मौजूदा प्रतिबद्ध क्रम में फिर से लिखना चाहिए सीटी टेम्पलेट से फोर्क किया गया था (यह पहले से ही मामला होगा)।
• सभी build.* को संशोधित करते हैं, जिसमें स्थानीय परिवर्तन और आपके अपस्ट्रीम क्रैडल से विलीन हो जाते हैं।
• अंत में, सभी परियोजना-विशिष्ट feature-* और common के लिए प्रतिबद्ध हैं।

फिर आप प्रोजेक्ट-विशिष्ट विकास-रेखा पर सुरक्षित रूप से git filter-branch चला सकते हैं, बिना किसी अपस्ट्रीम संसाधन इतिहास को पुनर्लेखित किए। यदि आप ऐसा नहीं करते हैं, तो संभवतः आप बिल्ड-स्क्रिप्ट से जुड़े री-राइटिंग कमेट्स को समाप्त कर देंगे, जिसमें अपस्ट्रीम क्रैडल से मर्ज-कॉमेट शामिल हैं, जो इतिहास ट्रेसिबिलिटी और भविष्य में विलय को रोक देगा।

विस्तार

ऐसा लगता है कि आप एक सुनहरे परियोजना टेम्पलेट है, यह T कहते हैं, और हर बार जब आप एक नई परियोजना शुरू करते हैं, आप (कि रेपो कांटा या तो पारंपरिक GitHub अर्थ में, या बस एक अलग क्लोन क्या होगा) इसे Pn पर कॉल करें। तो Pn और T एक ही इतिहास और सामान्य प्रतिबद्धताओं से शुरू होते हैं (शाखा बिंदु Pn-0 पर कॉल करें)।

Pn के रूप में अपने कोड आधार विकसित करता है, अन्य परियोजनाओं आधार परियोजना टेम्पलेट के बुनियादी ढांचे में सुधार की पहचान, और T में F फाइल करने के लिए एक परिवर्तन कर सकता है। कोई भी प्रोजेक्ट Pn, जो टेम्पलेट से पहले सैकड़ों काम करता है, अभी भी T से सामान्य फ़ाइलों में परिवर्तनों को मर्ज कर सकता है।

अब, आप Pn में इतिहास को फिर से लिखना चाहते हैं। चूंकि Pn-0 आपने कई परियोजना-विशिष्ट काम किए हैं, फिर T से विलय किया है, तो अधिक प्रोजेक्ट-विशिष्ट काम करता है। filter-branch के लिए आपको P वापस Pn-0 पर फिर से लिखना पड़ा, T से विलय-इतिहास खो गया है, क्योंकि इतिहास अलग हो गए हैं, और T से भविष्य में विलय नरक हो गया है।

क्या यह आपकी समस्या का वर्णन करता है?

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

• Let हो Tx सबसे हाल ही में T जो आप Pn में की एक पूरी मर्ज प्रदर्शन किया है के लिए प्रतिबद्ध।
• TPn रेपो में प्राप्त करें, और Pn में एक शाखा बनाएं जो प्रतिबद्ध Tx से शुरू होती है।
• कि शाखा पर अपने वर्तमान Pn इतिहास rebase, यह Pn-0 का आधार (आम T साथ प्रतिबद्ध) से Tx में जाने, नवीनतम आम T साथ करते हैं।

यह दृष्टिकोण के रूप में अगर यह Pn-0 के बजाय Tx के साथ शुरू किया Pn में अपना संपूर्ण इतिहास को फिर से चलाने, इसलिए प्रतिबद्ध Pn-1 एक नए अभिभावक Tx है जाएगा। बेशक प्रत्येक प्रतिबद्धता फिर से लिखी जाएगी, इसलिए Pn के मौजूदा क्लोन तुरंत अनाथ हैं।

एक बार आपके पास यह हो जाने के बाद, आप git filter-branch को फिर से लिखित प्रतिबद्धता Pn-1 से शुरू करने के लिए स्वतंत्र हैं, और अपूर्ण मॉड्यूल के किसी भी इतिहास को हटा दें।

अब - यह मुश्किल तरीके से इतिहास को फिर से लिखने के लिए उचित समस्या है, लेकिन इतिहास को बनाए रखा जाएगा। आप हर दिन इस प्रक्रिया को नहीं करना चाहते हैं।

एक बात जो आप विचार करना चाहें यह है कि क्या कोई भी तरीका है जिससे आप स्रोत-साझाकरण के बिना अपने क्रैडल का उत्पादन और उपभोग कर सकते हैं।यह गिट-विलय के रूप में सुविधाजनक नहीं हो सकता है, लेकिन यदि आपका टेम्पलेट प्रोजेक्ट संस्करण-नियंत्रित है और आप organize your build logic और शायद shared scripts का उपयोग करते हैं, तो आप अपने टेम्पलेट प्रोजेक्ट को मॉड्यूलर कर सकते हैं ताकि आप आम स्रोत इतिहास को बनाए रखने वाले बाल-परियोजनाओं पर निर्भर न हों मर्ज-अप - वे इसके बजाय नवीनतम टेम्पलेट बाइनरी का उपभोग करेंगे। तर्क तर्क के अलावा टेम्पलेट में क्या है इस पर बहुत कुछ निर्भर करता है।