दिलचस्प पोस्ट
कैसे ggplot2 आर भूखंडों में अक्षों की सीमा निर्धारित करने के लिए? DOCTYPE क्या है? ListView में छवियों को लोड करने के लिए AsyncTask का उपयोग करना I386 और x86-64 पर यूनिक्स और लिनक्स सिस्टम कॉल के लिए कॉलिंग सम्मेलनों क्या हैं I कॉइन का उपयोग करके अच्छा इनपुट सत्यापन पाश – C ++ स्विफ्ट – स्ट्रिंग टू इन्ट को परिवर्तित करना स्टैनफोर्ड पार्सर और एनएलटीके NullPointerException onCreate में दृश्यों को एक्सेस करना () आईफोन पर भी चुप मोड में ध्वनि चलाएं एक स्ट्रिंग में उसका नाम दिया गया एक चर का मान कैसे प्राप्त करें? MySQL में एक पूर्णांक अनुक्रम उत्पन्न करता है SHA1 बनाम एमडी 5 बनाम SHA256: जो एक PHP लॉगिन के लिए उपयोग करना है? "पीएक्स", "डुबकी", "डीपी" और "एसपी" के बीच अंतर क्या है? त्रिज्या और किनारों के आसपास के बिंदु के साथ एक चक्र बनाएं पायथन के लिए टिनकिनटर स्थापित करें

संयुक्त राष्ट्र के एक दल ने एक git submodule

मैं एक जीआईटी सबड्यूम्डी (सभी कोड को वापस कोर में लाने के लिए) कैसे अनलोड कर सकता हूँ?

जैसा कि "कैसे" मैं, जैसा कि "सर्वश्रेष्ठ प्रक्रिया" के रूप में …

वेब के समाधान से एकत्रित समाधान "संयुक्त राष्ट्र के एक दल ने एक git submodule"

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

 git rm --cached submodule_path # delete reference to submodule HEAD (no trailing slash) git rm .gitmodules # if you have more than one submodules, # you need to edit this file instead of deleting! rm -rf submodule_path/.git # make sure you have backup!! git add submodule_path # will add files instead of commit reference git commit -m "remove submodule" 

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

मुख्य मॉड्यूल में आपको निम्न करने की आवश्यकता होगी:

 # Fetch the submodule commits into the main repository git remote add submodule_origin git://url/to/submodule/origin git fetch submodule_origin # Start a fake merge (won't change any files, won't commit anything) git merge -s ours --no-commit submodule_origin/master # Do the same as in the first solution git rm --cached submodule_path # delete reference to submodule HEAD git rm .gitmodules # if you have more than one submodules, # you need to edit this file instead of deleting! rm -rf submodule_path/.git # make sure you have backup!! git add submodule_path # will add files instead of commit reference # Commit and cleanup git commit -m "removed submodule" git remote rm submodule_origin 

परिणामी भंडार थोड़ा अजीब दिखेगा: एक से अधिक प्रारंभिक प्रतिबद्ध हो जाएगा। लेकिन यह git के लिए कोई समस्या नहीं पैदा करेगा।

इस दूसरे समाधान में आपको बड़ा फायदा होगा कि आप अभी भी फाइलों पर जीआईटी दोष या जीआईटी लॉग चला सकते हैं जो मूलतः सबमोडुल्स में थे। वास्तव में आपने यहाँ क्या किया है कि एक रिपॉजिटरी में कई फाइलों का नाम बदलना है, और git को यह स्वतः खोजना चाहिए। यदि आपके पास अभी भी git लॉग के साथ समस्या है, तो कुछ विकल्प (- -Follow, -M, -C) का प्रयास करें, जो बेहतर नाम बदलने / कॉपी पता लगाने का काम करते हैं।

जीआईटी 1.8.5 (नवंबर 2013 ) के बाद से (एपोड्यूल के इतिहास को ध्यान में रखते हुए ):

 mv yoursubmodule yoursubmodule_tmp git submodule deinit yourSubmodule git rm yourSubmodule mv yoursubmodule_tmp yoursubmodule git add yoursubmodule 

