Wie importiere ich ein bestehendes Git Repository in ein anderes?

Wahrscheinlich die einfachste Möglichkeit wäre, ziehen die XXX Sachen in eine Filiale in YYY und dann merge in master:

YYY:

git remote add other /path/to/XXX
git fetch other
git checkout -b ZZZ other/master
mkdir ZZZ
git mv stuff ZZZ/stuff                      # repeat as necessary for each file/dir
git commit -m "Moved stuff to ZZZ"
git checkout master                
git merge ZZZ --allow-unrelated-histories   # should add ZZZ/to master
git commit
git remote rm other
git branch -d ZZZ                           # to get rid of the extra branch before pushing
git push                                    # if you have a remote, that is

Ich eigentlich nur versucht, diese mit ein paar von meinen repos und es funktioniert. Im Gegensatz zu Jörg ' s Antwort es nicht zulassen, Sie weiterhin zu nutzen das andere repo, aber ich glaube nicht, dass Sie angegeben, dass sowieso.

Hinweis: Da dies ursprünglich geschrieben wurde, im Jahr 2009, git Hinzugefügt hat, die Teilbaum-merge erwähnt in der Antwort unten. Ich würde wahrscheinlich benutzen diese Methode heute noch, obwohl natürlich diese Methode funktioniert immer noch.

InformationsquelleAutor der Antwort ebneter

git-subtree ist ein Skript entworfen für genau diesen Anwendungsfall der Zusammenführung mehrerer repositories in einer unter Wahrung der Geschichte (und/oder Spaltung der Geschichte von teilbäumen, aber das scheint irrelevant zu sein auf diese Frage). Es verteilt als Bestandteil des git-Baum seit Version 1.7.11.

Merge repository <repo> revision <rev> als Unterverzeichnis <prefix> verwenden git subtree add wie folgt:

git subtree add -P <prefix> <repo> <rev>

git-subtree implementiert die Teilbaum-merge-Strategie in benutzerfreundlicher Art und Weise.

Für Ihren Fall, innen-repository YYY, Sie laufen würde:

git subtree add -P ZZZ /path/to/XXX.git master

InformationsquelleAutor der Antwort kynan

Den einfachen Weg, das zu tun, ist die Verwendung von git-format-patch.

Angenommen, wir haben 2 git repositories foo und bar.

foo enthält:

• foo.txt
• .git

bar enthält:

• bar.txt
• .git

und wir wollen zu Ende-up mit foo mit der bar Geschichte und diese Dateien:

• foo.txt
• .git
• foobar/bar.txt

