सभी गिट सबमॉडल्स के नवीनतम खींचने का आसान तरीका

Question

हम बड़ी परियोजनाओं के एक जोड़े को प्रबंधित करने के लिए git सबमॉड्यूल्स का उपयोग कर रहे हैं जो हमारे द्वारा विकसित कई अन्य पुस्तकालयों पर निर्भरता रखते हैं। प्रत्येक लाइब्रेरी एक अलग रेपो है जो सबमॉड्यूल के रूप में आश्रित परियोजना में लाया जाता है। विकास के दौरान, हम अक्सर हर निर्भर सबमॉडल के नवीनतम संस्करण को पकड़ना चाहते हैं।

क्या git के पास ऐसा करने के लिए एक अंतर्निहित कमांड है? यदि नहीं, तो Windows बैच फ़ाइल या उसके समान कैसे हो सकता है?

Comments

git-deep को इससे मदद करनी चाहिए।

— मैथ्यू कुरियन

@ ब्रैड क्या आप मास्टर प्रोजेक्ट में नामित रीमेक को सबमॉड्यूल की अपनी प्रतियां अपडेट करना चाहते हैं; या क्या आप हर सबमॉडल से नवीनतम HEAD कमिट करना चाहते हैं? यहां अधिकांश उत्तर पूर्व को संबोधित करते हैं; बहुत से लोग बाद चाहते हैं।

— क्रिसिनटाउन

Answer 1

यदि यह पहली बार है जब आप एक रेपो की जांच करते हैं, तो आपको --initपहले उपयोग करने की आवश्यकता होती है :

git submodule update --init --recursive

के लिए Git 1.8.2 या इसके बाद के संस्करण, विकल्प --remoteदूरस्थ शाखाओं के नवीनतम सुझावों के लिए समर्थन को अद्यतन करने के लिए जोड़ा गया:

git submodule update --recursive --remote

इसमें .gitmodulesया .git/configफ़ाइलों में निर्दिष्ट किसी भी "गैर डिफ़ॉल्ट" शाखाओं का सम्मान करने का अतिरिक्त लाभ है (यदि आपके पास कोई है, तो डिफ़ॉल्ट मूल / मास्टर है, इस मामले में यहां कुछ अन्य उत्तर भी काम करेंगे)।

के लिए Git 1.7.3 या इसके बाद के संस्करण आप उपयोग कर सकते हैं (लेकिन क्या अद्यतन अभी भी लागू होता है चारों ओर gotchas नीचे):

git submodule update --recursive

या:

git pull --recurse-submodules

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

देखें Git-submodule (1) जानकारी के लिए

Comments

शायद आपको git submodule update --recursiveआजकल उपयोग करना चाहिए ।

— जेन्स कोहल

प्रदर्शन में सुधार:git submodule foreach "(git checkout master; git pull)&"

— बोगदान गुसिएव

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

— पीटर डेविस

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

— नाथन हॉर्बी

बस सभी के लिए स्पष्ट करना है। git submodule update --recursiveयह देखने के लिए कि प्रत्येक सबमॉड्यूल के लिए माता-पिता के भंडार को किस संशोधन में संग्रहीत किया गया है, फिर प्रत्येक सबमॉड्यूल में उस संशोधन की जांच करता है। यह प्रत्येक सबमॉड्यूल के लिए नवीनतम आवागमन को नहीं खींचता है। git submodule foreach git pull origin masterया git pull origin master --recurse-submodulesआप क्या चाहते हैं यदि आप प्रत्येक मूल उपप्रवेश को उनके मूल रिपॉजिटरी से नवीनतम में अपडेट करने का इरादा रखते हैं। इसके बाद ही आपको सबमॉड्यूल के लिए अपडेट किए गए रिवीजन हैश के साथ पैरेंट रेपो में लंबित बदलाव मिलेंगे। उन की जाँच करें और आप अच्छे हैं।

— Chev

Answer 2

git pull --recurse-submodules --jobs=10

एक फीचर गिट पहले 1.8.5 में सीखा था।

इस समय तक बग तय हो गई है, पहली बार के लिए आप रन की जरूरत है

git सबमॉड्यूल अपडेट --init --recursive

Comments

अपवित्र, मैं इसका उपयोग करता हूं: उपनाम अपडेट_सुबमोडुल्स = 'गिट पुल - क्रेकस-सबमॉड्यूल्स और& गिट सबमॉड्यूल अपडेट'