वो होगा:

  • पंजीकरण रद्द करें और अनलोड करें (यानी सामग्री को हटाना ) सबमोडी ( deinit , इसलिए mv पहले ),
  • आप के लिए .gitmodules साफ़ करें ( rm ),
  • और माता-पिता रिपो ( rm ) के सूचकांक में एडीयूएम एसएएच 1 को दर्शाने वाली विशेष प्रविष्टि को हटा दें।

एक बार जब सबमिशन को हटाया जाता है ( deinit और git rm ), तो आप फ़ोल्डर को उसके मूल नाम पर पुनर्नामित कर सकते हैं और उसे एक नियमित फ़ोल्डर के रूप में जीआईटी रेपो में जोड़ सकते हैं।

नोट: यदि एक पुरानी गीट (<1.8) द्वारा सबलोडन बनाया गया था, तो आपको .git पूर्व की टिप्पणी के रूप में नेस्टेड .git फ़ोल्डर को स्वयं ही .git निकालना होगा।


यदि आपको सबमिशन के इतिहास को रखने की आवश्यकता है, तो जसीर्स का जवाब देखें , जो git filter-branch का उपयोग करता है

यह हमारे साथ हुआ कि हमने 2 परियोजनाओं के लिए 2 रिपॉजिटरी बनाई जो इतने युग्मित थे कि उन्हें अलग करने का कोई मतलब नहीं था, इसलिए हमने उन्हें विलय कर दिया।

मैं दिखाता हूँ कि कैसे प्रत्येक में मास्टर शाखाओं को मर्ज करने के लिए और फिर मैं बताएगा कि आप इसे कैसे प्राप्त की जा सकने वाली हर शाखाओं में बढ़ा सकते हैं, आशा है कि यह आपको मदद करेगी।

यदि आप काम कर रहे हैं submodule, और आप इसे एक निर्देशिका में कन्वर्ट करना चाहते हैं जगह आप कर सकते हैं:

 git clone project_uri project_name 

यहाँ हम काम करने के लिए एक साफ क्लोन करते हैं इस प्रक्रिया के लिए आपको सबम्यूड्यूल को प्रारंभ या अपडेट करने की आवश्यकता नहीं है, इसलिए इसे छोड़ दें।

 cd project_name vim .gitmodules 

आपके पसंदीदा एडिटर (या विम) के साथ .gitmodules को बदलने के लिए आप जिस डिस्प्ले को बदलना चाहते हैं उसे संपादित करें। जिन पंक्तियों को आप निकालना चाहते हैं वे कुछ ऐसा दिखना चाहिए:

 [submodule "lib/asi-http-request"] path = lib/asi-http-request url = https://github.com/pokeb/asi-http-request.git 

फाइल को सहेजने के बाद,

 git rm --cached directory_of_submodule git commit -am "Removed submodule_name as submodule" rm -rf directory_of_submodule 

यहां हम सबुमुलेशन संबंध को पूरी तरह से हटा देते हैं ताकि हम अन्य रेपो को परियोजना में जगह दे सकें।

 git remote add -f submodule_origin submodule_uri git fetch submodel_origin/master 

यहां हम विलय करने के लिए सबपलोड रिपॉजिटरी लाते हैं।

 git merge -s ours --no-commit submodule_origin/master 

यहां हम 2 रिपॉजिटरी के मर्ज ऑपरेशन प्रारंभ करते हैं, लेकिन प्रतिबद्ध होने से पहले रोकें।

 git read-tree --prefix=directory_of_submodule/ -u submodule_origin/master 

यहां हम मास्टर की सामग्री को सबमिंड में निर्देशिका में भेजते हैं, जहां डायरेक्टरी नाम को प्रीफिक्स करने से पहले था

 git commit -am "submodule_name is now part of main project" 

यहां हम मर्ज में हुए बदलावों की एक प्रतिबद्धता को पूरा करते हैं।

इसे पूरा करने के बाद आप किसी अन्य शाखा से फिर से शुरू कर सकते हैं, मर्ज कर सकते हैं, बस उस रिपॉजिटरी में शाखा की जांच करें जो परिवर्तनों को प्राप्त करेगी और आप मर्ज और पढ़ने-पेड़ के संचालन में लाने वाली शाखा को बदल सकेंगी।