Damit zu tun, dass:

 1. create a temporary directory eg PATH_YOU_WANT/patch-bar
 2. go in bar directory
 3. git format-patch --root HEAD --no-stat -o PATH_YOU_WANT/patch-bar --src-prefix=a/foobar/--dst-prefix=b/foobar/
 4. go in foo directory
 5. git am PATH_YOU_WANT/patch-bar/*

Und wenn wir wollen, neu zu schreiben, alle Nachrichten-übertragungen aus der bar, die wir tun können, zB auf Linux:

git filter-branch --msg-filter 'sed "1s/^/\[bar\] /"' COMMIT_SHA1_OF_THE_PARENT_OF_THE_FIRST_BAR_COMMIT..HEAD

Diese fügen "[bar] " am Anfang jeder commit-Nachricht.

InformationsquelleAutor der Antwort Damien R.

Hinzufügen einer weiteren Antwort, da ich denke, das ist ein bisschen einfacher. Ein ziehen von repo_dest erfolgt in repo_to_import und dann eine push --set-upstream-url:repo_dest master ist fertig.

Diese Methode hat bei mir geklappt importieren mehrere kleinere repos in ein größeres.

Wie zu importieren: repo1_to_import zu repo_dest

# checkout your repo1_to_import if you don't have it already 
git clone url:repo1_to_import repo1_to_import
cd repo1_to_import

# now. pull all of repo_dest
git pull url:repo_dest
ls 
git status # shows Your branch is ahead of 'origin/master' by xx commits.
# now push to repo_dest
git push --set-upstream url:repo_dest master

# repeat for other repositories you want to import

Umbenennen oder verschieben von Dateien und Verzeichnissen in die gewünschte position im original-repo vor dem import. z.B.

cd repo1_to_import
mkdir topDir
git add topDir
git mv this that and the other topDir/
git commit -m"move things into topDir in preparation for exporting into new repo"
# now do the pull and push to import

Beschriebene Methode auf den folgenden link, inspiriert diese Antwort. Ich mochte es, wie es schien einfacher. ABER Vorsicht! Es werden Drachen! https://help.github.com/articles/importing-an-external-git-repository git push --mirror url:repo_dest schiebt Ihre lokale repo-Geschichte und Staat-Fernbedienung (url:repo_dest). ABER es löscht die alte Geschichte und den Zustand der Fernbedienung. Spaß macht es! :-E

InformationsquelleAutor der Antwort gaoithe

Diese Funktion clone remote-repo in das lokale repo dir, nach der Fusion alle commits gespeichert werden, git log wird zeigen, dem original verpflichtet und richtige Wege:

function git-add-repo
{
    repo="$1"
    dir="$(echo "$2" | sed 's/\/$//')"
    path="$(pwd)"

    tmp="$(mktemp -d)"
    remote="$(echo "$tmp" | sed 's/\///g'| sed 's/\./_/g')"

    git clone "$repo" "$tmp"
    cd "$tmp"

    git filter-branch --index-filter '
        git ls-files -s |
        sed "s,\t,&'"$dir"'/," |
        GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
        mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
    ' HEAD

    cd "$path"
    git remote add -f "$remote" "file://$tmp/.git"
    git pull "$remote/master"
    git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
    git remote remove "$remote"
    rm -rf "$tmp"
}

Wie zu verwenden:

cd current/package
git-add-repo https://github.com/example/example dir/to/save

Wenn etwas änderungen, die Sie können sogar verschieben von Dateien/Verzeichnissen zusammengeführt repo in verschiedene Wege, zum Beispiel:

repo="https://github.com/example/example"
path="$(pwd)"

tmp="$(mktemp -d)"
remote="$(echo "$tmp" | sed 's/\///g' | sed 's/\./_/g')"

git clone "$repo" "$tmp"
cd "$tmp"

GIT_ADD_STORED=""

function git-mv-store
{
    from="$(echo "$1" | sed 's/\./\\./')"
    to="$(echo "$2" | sed 's/\./\\./')"

    GIT_ADD_STORED+='s,\t'"$from"',\t'"$to"',;'
}

# NOTICE! This paths used for example! Use yours instead!
git-mv-store 'public/index.php' 'public/admin.php'
git-mv-store 'public/data' 'public/x/_data'
git-mv-store 'public/.htaccess' '.htaccess'
git-mv-store 'core/config' 'config/config'
git-mv-store 'core/defines.php' 'defines/defines.php'
git-mv-store 'README.md' 'doc/README.md'
git-mv-store '.gitignore' 'unneeded/.gitignore'

git filter-branch --index-filter '
    git ls-files -s |
    sed "'"$GIT_ADD_STORED"'" |
    GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
    mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
' HEAD

GIT_ADD_STORED=""

cd "$path"
git remote add -f "$remote" "file://$tmp/.git"
git pull "$remote/master"
git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
git remote remove "$remote"
rm -rf "$tmp"

Hinweise

Pfade ersetzt über sed, so stellen Sie sicher, dass es verschoben in richtige Pfade nach der Zusammenführung.

Die --allow-unrelated-histories parameter existiert nur, da git >= 2.9.

InformationsquelleAutor der Antwort Andrey Izman

Sehen einfaches Beispiel in dieser Artikel und betrachten eine solche Zuordnung auf Repositorys:

• A <-> YYY
• B <-> XXX

Nachdem alle Aktivitäten die in diesem Kapitel beschrieben (nach der Zusammenführung), entfernen Zweig B-master:

$ git branch -d B-master

Dann drücken Sie die änderungen.

Es funktioniert für mich.

InformationsquelleAutor der Antwort VeLKerr

Ich denke, Sie können dies tun, mit "git mv' und 'git pull'.

Ich bin ein fair-git-noob - also seien Sie vorsichtig mit Ihrem Haupt-repository - aber ich habe nur versucht, diese in ein temp-dir und es scheint zu funktionieren.

Erste - benennen Sie die Struktur von XXX zu passen, wie Sie möchten, es zu schauen, wenn es innerhalb YYY:

cd XXX
mkdir tmp
git mv ZZZ tmp/ZZZ
git mv tmp ZZZ

XXX sieht wie folgt aus:

XXX
 |- ZZZ
     |- ZZZ

Nun benutzen Sie 'git pull' zu Holen, die änderungen über:

cd ../YYY
git pull ../XXX

Nun YYY sieht wie folgt aus:

YYY
 |- ZZZ
     |- ZZZ
 |- (other folders that already were in YYY)

InformationsquelleAutor der Antwort Aaron