Come faccio a re-play miei commit di un repository Git locale, in cima ad un progetto che ho biforcato su github.com?

StackOverflow https://stackoverflow.com/questions/1457248

  •  12-09-2019
  •  | 
  •  

Domanda

Sì, lo so che avrei dovuto solo biforcuta il progetto fin dall'inizio, ma questo è ciò che situazione mi trovo in ora. :)

Ho un repository Git locale che contiene il mio blog, sul mio computer locale, che dispone di diversi mesi di commettere storia. In origine, ho semplicemente scaricato i file dal repository http://github.com/mojombo/mojombo.github.com , e io proseguito con la mia repository Git locale, con il primo commit guardando come i più recenti file dal repository di mojombo.

Ora vorrei sborsare il progetto e avere il mio repository Git locale impegna i essere riprodotti su di esso, così sembra che io biforcato il progetto fin dall'inizio, e poi spinto di nuovo a mia versione biforcuta della repository di mojombo, sul mio conto GitHub:

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

Quindi, forse la storia sarebbe quindi simile a questa: 

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

Quali comandi Git posso usare esattamente per fare questo?

Ho guardato questa domanda . Dovrò aggiungere repository di mojombo come un telecomando per il mio progetto, e poi tirare in, unire, risolvere i conflitti, e quindi spingere al mio progetto biforcuta su GitHub?

È stato utile?

Soluzione 2

Quando ho provato git pull mi ha dato il seguente errore: 

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

Nel mio caso particolare, sembrava che git rebase era la strada da percorrere per me, come dimostrano i passi qui: 

#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

Altri suggerimenti

In breve:

Una soluzione è quella di utilizzare innesti per collegare storia, quindi utilizzare git filter-branch per riscrivere la storia secondo tali innesti, quindi opzionalmente fare un merge .

Si noti che la soluzione di riprodurre le modifiche (i vostri impegna) sulla parte superiore del nuovo sviluppo nella repository originale ( rebase la soluzione) è un'altra soluzione praticabile.

versione più lunga:

Supponiamo che si sia ricordi, o si può trovare esaminando fonte e / o utilizzando i comandi git la revisione del repository è stato scaricato un'istantanea di, e ha iniziato lo sviluppo locale. Chiamiamo questo inizio di revisione o A.

Supponiamo che la storia locale disconnesso è nel clone di repository originale. Ciò significa che il vostro sviluppo scollegato locale è nello stesso repository come storia completa di un progetto. Supponiamo che voi filiali locali sono nel ramo 'master' (e per semplicità che v'è un solo ramo).

Se avete fatto del progetto non inverosimile nel repository con il vostro lavoro scollegato locale, è possibile farlo con: 

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

La storia si presenta ora come il seguente: 

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

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

L'A commettere chiamato nel diagramma sopra è l'inizio commit di acquistare snapshot e ha iniziato il vostro sviluppo locale off.

Ci sono due possibilità:. Hai ha commesso un'istantanea di 'A' come un primo commit 'x', o il primo impegno che hai fatto è stato con le modifiche locali

Nel primo caso (hai commesso stato di partenza originale, per esempio come 'Initial commit' o 'Importa') si vorrebbe la storia collegata alla aspetto: 

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

vale a dire. il primo originale commettere 'y' per avere 'A' come un genitore.

Nel secondo caso (si è già impegnati con i vostri cambiamenti) si vorrebbe la storia collegata a guardare come questo, invece: 

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

vale a dire. si desidera primo commit 'x' per avere 'A" come un genitore.

In entrambi i casi si desidera trovare piena SHA-1 identificatore di commettere 'A', e pieno SHA-1 identificatori di 'x' commit e 'y'.

Si possono trovare SHA-1 di commettere 'A' (supponendo che non si conosce già) con git rev-parse : 

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

(il '^ {commettere}' il suffisso potrebbe essere necessario fare in modo che hai trovato commit SHA-1, che è importante se, ad esempio sa 'A" per la sua etichetta, ad esempio' v0.99' ;. nel tuo caso non è necessario, come il repository in questione non utilizzare i tag)

Si possono trovare SHA-1 di commit 'x' e 'y' utilizzando git rev-list (supponendo che lo sviluppo è stato fatto sul ramo 'master'): 

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

(il "| tail -2" è qui per trovare ultimi due commit nella lista generata; non è necessario usarlo se non ce l'hai).

Nota: in tutti gli esempi di cui sopra pieno SHA-1 sono esempi , e non dovrebbe essere usato come è

Diamo un nome il commit che si desidera avere 'A"(o 'START') come un padre come il primo (che sarebbe stato 'x' o 'y', a seconda che si caso, come indicato sopra). Ora noi utilizzare innesti meccanismo per collegare la storia: 

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

Poi si dovrebbe verificare se la società è collegata correttamente (unito) la storia, utilizzando browser grafico storia così come gitk, o qgit, o GitX è che sono su MacOS X, o anche "git log --graph", o "git show-branch", ad esempio: 

$ gitk master origin/master    # or --all

(dove gitk è qui solo come esempio, se si utilizza "git show branch" non sempre possibile utilizzare l'opzione '--all').

Infine ci sarebbe probabilmente vuole fare quelle modifiches permanente, quindi chiunque volesse prendere dal nostro repository sarebbe anche collegato la storia. Possiamo farlo utilizzando git filtro- ramo : 

$ git filter-branch master

Si dovrebbe storia originale (disconnesso) nella 'refs / originale / master'.

file Ora è possibile rimuovere innesti: 

$ rm .git/info/grafts

Ora si sarebbe in grado di fondere in nuovo sviluppo per repository originale: 

$ git merge origin/master

Impostazione di configurazione per-ramo, in modo che sarebbe stato sufficiente per fare semplicemente "git pull" quando sul ramo 'master' per tirare (unione) cambiamenti di origine (al) repository è lasciata come esercizio per il lettore .. .: -)

Nota: rebase soluzione comporterebbe la seguente storia (supponendo che abbiamo caso in cui prima Comit era semplice importazione): 

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

(dove i mezzi y' che commettono y stata modificata: dovrebbe essere circa lo stesso changeset, ma è differente come commit).

Ecco un pensiero su cosa si potrebbe fare. È un po 'l'opposto dall'idea ha ricapitolato in fondo alla tua domanda.

  1. repo di mojombo Fork in GitHub.
  2. Clonare la vostra copia biforcuta.
  3. Unisci nelle modifiche dal repository esistente (originale).
  4. Elimina il repository originale (se lo si desidera, ma non si ha realmente bisogno più).

Quindi, in pratica, dopo che si biforcano su GitHub, è possibile utilizzare la seguente sequenza di comandi: 

$ 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

In sintesi, questo metodo si fonderanno in tutte le modifiche apportate nel repository più anziani (preservando in tal modo la vostra storia di sviluppo), ma anche di tirare nella storia di mojombo, e che consente di tenere il passo con i cambiamenti di mojombo / contribuire facilmente le modifiche di nuovo al suo repo, se applicabile.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top