मैंने एक स्क्रिप्ट बनाई है जो सभी फाइल इतिहास को बरकरार रखे हुए एक सरल निर्देशिका में एक सबलोड का अनुवाद करेगा। यह git log --follow <file> मुद्दों से ग्रस्त नहीं होता है कि अन्य समाधान पीड़ित हैं यह भी एक बहुत आसान एक-लाइन आमंत्रण है जो आपके लिए सभी काम करता है। G'luck।

यह ल्यूकस जेनस द्वारा उत्कृष्ट काम पर बनाता है, जो अपने ब्लॉग पोस्ट में " पैरेंट रिपॉजिटरी में एक सबमिंडिंग को एकीकृत करना " में वर्णित है, लेकिन पूरी प्रक्रिया को स्वचालित करता है और कुछ अन्य कोने के मामलों को साफ करता है

नवीनतम कोड को गिटूब पर https://github.com/jeremysears/scripts/blob/master/bin/git-submodule-rewrite पर बगफिक्स के साथ बनाए रखा जाएगा, लेकिन उचित स्टैकेवरफ्लो उत्तर प्रोटोकॉल के लिए, मैंने इसमें शामिल किया है समाधान पूरी तरह से नीचे

उपयोग:

 $ git-submodule-rewrite <submodule-name> 

Git-submodule-रीराइट:

 #!/usr/bin/env bash # This script builds on the excellent work by Lucas Jenß, described in his blog # post "Integrating a submodule into the parent repository", but automates the # entire process and cleans up a few other corner cases. # https://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html function usage(){ echo "Merge a submodule into a repo, retaining file history." echo "Usage: $0 <submodule-name>" echo "" echo "options:" echo " -h, --help Print this message" echo " -v, --verbose Display verbose output" } function abort { echo "$(tput setaf 1)$1$(tput sgr0)" exit 1 } function request_confirmation { read -p "$(tput setaf 4)$1 (y/n) $(tput sgr0)" [ "$REPLY" == "y" ] || abort "Aborted!" } function warn() { cat << EOF This script will convert your "${sub}" git submodule into a simple subdirectory in the parent repository while retaining all contents and file history. The script will: * delete the ${sub} submodule configuration from .gitmodules and .git/config and commit it. * rewrite the entire history of the ${sub} submodule so that all paths are prefixed by ${path}. This ensures that git log will correctly follow the original file history. * merge the submodule into its parent repository and commit it. NOTE: This script might completely garble your repository, so PLEASE apply this only to a fresh clone of the repository where it does not matter if the repo is destroyed. It would be wise to keep a backup clone of your repository, so that you can reconstitute it if need be. You have been warned. Use at your own risk. EOF request_confirmation "Do you want to proceed?" } function git_version_lte() { OP_VERSION=$(printf "%03d%03d%03d%03d" $(echo "$1" | tr '.' '\n' | head -n 4)) GIT_VERSION=$(git version) GIT_VERSION=$(printf "%03d%03d%03d%03d" $(echo "${GIT_VERSION#git version}" | tr '.' '\n' | head -n 4)) echo -e "${GIT_VERSION}\n${OP_VERSION}" | sort | head -n1 [ ${OP_VERSION} -le ${GIT_VERSION} ] } function main() { warn if [ "${verbose}" == "true" ]; then set -x fi # Remove submodule and commit git config -f .gitmodules --remove-section "submodule.${sub}" if git config -f .git/config --get "submodule.${sub}.url"; then git config -f .git/config --remove-section "submodule.${sub}" fi rm -rf "${path}" git add -A . git commit -m "Remove submodule ${sub}" rm -rf ".git/modules/${sub}" # Rewrite submodule history local tmpdir="$(mktemp -d -t submodule-rewrite-XXXXXX)" git clone "${url}" "${tmpdir}" pushd "${tmpdir}" local tab="$(printf '\t')" local filter="git ls-files -s | sed \"s/${tab}/${tab}${path}\//\" | GIT_INDEX_FILE=\${GIT_INDEX_FILE}.new git update-index --index-info && mv \${GIT_INDEX_FILE}.new \${GIT_INDEX_FILE}" git filter-branch --index-filter "${filter}" HEAD popd # Merge in rewritten submodule history git remote add "${sub}" "${tmpdir}" git fetch "${sub}" if git_version_lte 2.8.4 then # Previous to git 2.9.0 the parameter would yield an error ALLOW_UNRELATED_HISTORIES="" else # From git 2.9.0 this parameter is required ALLOW_UNRELATED_HISTORIES="--allow-unrelated-histories" fi git merge -s ours --no-commit ${ALLOW_UNRELATED_HISTORIES} "${sub}/master" rm -rf tmpdir # Add submodule content git clone "${url}" "${path}" rm -rf "${path}/.git" git add "${path}" git commit -m "Merge submodule contents for ${sub}" git config -f .git/config --remove-section "remote.${sub}" set +x echo "$(tput setaf 2)Submodule merge complete. Push changes after review.$(tput sgr0)" } set -euo pipefail declare verbose=false while [ $# -gt 0 ]; do case "$1" in (-h|--help) usage exit 0 ;; (-v|--verbose) verbose=true ;; (*) break ;; esac shift done declare sub="${1:-}" if [ -z "${sub}" ]; then >&2 echo "Error: No submodule specified" usage exit 1 fi shift if [ -n "${1:-}" ]; then >&2 echo "Error: Unknown option: ${1:-}" usage exit 1 fi if ! [ -d ".git" ]; then >&2 echo "Error: No git repository found. Must be run from the root of a git repository" usage exit 1 fi declare path="$(git config -f .gitmodules --get "submodule.${sub}.path")" declare url="$(git config -f .gitmodules --get "submodule.${sub}.url")" if [ -z "${path}" ]; then >&2 echo "Error: Submodule not found: ${sub}" usage exit 1 fi if ! [ -d "${path}" ]; then >&2 echo "Error: Submodule path not found: ${path}" usage exit 1 fi main 
  1. git rm --cached the_submodule_path
  2. .submodules फ़ाइल से सबमिशन अनुभाग को हटा दें
  3. एक प्रतिबद्ध "हटाया गया submodule xyz"
  4. git add the_submodule_path
  5. एक और "xyz के जोड़ा गया कोडबेस"