— स्टीफन सी

यह काम करता है यदि सबमॉडल्स को पहले ही कम से कम एक बार खींच लिया गया हो, लेकिन उन सबमॉड्यूल्स के लिए जिन्हें कभी चेक नहीं किया गया है, तो नीचे गाहुआ का जवाब देखें।

— मैट ब्राउन

यह उस संस्करण तक खिंच जाएगा जो शीर्ष रेपो निर्दिष्ट करता है; यह सिर नहीं खींचता है। उदाहरण के लिए यदि TopRepo, SubRepo के लिए HEAD के पीछे एक संस्करण 2 निर्दिष्ट करता है, तो यह SubRepo को उस संस्करण के साथ खींचेगा जो 2 पीछे है। यहाँ अन्य उत्तर सबरापो में HEAD को खींचते हैं।

— क्रिस मोशिनि

नोट है कि न तो git pull --recurse-submodulesहै और न ही git submodule update --recursiveकरता है नहीं नव submodules जोड़ा आरंभ कर देगा। उन्हें आरंभ करने के लिए आपको चलाने की आवश्यकता है git submodule update --recursive --init। मैनुअल से उद्धरण : यदि सबमॉडल को अभी तक इनिशियलाइज़ नहीं किया गया है, और आप बस सेटिंग को। Initmodspules के रूप में उपयोग करना चाहते हैं, तो आप स्वचालित रूप से --mit ऑप्शन के साथ सबमॉड्यूल को इनिशियलाइज़ कर सकते हैं।

— patryk.beza

हो सकता है कि एक संकेत जोड़ दें git submodule update --recursive --remoteजो सबमॉड्यूल्स को संग्रहीत SHA-1 के बजाय दूरस्थ नवीनतम संशोधन में भी अपडेट करता है।

— हन्नो एस।

Answer 3

निम्नलिखित कमांड चलाने में init पर:

git submodule update --init --recursive

git रेपो डायरेक्टरी के भीतर से, मेरे लिए सबसे अच्छा काम करता है।

यह सबमॉड्यूल सहित सभी नवीनतम खींच देगा।

व्याख्या की

git - the base command to perform any git command
    submodule - Inspects, updates and manages submodules.
        update - Update the registered submodules to match what the superproject
        expects by cloning missing submodules and updating the working tree of the
        submodules. The "updating" can be done in several ways depending on command
        line options and the value of submodule.<name>.update configuration variable.
            --init without the explicit init step if you do not intend to customize
            any submodule locations.
            --recursive is specified, this command will recurse into the registered
            submodules, and update any nested submodules within.

---

इसके बाद आप बस चला सकते हैं:

git submodule update --recursive

git रेपो डायरेक्टरी के भीतर से, मेरे लिए सबसे अच्छा काम करता है।

यह सबमॉड्यूल सहित सभी नवीनतम खींच देगा।

Comments

हां - सबसे ज्यादा वोट दिया गया उत्तर '09 में ऐसा करने का सबसे अच्छा तरीका था, लेकिन यह निश्चित रूप से सरल और अधिक सहज है।

— माइकल स्कॉट कथबर्ट

@MichaelScottCuthbert धन्यवाद, मुझे यकीन है कि एक और 3 साल में यह आदेश भी पागल हो जाएगा

— abc123

फिर भी, यह सबमॉडल से नवीनतम संशोधन की जांच नहीं करता है, केवल नवीनतम संशोधन जो कि माता-पिता को ट्रैक कर रहा है।

— नाथन उस्मान

@ नथनओसमैन जो आप चाहते हैं ... आप माता-पिता के संशोधन ट्रैकिंग का पालन न करके टूटे हुए कोड के साथ समाप्त करेंगे। यदि आप माता-पिता के अनुचर हैं तो आप उन लोगों को अपडेट कर सकते हैं और उन्हें प्रतिबद्ध कर सकते हैं।

— abc123

हां, लेकिन मेरी समझ से, वह नहीं है जो ओपी चाहता था।

— नाथन उस्मान

Answer 4

नोट: यह 2009 से है और तब अच्छा रहा होगा, लेकिन अब बेहतर विकल्प हैं।

हम इसका उपयोग करते हैं। इसे कहा जाता है git-pup:

#!/bin/bash
# Exists to fully update the git repo that you are sitting in...

git pull && git submodule init && git submodule update && git submodule status

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

अपडेट करें:

मूल लेखक द्वारा टिप्पणी के जवाब में सभी सबमॉडल्स के सभी हेड्स में खींचने के बारे में - यह एक अच्छा सवाल है।

मुझे पूरा यकीन है कि gitआंतरिक रूप से इसके लिए कोई आदेश नहीं है। ऐसा करने के लिए, आपको यह पहचानने की आवश्यकता होगी कि HEAD वास्तव में एक सबमॉड्यूल के लिए क्या है। यह उतना ही सरल हो सकता है जितना यह कहा जा सकता है कि यह masterतारीख शाखा, आदि ...

इसके बाद, एक सरल स्क्रिप्ट बनाएं जो निम्न कार्य करता है:

1. git submodule status"संशोधित" रिपॉजिटरी के लिए जाँच करें । आउटपुट लाइनों का पहला वर्ण यह इंगित करता है। यदि कोई सब-रेपो संशोधित किया गया है, तो आप आगे बढ़ना नहीं चाह सकते हैं।
2. सूचीबद्ध प्रत्येक रेपो के लिए, यह निर्देशिका और सीडी में सीडी है git checkout master && git pull। त्रुटियों के लिए जाँच करें।
3. अंत में, मेरा सुझाव है कि आप सबमॉडल्स की वर्तमान स्थिति को इंगित करने के लिए उपयोगकर्ता को एक डिस्प्ले प्रिंट करें - शायद उन्हें सभी को जोड़ने और प्रतिबद्ध करने के लिए संकेत दें?

मैं यह उल्लेख करना चाहूंगा कि यह शैली वास्तव में नहीं है जो गिट सबमॉडल्स के लिए डिज़ाइन की गई थी। आमतौर पर, आप "लाइब्रेरीएक्स" को "2.32" संस्करण में कहना चाहते हैं और जब तक मैं इसे "अपग्रेड" करने के लिए नहीं कहूंगा, तब तक यह रहेगा।

यही है, एक अर्थ में, आप वर्णित स्क्रिप्ट के साथ क्या कर रहे हैं, लेकिन बस अधिक स्वचालित रूप से। देखभाल की आवश्यकता है!

अपडेट 2:

यदि आप एक विंडोज़ प्लेटफ़ॉर्म पर हैं, तो आप स्क्रिप्ट को लागू करने के लिए पायथन का उपयोग करना चाह सकते हैं क्योंकि यह इन क्षेत्रों में बहुत सक्षम है। यदि आप यूनिक्स / लाइनक्स पर हैं, तो मैं सिर्फ बैश स्क्रिप्ट का सुझाव देता हूं।

किसी भी स्पष्टीकरण की आवश्यकता है? बस एक टिप्पणी पोस्ट करें।

Comments

मुझे नहीं लगता कि मैं यही चाहता हूं। सुपर-प्रोजेक्ट के साथ अंतिम बार किए गए सबमॉड्यूल के संस्करण को नहीं खींचेंगे। मैं सभी सबमॉडल्स का हेड वर्जन खींचना चाहता हूं।

— ब्रैड रॉबिन्सन

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

— मैट ब्राउन

मैं अभी प्राप्त कर रहा हूं "वर्तमान शाखा के लिए कोई ट्रैकिंग जानकारी नहीं है। कृपया निर्दिष्ट करें कि आप किस शाखा के साथ विलय करना चाहते हैं।" कोई फर्क नहीं पड़ता कि मैं क्या कोशिश करता हूं: /

— नाथन हॉर्बी

इसके लिए एक उपनाम क्यों नहीं बनाया? git config --global alias.pup '!git pull && git submodule init && git submodule update && git submodule status'और फिर इसे git pupबिना किसी स्क्रिप्टिंग के उपयोग करें ।

— फ्राकज

धन्यवाद, किसी कारण के लिए, भले ही मेरे पास 1.9.1 है, मुझे git submodule initपहले खींचने के बाद प्रदर्शन करना था जिसमें सबमॉड्यूल्स शामिल थे, ताकि सब कुछ ठीक से काम करना शुरू कर दे।

— बेन उस्मान

Answer 5

