Como faço para re-jogar meus commits de um repositório local Git, em cima de um projeto que eu bifurcada em github.com?

Question

Sim, eu sei que eu deveria ter apenas bifurcada o projeto desde o início, mas isso é o que situação em que estou agora. :)

Eu tenho um repositório local Git que contém o meu blog, no meu computador local, que tem vários meses de cometer história. Originalmente, eu simplesmente baixou os arquivos do repositório http://github.com/mojombo/mojombo.github.com , e eu continuou com o meu repositório local Git, com o primeiro cometer parecendo os últimos arquivos de repositório de mojombo.

Eu gostaria agora de fork do projeto e ter meus Git commits repositório local ser repetido em cima dela, então parece que eu bifurcada o projeto desde o início, e depois empurrou-o de volta para a minha versão bifurcada de repositório de mojombo, na minha conta GitHub:

http://github.com/program247365/mojombo.github.com

Por isso, talvez a história seria então semelhante a este:

mobjombo repository:         1---2---3----23
                                  \
my blog repository commits:       24---25---

comandos O Git posso usar exatamente fazer isso?

Eu olhei esta questão . Vou ter que adicionar o repositório do mojombo como um controle remoto para o meu projeto, e puxe-o em, merge, resolver conflitos, e depois empurrar para o meu projeto bifurcada no GitHub?

Answer 1

Quando eu tentei git pull ele me deu o seguinte erro:

$ git pull grid master:master
! [rejected]        master     -> master  (non fast forward)

No meu caso particular, parecia que git rebase era o caminho a percorrer para mim, como mostram os passos aqui:

#Clone my forked project from github
git clone git@github.com:program247365/mojombo.github.com.git 

#Add my repo as a remote repo, with the alias 'grid'
git remote add grid "path/to/remote/gitrep/with/all/history/unrelated/to/mojombo/" 

#Rebase my commits on top of mojombo's
git rebase master grid/master

#Switch to the local master branch 
git checkout master

#Call up my mergetool via git, to start rectifying the conflicts that emerge between my repo, and mojombo's
git mergetool

#Push my rebased/combined repo back to Github.com
git push github

Answer 2

Em resumo:

Uma solução é usar enxertos a história de conexão, em seguida, usar git filter-branch de reescrever a história de acordo com esses enxertos, em seguida, opcionalmente, fazer um merge .

Note que a solução para reproduzir as suas alterações (seus commits) em cima de um novo desenvolvimento no repositório original (o rebase solução) é outra solução viável.

---

versão mais longa:

Vamos supor que você quer se lembrar, ou você pode encontrar examinando fonte e / ou usar git comanda a revisão do repositório que você baixou instantâneo, eo desenvolvimento local começou. Vamos chamar essa revisão START ou A.

Vamos supor que você história desconectado local é no clone do repositório original. Isso significa que o seu desenvolvimento desconectado local é no mesmo repositório como histórico completo de um projeto. Vamos supor que você filiais locais estão no ramo 'mestre' (e por simplicidade que há apenas um ramo).

Se você fez projeto não buscada em repositório com o seu trabalho desconectado local, você pode fazer isso com:

$ git remote add origin git://github.com/mojombo/mojombo.github.com.git
$ git fetch origin

A história parece agora como o seguinte:

*---*---*---*---*---A---*---*---*---*      <--- origin/master (remote-tracking branch)

                                     x---y---*---*---*      <--- master (your local disconnected history)

A Um cometer nomeado no diagrama acima é o início entrego baixado como snapshot e começou o seu desenvolvimento local off.

Existem duas possibilidades: você comitted instantâneo de 'A' como cometer um inicial 'x', ou o primeiro cometer você fez foi com as suas modificações locais

.

No primeiro caso (você cometeu Estado de partida original, por exemplo, como 'Initial cometer' ou 'Import') que você iria querer a história ligada a esta aparência:

*---*---*---*---*---A---*---*---*---*      <--- origin/master (remote-tracking branch)
                                      \
                                        \-y---*---*---*       <--- master (your local disconnected history)

i. o primeiro original cometer 'y' ter 'A' como um pai.

No segundo caso (você cometeu com as suas alterações) que você iria querer a história conectado a olhar como este em vez disso:

*---*---*---*---*---A---*---*---*---*           <--- origin/master (remote-tracking branch)
                                      \
                                        \-x---y---*---*---*      <--- master (your local disconnected history)

