Mesclar dois repositórios Git sem quebrar o histórico do arquivo

Eu preciso mesclar dois repositórios Git em um novo repositório, terceiro. Eu encontrei muitas descrições de como fazer isso usando uma mesclagem de subárvore (por exemplo, a resposta de Jakub Narębski em Como você mescla dois repositórios Git? ) E seguir essas instruções geralmente funciona, exceto que, quando eu submeto a subárvore, mesclamos todos os arquivos dos repositórios antigos são registrados como novos arquivos adicionados. Eu posso ver o histórico de confirmação dos repositórios antigos quando o faço git log, mas se o fizer git log <file>, mostrará apenas uma confirmação para esse arquivo - a mesclagem da subárvore. A julgar pelos comentários na resposta acima, não estou sozinho vendo esse problema, mas não encontrei soluções publicadas para ele.

Existe alguma maneira de mesclar repositórios e deixar intacto o histórico de arquivos individuais?

Acontece que a resposta é muito mais simples se você estiver simplesmente tentando colar dois repositórios e parecer que era assim o tempo todo, em vez de gerenciar uma dependência externa. Você só precisa adicionar controles remotos aos seus repositórios antigos, mesclá-los ao seu novo mestre, mover os arquivos e pastas para um subdiretório, confirmar a movimentação e repetir para todos os repositórios adicionais. Sub-módulos, mesclagens de sub-árvores e rebotes sofisticados destinam-se a resolver um problema ligeiramente diferente e não são adequados para o que eu estava tentando fazer.

Aqui está um exemplo de script do Powershell para colar dois repositórios:

# 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
git commit --allow-empty -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

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

Obviamente, você pode mesclar old_b em old_a (que se torna o novo repositório combinado) se preferir fazer isso - modifique o script para se adequar.

Se você deseja trazer ramificações de recursos em andamento também, use o seguinte:

# 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

Essa é a única parte não óbvia do processo - não é uma mesclagem de subárvore, mas um argumento para a mesclagem recursiva normal que informa ao Git que renomeamos o alvo e ajuda o Git a alinhar tudo corretamente.

Eu escrevi uma explicação um pouco mais detalhada aqui .

Aqui está uma maneira de não reescrever nenhum histórico, para que todos os IDs de confirmação permaneçam válidos. O resultado final é que os arquivos do segundo repositório acabarão em um subdiretório.

1. Adicione o segundo repositório como um controle remoto:

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

2. Verifique se você baixou todos os commits do secondrepo:

   git fetch secondrepo
   

3. Crie uma ramificação local a partir da ramificação do segundo repositório:

   git branch branchfromsecondrepo secondrepo/master
   

4. Mova todos os seus arquivos para um subdiretório:

   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. Mesclar a segunda ramificação na ramificação principal do primeiro repositório:

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

Seu repositório terá mais de uma confirmação raiz, mas isso não deve representar um problema.

Alguns anos se passaram e há soluções bem votadas bem fundamentadas, mas quero compartilhar as minhas porque era um pouco diferente, porque eu queria mesclar 2 repositórios remotos em um novo, sem excluir o histórico dos repositórios anteriores.

1. Crie um novo repositório no Github.

   

2. Faça o download do repositório recém-criado e adicione o repositório remoto antigo.

   git clone https://github.com/alexbr9007/Test.git
   cd Test
   git remote add OldRepo https://github.com/alexbr9007/Django-React.git
   git remote -v
   

3. Busque todos os arquivos do repositório antigo para que uma nova ramificação seja criada.

   git fetch OldRepo
   git branch -a
   

   

4. Na ramificação mestre, faça uma mesclagem para combinar o repositório antigo com o recém-criado.

   git merge remotes/OldRepo/master --allow-unrelated-histories
   

   

5. Crie uma nova pasta para armazenar todo o novo conteúdo criado que foi adicionado no OldRepo e mover seus arquivos para essa nova pasta.

6. Por fim, você pode fazer o upload dos arquivos dos repositórios combinados e excluir com segurança o OldRepo do GitHub.

Espero que isso possa ser útil para quem lida com a fusão de repositórios remotos.

por favor, dê uma olhada no uso

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

para ligar duas histórias no início de suas vidas.

Se você tiver caminhos sobrepostos, corrija-os com

git filter-branch --index-filter

ao usar o log, verifique se "encontra cópias mais difíceis" com

git log -CC

Dessa forma, você encontrará movimentos de arquivos no caminho.

Eu transformei a solução do @Flimm em um git aliasassim (adicionado ao meu ~/.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"

Esta função clonará o repositório remoto no diretório de repositório local:

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

Como usar:

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

Aviso prévio. Esse script pode reescrever confirmações, mas salvará todos os autores e datas, significa que novas confirmações terão outros hashes, e se você tentar enviar alterações para o servidor remoto, ele poderá ser capaz apenas com a força de chave, e também reescreverá confirmações no servidor. Portanto, faça backups antes do lançamento.

Lucro!

Siga as etapas para incorporar um repositório em outro repositório, tendo um único histórico git mesclando os dois históricos git.

1. Clone os dois repositórios que você deseja mesclar.

git clone [email protected]: usuário / pai-repo.git

git clone [email protected]: user / child-repo.git

2. Ir para o repo filho

cd repositório-filho /

3. execute o comando abaixo, substitua o caminho my/new/subdir(3 ocorrências) pela estrutura de diretórios na qual você deseja que o repo filho seja executado.

git filter-branch --une-empty - --tree-filter 'se [! -e meu / novo / subdir]; então mkdir -p my / new / subdir git ls-tree --name-only $ GIT_COMMIT | xargs -I arquivos mv arquivos my / new / subdir fi '

4. Ir para o repo pai

cd ../parent-repo/

5. Adicionar um controle remoto ao repositório pai, apontando o caminho para o repositório filho

git remote add child-remote ../child-repo/

6. Buscar o repositório filho

git fetch child-remote

7. Mesclar as histórias

git merge --allow-unrelated-historories filho-remoto / mestre

Se você verificar o log do git no repositório pai agora, ele deverá fazer com que o repositório filho confirme a fusão. Você também pode ver a tag indicando na fonte de confirmação.

O artigo abaixo me ajudou a incorporar um repositório em outro repositório, tendo um único histórico do git ao mesclar os dois.

http://ericlathrop.com/2014/01/combining-git-repositories/

Espero que isto ajude. Feliz codificação!

Digamos que você deseja mesclar repositório apara b(eu estou supondo que eles estão localizados ao lado do outro):

cd b
git remote add a ../a
git fetch a
git merge --allow-unrelated-histories a/master
git remote remove a

Caso queira colocar aem um subdiretório, faça o seguinte antes dos comandos acima:

cd a
git filter-repo --to-subdirectory-filter a
cd ..

Para isso, você precisa git-filter-repoinstalar ( filter-branché desencorajado ).

Um exemplo de mesclagem de 2 grandes repositórios, colocando um deles em um subdiretório: https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

Mais sobre isso aqui .