हेनरिक सही रास्ते पर हैं। 'फॉर्च्यूनर' कमांड किसी भी मनमाना शेल स्क्रिप्ट को निष्पादित कर सकता है। बहुत नवीनतम खींचने के लिए दो विकल्प हो सकते हैं,

git submodule foreach git pull origin master

तथा,

git submodule foreach /path/to/some/cool/script.sh

यह सभी आरंभिक सबमॉड्यूल्स के माध्यम से पुनरावृत्ति करेगा और दिए गए आदेशों को चलाएगा।

Answer 6

निम्न ने विंडोज पर मेरे लिए काम किया।

git submodule init
git submodule update

Comments

यह स्पष्ट रूप से नहीं है कि ओपी ने क्या मांगा। यह केवल संबंधित सबमॉड्यूल कमेटी को अपडेट करेगा और नवीनतम को नहीं।

— पैट्रिक

हालाँकि यह इस पृष्ठ पर केवल एक ही चीज़ है जो

— सबमोडुल्स

यह भी उपयोग कर सकते हैं: git सबमॉड्यूल अपडेट - इनिट - क्रेसीसिव (विशेषकर यदि प्रश्न में सबमॉड्यूल एक ताज़ा क्लोन से RestKit है)

— HCdev

Answer 7

संपादित करें :

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

git submodule foreach --recursive git pull

----- बाहर की टिप्पणी नीचे -----

क्या यह ऐसा करने का आधिकारिक तरीका नहीं है?

git submodule update --init

मैं हर बार इसका इस्तेमाल करता हूं। अब तक कोई समस्या नहीं।

संपादित करें:

मैंने पाया कि आप उपयोग कर सकते हैं:

git submodule foreach --recursive git submodule update --init 

जो सभी सबमॉड्यूल यानी निर्भरता को पुन: खींच लेगा।

Comments

आपका जवाब ओपी के सवाल का जवाब नहीं देता है, लेकिन आपने जो प्रस्तावित किया है उसे करने के लिए आप सिर्फ कह सकते हैंgit submodule update --init --recursive

— फिल्पेरो

मैं देख रहा हूं, नवीनतम संस्करण की आवश्यकता है। खैर यह उपयोगी हो सकता है अगर वहाँ नेस्टेड submodules है: git submodule foreach --recursive git pull

— एंटीटॉक्सिक

मैं इनमें से कोई भी वास्तव में कुछ भी डाउनलोड नहीं कर सका - "git सबमॉड्यूल अपडेट - इनिट - क्रेसीसिव" ने मेरे लिए काम किया।

— BrainSlugs83

Answer 8

जैसा कि यह हो सकता है कि आपके सबमॉडल्स की डिफ़ॉल्ट शाखा नहीं है master , यह है कि मैं पूर्ण गिट सबमॉड्यूल को कैसे स्वचालित करता हूं:

git submodule init
git submodule update
git submodule foreach 'git fetch origin; git checkout $(git rev-parse --abbrev-ref HEAD); git reset --hard origin/$(git rev-parse --abbrev-ref HEAD); git submodule update --recursive; git clean -dfx'

Comments