मुझे अभी तक कोई आसान रास्ता नहीं मिला। आप 3-5 git commit -a – स्वाद के मामले के माध्यम से एक चरण में एक सेकेंड सेक कर सकते हैं।

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

इस उदाहरण के लिए मुख्य रिपो git@site.com:main/main.git होगा git@site.com:main/main.git और git@site.com:main/main.git रेपो git@site.com:main/child.git । यह मानता है कि सबपलोड मूल अभिविन्यास के मूल निर्देशिका में स्थित है। आवश्यकतानुसार निर्देश समायोजित करें

माता पिता के रिपो को क्लोन करना और पुरानी पोड्यूम को निकालने से प्रारंभ करें

 git clone git@site.com:main/main.git git submodule deinit child git rm child git add --all git commit -m "remove child submodule" 

अब हम मुख्य रिपो अपस्ट्रीम को अपस्ट्रीम से लेकर बाल रेपो तक जोड़ देंगे।

 git remote add upstream git@site.com:main/child.git git fetch upstream git checkout -b merge-prep upstream/master 

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

 mkdir child 

सभी फ़ोल्डर्स और फाइल को फ़ोल्डर फ़ोल्डर में छोड़ दें।

 git add --all git commit -m "merge prep" 

अब आप आसानी से अपनी फ़ाइलों को मास्टर शाखा में वापस मर्ज कर सकते हैं

 git checkout master git merge merge-prep # --allow-unrelated-histories merge-prep flag may be required 

चारों ओर देखो और सुनिश्चित करें कि सब कुछ ठीक है git push चलाने से पहले