i. você quer primeiro cometer 'x' ter 'A" como um pai.

Em ambos os casos você quiser encontrar completo SHA-1 identificador de cometer 'A', e cheio SHA-1 identificadores de commits 'x' e 'y'.

Você pode encontrar SHA-1 de cometer 'A' (assumindo que você não sabe já) com git rev-parse :

$ git rev-parse A     # or A^{commit}
437b1b20df4b356c9342dac8d38849f24ef44f27

(o '^ {cometer}' sufixo pode ser necessária para se certificar de que você encontrou commit SHA-1, o que é importante se você, por exemplo, saber 'A" pela sua tag, por exemplo' v0.99' .; no seu caso, não é necessário, como o repositório em questão não usar tags)

Você pode encontrar SHA-1 de commits 'x' e 'y' usando git-list rev (supondo que você desenvolvimento foi feito no ramo 'master'):

$ git rev-list --topo-order master | tail -2
8bc9a0c769ac1df7820f2dbf8f7b7d64835e3c68
e83c5163316f89bfbde7d9ab23ca2e25604af290

. (A "| tail -2" está aqui para encontrar últimos dois commits na lista gerada; você não precisa usá-lo se você não tiver)

Nota: em todos os exemplos acima completo SHA-1 são exemplos , e não deve ser usada como é

Vamos nome comprometer que pretende ter 'A"(ou 'START') como um pai como FIRST (que seria 'x' ou 'y', dependendo de seu caso, como dito acima). Agora nós uso enxertos mecanismo a história de conexão:

$ echo "<SHA-1 of FIRST> <SHA-1 of START>" > .git/info/grafts

Em seguida, você deve verificar se você já conectou corretamente história (se juntou a), usando navegador história gráfica como gitk, ou QGit, ou gitx é que você está no MacOS X, ou mesmo "git log --graph", ou "git show-branch", por exemplo:

$ gitk master origin/master    # or --all

(onde gitk é aqui apenas como um exemplo, se você usar "git show branch" você nem sempre pode usar '--all' opção).

Finalmente, nós provavelmente quer fazer aqueles mudançaé permanente, portanto, qualquer pessoa que iria buscar do nosso repositório também teria história conectado. Podemos fazer isso usando git filter- ramo :

$ git filter-branch master

Você teria a história original (desconectado) em 'refs / / original master'.

Agora você pode remover arquivo de enxertos:

$ rm .git/info/grafts

Agora você seria capaz de mesclar no novo desenvolvimento para repositório original:

$ git merge origin/master

definição de configuração-se por ramo, de modo que seria suficiente para fazer simplesmente "git pull", quando no ramo 'master' para puxar (merge) muda de origem (al) repositório é deixada como exercício para o leitor .. .: -)

---

Nota: solução rebase resultaria na seguinte história (assumindo que temos caso em primeira comit foi de importação simples):

*---*---*---*---*---A---*---*---*---*                                      <--- origin/master (remote-tracking branch)
                                                                     \
                                                                       \-y'---*'---*'---*'      <--- master (your local disconnected history)

(onde os meios y' que comprometem y foi modificado: deve ser aproximadamente a mesma de alterações, mas é diferente como uma confirmação).

Answer 3

Aqui está um pensamento sobre o que você poderia fazer. É uma espécie do oposto da idéia de você resumidos na parte inferior da sua pergunta.

1. repo do Fork mojombo no GitHub.
2. Clone sua cópia bifurcada.
3. Merge em suas alterações de seu repositório existente (original).
4. Excluir seu repositório original (se desejar, mas você realmente não é mais necessário).

Então, basicamente, após a bifurcação no GitHub, você pode usar a seguinte seqüência de comandos:

$ git clone git://github.com/$YOUR_USERNAME/$YOUR_PROJECT.git  # Clone your GitHub fork (#2 from above)
$ git pull /path/to/your/original/repo master:master           # Clone your original repo's master branch into your new repo (cloned from GitHub)
$ rm -rf /path/to/your/original/repo                           # Might as well delete the original -- you don't need it anymore, since all your history is in your new repo

Em resumo, este método irá fundir em todas as mudanças que você fez no repo mais velhos (preservando assim o seu desenvolvimento histórico), ao mesmo tempo, puxando na história da mojombo, e que lhe permite manter-se com as mudanças de mojombo / facilmente contribuir alterações de volta para o seu repo, se for o caso.