कई सवालों के कई जवाबों में से, इसने मेरे लिए काम किया (2019, विशिष्ट हैश आईडी के साथ

— जीथब

Answer 9

पहली बार

क्लोन और इनिट सबमॉड्यूल

git clone [e-mail]:speedovation/kiwi-resources.git resources
git submodule init

आराम

विकास के दौरान बस सबमॉड्यूल को खींचें और अपडेट करें

git pull --recurse-submodules  && git submodule update --recursive

मूल पर नवीनतम कमिट के लिए Git सबमॉड्यूल अपडेट करें

git submodule foreach git pull origin master

पसंदीदा तरीका नीचे होना चाहिए

git submodule update --remote --merge

नोट: पिछले दो आदेशों में समान व्यवहार है

Comments

मैंने गलती से कोई सबमॉड्यूल्स के साथ एक क्लोन क्लोन किया और अन्य सभी विकल्पों ने काम नहीं किया, किसी ने क्लोन सबमॉड्यूल्स नहीं किया। तुम्हारा उपयोग करते हुए, git submodule updateचाल चली। अब मैं पहले चरण से गायब सबमॉडल्स डेटा डाउनलोड कर रहा हूं। धन्यवाद। मैं git में अच्छा नहीं हूँ: C

— m3nda

यह एज़र वास्तव में शीर्ष पर एक सवाल पूछने के लिए एक बहुत अच्छा जवाब है: मुझे ".. --recursive-submodules .." क्यों करना है और इसके बाद "... अद्यतन ..." और यहां तक ​​कि ".." .foreach ... "बाद में नवीनतम कमिटमेंट प्राप्त करने के लिए? यह सब जीआईटी की तरह नहीं दिखता है! "अपडेट" क्या कर रहा है और मुझे खींचने के लिए प्रत्येक मॉड्यूल पर मैन्युअल रूप से क्यों जाना है? क्या ऐसा नहीं है कि "... --recurse-submodules .." कर रहा है? कोई संकेत?

— पीटर ब्रैनफॉर्न

Answer 10

मुझे नहीं पता कि यह किस संस्करण से काम कर रहा है, लेकिन यह वही है जो आप खोज रहे हैं:

git submodule update --recursive

मैं इसका उपयोग git pullरूट रिपॉजिटरी को अपडेट करने के लिए भी करता हूं :

git pull && git submodule update --recursive

Answer 11

उपरोक्त उत्तर अच्छे हैं, हालांकि हम इसे आसान बनाने के लिए गिट-हुक का उपयोग कर रहे थे लेकिन यह पता चलता है कि गिट 2.14 में , आप git config submodule.recurseसबमॉड्यूल को सक्षम करने के लिए सही सेट कर सकते हैं जब आप अपने गिट रिपॉजिटरी में खींच सकते हैं।

यह उन सभी सबमॉडल्स परिवर्तन को धक्का देने का दुष्प्रभाव होगा जो अगर वे शाखाओं पर हैं, लेकिन अगर आपको उस व्यवहार की आवश्यकता है तो यह काम कर सकता है।

का उपयोग करके किया जा सकता है:

git config submodule.recurse true

Comments

यह विकल्प पसंद आएगा, दुर्भाग्य से अभी भी git submodule initहाथ से पहले उपयोग करने की आवश्यकता है, अगर आपका सबमॉडल अभी तक आरंभीकृत नहीं हुआ है।

— पेलेट

Answer 12

विंडोज़ के लिए गिट्टी 2.6.3 :

git submodule update --rebase --remote

Comments

बस यही एक काम है मेरे लिए। मैं भी init या अपडेट करने में सक्षम नहीं था क्योंकि सबमॉड्यूल पॉइंटर एक ऐसे संस्करण की ओर इशारा कर रहा था जो अब रिमोट में नहीं था

— Pavel P

Answer 13

रेपो में शीर्ष स्तर से:

git submodule foreach git checkout develop
git submodule foreach git pull

यह नवीनतम विकसित करने और खींचने के लिए सभी शाखाओं को स्विच करेगा

Comments

मेरे लिए काम नहीं करता है, जीआईटी 2.7 के साथ।

— ब्रूनो हैबल

क्या आपके पास एवरीवन स्लन फाइल जैसा कुछ है जो पेड़ में सभी परियोजना संदर्भ जोड़ता है? इसके अलावा आप क्या त्रुटि देखते हैं? क्या आप अपनी gitignore फ़ाइल को भी देख सकते हैं

— Srayan Guhathakurta

git submodule foreach git pull origin masterमुझे उस शाखा को जोड़ना था जिसे मैं लाना चाहता था। इसके अलावा, पूरी तरह से काम किया।

— Torxed

Answer 14

मैंने यह ऊपर दिए गए गाहुआ के उत्तर को स्वीकार करके किया है :

इसे एक एकीकरण के साथ एकीकृत करें [alias]...

यदि आपकी मूल परियोजना में कुछ इस तरह है .gitmodules:

[submodule "opt/submodules/solarized"]
    path = opt/submodules/solarized
    url = [e-mail]:altercation/solarized.git
[submodule "opt/submodules/intellij-colors-solarized"]
    path = opt/submodules/intellij-colors-solarized
    url = [e-mail]:jkaving/intellij-colors-solarized.git

अपने .gitconfig के अंदर कुछ इस तरह जोड़ें

[alias]
    updatesubs = "!sh -c \"git submodule init && git submodule update && git submodule status\" "

फिर अपने सबमॉडल्स को अपडेट करने के लिए, रन करें:

git updatesubs

मेरे पास मेरे पर्यावरण सेटअप रेपो में इसका एक उदाहरण है ।

Answer 15

अब आपको बस एक सरल करने की आवश्यकता है git checkout

बस इसे इस वैश्विक कॉन्फ़िग के माध्यम से सक्षम करना सुनिश्चित करें: git config --global submodule.recurse true

Answer 16

यहाँ आपके सभी git रिपॉजिटरी से खींचने के लिए कमांड-लाइन है कि वे सबमोडुल्स हैं या नहीं:

ROOT=$(git rev-parse --show-toplevel 2> /dev/null)
find "$ROOT" -name .git -type d -execdir git pull -v ';'

आप अपने शीर्ष Git भंडार में यह चल रहा है, तो आप बदल सकते हैं "$ROOT"में .।

Answer 17

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

Answer 18

टिप्पणी: बहुत आसान तरीका नहीं है, लेकिन काम करने योग्य है और इसके अपने अलग-अलग नियम हैं।

यदि कोई HEADएक रिपॉजिटरी का केवल संशोधन करना चाहता है और HEADउसके सभी सबमॉड्यूल्स (यानी "ट्रंक" चेकआउट करने के लिए) है, तो कोई लूआ स्क्रिप्ट का उपयोग कर सकता है । कभी-कभी साधारण आदेश के git submodule update --init --recursive --remote --no-fetch --depth=1परिणामस्वरूप एक अपरिवर्तनीय gitत्रुटि हो सकती है। इस स्थिति में किसी को आदेश .git/modulesका उपयोग करके मैन्युअल रूप से उपनिर्देशिका और क्लोन सबमॉड्यूल को साफ करने की आवश्यकता होती है git clone --separate-git-dir। एकमात्र जटिलता यह है कि URL का पता लगाएं , सबमॉड्यूल की .gitनिर्देशिका का मार्ग और सुपरप्रोजेक्ट ट्री में सबमॉडल का मार्ग।

टिप्पणी: स्क्रिप्ट केवल https://github.com/boostorg/boost.gitभंडार के खिलाफ परीक्षण की जाती है। इसकी ख़ासियत: एक ही होस्ट पर होस्ट किए गए सभी सबमॉडल्स और .gitmodulesकेवल रिश्तेदार URL होते हैं ।

-- mkdir boost ; cd boost ; lua ../git-submodules-clone-HEAD.lua https://github.com/boostorg/boost.git .
local module_url = arg[1] or 'https://github.com/boostorg/boost.git'
local module = arg[2] or module_url:match('.+/([_%d%a]+)%.git')
local branch = arg[3] or 'master'
function execute(command)
    print('# ' .. command)
    return os.execute(command)
end
-- execute('rm -rf ' .. module)
if not execute('git clone --single-branch --branch master --depth=1 ' .. module_url .. ' ' .. module) then
    io.stderr:write('can\'t clone repository from ' .. module_url .. ' to ' .. module .. '\n')
    return 1
end
-- cd $module ; git submodule update --init --recursive --remote --no-fetch --depth=1
execute('mkdir -p ' .. module .. '/.git/modules')
assert(io.input(module .. '/.gitmodules'))
local lines = {}
for line in io.lines() do
    table.insert(lines, line)
end
local submodule
local path
local submodule_url
for _, line in ipairs(lines) do
    local submodule_ = line:match('^%[submodule %"([_%d%a]-)%"%]$')
    if submodule_ then
        submodule = submodule_
        path = nil
        submodule_url = nil
    else
        local path_ = line:match('^%s*path = (.+)$')
        if path_ then
            path = path_
        else
            submodule_url = line:match('^%s*url = (.+)$')
        end
        if submodule and path and submodule_url then
            -- execute('rm -rf ' .. path)
            local git_dir = module .. '/.git/modules/' .. path:match('^.-/(.+)$')
            -- execute('rm -rf ' .. git_dir)
            execute('mkdir -p $(dirname "' .. git_dir .. '")')
            if not execute('git clone --depth=1 --single-branch --branch=' .. branch .. ' --separate-git-dir ' .. git_dir .. ' ' .. module_url .. '/' .. submodule_url .. ' ' .. module .. '/' .. path) then
                io.stderr:write('can\'t clone submodule ' .. submodule .. '\n')
                return 1
            end
            path = nil
            submodule_url = nil
        end
    end
end