Unisci due repository Git senza spezzare la cronologia dei file

Question

Ho bisogno di unire due repository Git in un repository nuovo di zecca, terzo. Ho trovato molte descrizioni su come eseguire questa operazione utilizzando un'unione di sottostrati (ad esempio Jakub Narębski's answer su How do you merge two Git repositories?) e seguendo queste istruzioni funziona per lo più, tranne che quando commetto l'unione di sottoalbero tutti i file dei vecchi archivi vengono registrati come nuovi aggiunti File. Riesco a vedere la cronologia dei commit dai vecchi repository quando faccio git log, ma se faccio git log <file> mostra solo un commit per quel file - l'unione di sottoalbero si unisce. A giudicare dai commenti sulla risposta di cui sopra, non sono il solo a vedere questo problema, ma non ho trovato soluzioni pubblicate per questo.

C'è un modo per unire i repository e lasciare intatta la cronologia dei singoli file?

Answer 1

Si scopre che la risposta è molto più semplice se si sta semplicemente cercando di incollare due repository insieme e far sembrare che fosse sempre così, piuttosto che gestire una dipendenza esterna. Devi semplicemente aggiungere telecomandi ai tuoi vecchi repository, unirli al tuo nuovo master, spostare i file e le cartelle in una sottodirectory, commettere il movimento e ripetere per tutti i repository aggiuntivi. Sottomoduli, fusioni di sottostrutture e abbellimenti fantasiosi hanno lo scopo di risolvere un problema leggermente diverso e non sono adatti a ciò che stavo cercando di fare.

Ecco uno script PowerShell esempio per incollare due repository insieme:

# Assume the current directory is where we want the new repository to be created 
# Create the new repository 
git init 

# Before we do a merge, we have to have an initial commit, so we'll make a dummy commit 
dir > deleteme.txt 
git add . 
git commit -m "Initial dummy commit" 

# Add a remote for and fetch the old repo 
git remote add -f old_a <OldA repo URL> 

# Merge the files from old_a/master into new/master 
git merge old_a/master --allow-unrelated-histories 

# Clean up our dummy file because we don't need it any more 
git rm .\deleteme.txt 
git commit -m "Clean up initial file" 

# Move the old_a repo files and folders into a subdirectory so they don't collide with the other repo coming later 
mkdir old_a 
dir -exclude old_a | %{git mv $_.Name old_a} 

# Commit the move 
git commit -m "Move old_a files into subdir" 

# Do the same thing for old_b 
git remote add -f old_b <OldB repo URL> 
git merge old_b/master --allow-unrelated-histories 
mkdir old_b 
dir –exclude old_a,old_b | %{git mv $_.Name old_b} 
git commit -m "Move old_b files into subdir" 

Ovviamente si potrebbe invece fondersi old_b in old_a (che diventa il nuovo repo combinato) se si preferisce farlo - modificare la script per soddisfare.

Se si desidera portare over in corso caratteristica rami così, utilizzare questo:

# Bring over a feature branch from one of the old repos 
git checkout -b feature-in-progress 
git merge -s recursive -Xsubtree=old_a old_a/feature-in-progress 

che è l'unica parte non evidente del processo - che non è una fusione sottostruttura, ma piuttosto un argomento di la normale unione ricorsiva che dice a Git che abbiamo ribattezzato il bersaglio e che aiuta Git a riorganizzare tutto correttamente.

Ho scritto una spiegazione leggermente più dettagliata here.

Answer 2

prega di dare un'occhiata a utilizzare

git rebase --root --preserve-merges --onto 

per collegare due storie nella fase iniziale della loro vita.

Se si dispone di percorsi che si sovrappongono, fissarli con

git filter-branch --index-filter 

quando si utilizza di registro, assicurarsi di "trovare copie di più" con

git log -CC 

in questo modo troverete i movimenti di file nel percorso.

Answer 3

Ecco un modo che non riscrive alcuna cronologia, quindi tutti gli ID di commit rimarranno validi. Il risultato finale è che i file del secondo repository finiranno in una sottodirectory.

1. aggiungere il secondo repo come un telecomando:

   cd firstgitrepo/ 
   git remote add secondrepo username@servername:andsoon 
   

2. Assicurarsi di aver scaricato tutti i commit del secondrepo:

   git fetch secondrepo 
   

3. Creare un ramo locale dal seconda succursale:

   git branch branchfromsecondrepo secondrepo/master 
   

4. Spostare tutti i suoi file in una sottodirectory:

   git checkout branchfromsecondrepo 
   mkdir subdir/ 
   git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} subdir/ 
   git commit -m "Moved files to subdir/" 
   

5. unire il secondo ramo in ramo master del primo pronti contro termine:

   git checkout master 
   git merge --allow-unrelated-histories branchfromsecondrepo 
   

Il repository avrà più di una radice commettere, ma questo non dovrebbe rappresentare un problema.

Answer 4

ho girato la solution da @Flimm questo in un git alias come questo (aggiunto alla mia ~/.gitconfig):

[alias] 
mergeRepo = "!mergeRepo() { \ 
    [ $# -ne 3 ] && echo \"Three parameters required, <remote URI> <new branch> <new dir>\" && exit 1; \ 
    git remote add newRepo $1; \ 
    git fetch newRepo; \ 
    git branch \"$2\" newRepo/master; \ 
    git checkout \"$2\"; \ 
    mkdir -vp \"${GIT_PREFIX}$3\"; \ 
    git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} \"${GIT_PREFIX}$3\"/; \ 
    git commit -m \"Moved files to '${GIT_PREFIX}$3'\"; \ 
    git checkout master; git merge --allow-unrelated-histories --no-edit -s recursive -X no-renames \"$2\"; \ 
    git branch -D \"$2\"; git remote remove newRepo; \ 
}; \ 
mergeRepo" 

Answer 5

Questa funzione clonare repo remoto in locale dir repo:

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" 
} 

Come utilizzare:

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

Utile!