एक बात जिसे आपको अब याद रखना है कि जीआईटी लॉग डिफ़ॉल्ट रूप से चले गए फाइलों का पालन नहीं करता है, लेकिन git log --follow filename आप अपनी फ़ाइलों का पूरा इतिहास देख सकते हैं।

मैंने पाया है कि इसका सबसे अच्छा जवाब यहां है:

http://x3ro.de/2013/09/01/Integrating-a-submodule-into-the-parent-repository.html

यह लेख प्रक्रिया को बहुत अच्छी तरह बताता है

जब के लिए

 git rm [-r] --cached submodule_path 

रिटर्न

 fatal: pathspec 'emr/normalizers/' did not match any files 

संदर्भ: मैंने अपने submodule फ़ोल्डर्स में rm -r .git* को पूरा करने से पहले यह महसूस किया कि उन्हें उन मुख्य परियोजना में शामिल होने की जरूरत थी, जिसके लिए मैंने उन्हें जोड़ा था। मुझे उपरोक्त त्रुटि मिलती है, जब कुछ को डूबने लगता है, लेकिन उन सभी को नहीं। वैसे भी, मैंने उन्हें चलाने से तय किया, (निश्चित रूप से, rm -r .git* )

 mv submodule_path submodule_path.temp git add -A . git commit -m "De-submodulization phase 1/2" mv submodule_path.temp submodule_path git add -A . git commit -m "De-submodulization phase 2/2" 

ध्यान दें कि यह इतिहास को संरक्षित नहीं करता है

वर्तमान शीर्ष उत्तर का थोड़ा बेहतर संस्करण (आईएमएचओ) है:

एक अलग डायर में (गलतियों को साफ करने और फिर से कोशिश करने के लिए आसान) दोनों शीर्ष रेपो और सबरेपो को देखें

 git clone ../main_repo main.tmp git clone ../main_repo/sub_repo sub.tmp 

पहले वांछित उपनिर्देशिका में सभी फाइलों को स्थानांतरित करने के लिए सबरेपो को संपादित करें

 cd sub.tmp mkdir sub_repo_path git mv `ls | grep -v sub_repo_path` sub_repo_path/ git commit -m "Moved entire subrepo into sub_repo_path" 

सिर का एक नोट बनाओ

 SUBREPO_HEAD=`git reflog | awk '{ print $1; exit; }'` 

अब मुख्य रिपो से उपप्रो हटाएं

 cd ../main.tmp rmdir sub_repo_path vi .gitmodules # remove config for submodule git add -A git commit -m "Removed submodule sub_repo_path in preparation for merge" 

और अंत में, बस उन्हें मर्ज करें

 git fetch ../sub.tmp git merge $SUBREPO_HEAD 

और हो गया! सुरक्षित और किसी भी जादू के बिना

वॉनसी के उत्तर के आधार पर, मैंने एक सरल बाश स्क्रिप्ट बनाई है जो यह करता है। अंत में add लिए वाइल्डकार्ड का उपयोग करना पड़ता है अन्यथा यह rm लिए पिछले rm को पूर्ववत कर देगा एब्ड्यूल डायरेक्टरी की सामग्री को जोड़ना महत्वपूर्ण है, और add कमांड में डायरेक्टरी का नाम नहीं देना है।

git-integrate-submodule नामक फ़ाइल में:

 #!/usr/bin/env bash mv "$1" "${1}_" git submodule deinit "$1" git rm "$1" mv "${1}_" "$1" git add "$1/**" 

मैं इसे अधिक सुविधाजनक (भी?) Submodule से स्थानीय प्रतिबद्ध डेटा लाने के लिए, क्योंकि अन्यथा मैं उन्हें खो देंगे पाया। (उन रिमोट तक पहुंच नहीं के रूप में उन्हें धक्का नहीं दिया जा सकता है)। इसलिए मैंने submodule / .git को remote_origin2 के रूप में जोड़ा, इसे प्राप्त किया और उस शाखा से मिला दिया गया। यकीन नहीं है कि मुझे अभी भी मूल रूप से उपलक्ष्य की आवश्यकता है, क्योंकि मैं अभी तक git के साथ पर्याप्त परिचित नहीं हूँ