spostare le modifiche impegnate (ma non spinte) in un nuovo ramo dopo il pull

Ho fatto un bel po 'di lavoro ("Il tuo ramo è davanti a' origine / padrone 'di 37 commit") che avrebbe dovuto andare nel suo ramo piuttosto che in master. Questi commit esistono solo sulla mia macchina locale e non sono stati spinti a origin, ma la situazione è alquanto complicata in quanto altri sviluppatori hanno spinto verso origin/mastere ho apportato quei cambiamenti.

Come posso spostare retroattivamente i miei 37 commit locali in una nuova filiale? Sulla base dei documenti, sembra che dovrebbe git rebase --onto my-new-branch mastero ...origin/masterdebba farlo, ma entrambi mi danno solo l'errore "fatale: necessaria una sola revisione". man git-rebasenon dice nulla sulla fornitura di una revisione rebasee i suoi esempi non lo fanno, quindi non ho idea di come risolvere questo errore.

(Si noti che questo non è un duplicato di Sposta lavoro esistente e non sottoposto a commit in un nuovo ramo in Git o Come unire le mie modifiche locali senza commit in un altro ramo Git? Poiché tali domande riguardano le modifiche non confermate nell'albero di lavoro locale, non le modifiche che hanno stato commesso localmente.)

Questo dovrebbe andare bene, dal momento che non hai ancora trasferito i tuoi impegni da nessun'altra parte e sei libero di riscrivere la storia della tua filiale dopo origin/master. Prima di tutto vorrei eseguire un git fetch originper assicurarsi che origin/mastersia aggiornato. Supponendo che tu sia attualmente attivo master, dovresti essere in grado di fare:

git rebase origin/master

... che riprodurre tutti i commit che non sono in origin/mastersu origin/master. L'azione predefinita di rebase è ignorare i commit di merge (ad esempio quelli che git pullprobabilmente sono stati introdotti) e proverà semplicemente ad applicare la patch introdotta da ciascuno dei tuoi commit origin/master. (Potrebbe essere necessario risolvere alcuni conflitti lungo il percorso.) Quindi è possibile creare il nuovo ramo in base al risultato:

git branch new-work

... e poi resetta le masterspalle a origin/master:

# Use with care - make sure "git status" is clean and you're still on master:
git reset --hard origin/master

Quando faccio questo tipo di manipolazione di rami con git branch, git resetecc. Trovo utile guardare frequentemente il grafico di commit con gitk --allo uno strumento simile, solo per verificare che capisca dove puntano tutti i diversi ref.

In alternativa, potresti aver appena creato un ramo di argomento in base a dove si trova il tuo master in primo luogo ( git branch new-work-including-merges) e quindi ripristinare mastercome sopra. Tuttavia, dal momento che la sezione del tuo argomento includerà le fusioni origin/mastere che non hai ancora apportato le modifiche, ti suggerirei di fare un rebase in modo che la cronologia sia più ordinata. (Inoltre, quando alla fine unirai il ramo del tuo argomento al master, le modifiche saranno più evidenti.)

Se hai un numero basso di commit e non ti importa se questi sono combinati in un mega-commit, questo funziona bene e non è spaventoso come fare git rebase:

decomprimere i file (sostituire 1 con # di commit)

git reset --soft HEAD~1

creare una nuova filiale

git checkout -b NewBranchName

aggiungi le modifiche

git add -A

impegnarsi

git commit -m "Whatever"

Ho bloccato con lo stesso problema. Ho trovato la soluzione più semplice che mi piace condividere.

1) Crea una nuova filiale con le tue modifiche.

git checkout -b mybranch

2) (Opzionale) Inserire il nuovo codice di filiale sul server remoto.

git push origin mybranch

3) Torna alla sezione principale.

git checkout master

4) Ripristinare il codice filiale principale con il server remoto e rimuovere il commit locale.

git reset --hard origin/master

Un altro modo per assumere branch1 - è branch con modifiche commesse branch2 - è branch desiderabile

git fetch && git checkout branch1
git log

seleziona gli ID di commit che devi spostare

git fetch && git checkout branch2
git cherry-pick commit_id_first..commit_id_last
git push

Ora ripristina i commit non compressi dal ramo iniziale

git fetch && git checkout branch1
git reset --soft HEAD~1

In alternativa, subito dopo aver eseguito il commit nel ramo sbagliato, attenersi alla seguente procedura:

1. git log
2. git diff {previous to last commit} {latest commit} > your_changes.patch
3. git reset --hard origin/{your current branch}
4. git checkout -b {new branch}
5. git apply your_changes.patch

Posso immaginare che esiste un approccio più semplice per i passaggi uno e due.

Che dire:

1. Diramazione dall'attuale TESTA.
2. Assicurati di essere padrone , non il tuo nuovo ramo.
3. git reset tornare all'ultimo commit prima di iniziare a apportare modifiche.
4. git pull per ritirare solo le modifiche remote che hai eliminato con il ripristino.

O esploderà quando proverai a ricongiungere il ramo?

Ecco un modo molto più semplice:

1. Crea una nuova filiale

2. Nel tuo nuovo ramo fai un git merge master- questo unirà le tue modifiche impegnate (non spinte) al tuo nuovo ramo

3. Elimina il ramo principale locale git branch -D masterUtilizzare -Dinvece di -dperché si desidera forzare l'eliminazione del ramo.

4. Basta fare un git fetchramo principale e fare un git pullramo principale per assicurarsi di disporre del codice più recente per i team.

Un approccio più semplice, che ho usato (supponendo che tu voglia spostare 4 commit):

git format-patch HEAD~4

(Cerca nella directory da cui hai eseguito l'ultimo comando per i 4 .patchfile)

git reset HEAD~4 --hard

git checkout -b tmp/my-new-branch

Poi:

git apply /path/to/patch.patch

Nell'ordine che volevi.

1. Acquista una nuova copia delle tue fonti

   git clone ........

2. Crea ramo dalla posizione desiderata

   git checkout {position} git checkout -b {branch-name}

3. Aggiungi repository remoto

   git remote add shared ../{original sources location}.git

4. Ottieni fonti remote

   git fetch shared

5. Acquista la filiale desiderata

   git checkout {branch-name}

6. Unisci fonti

   git merge shared/{original branch from shared repository}

Per me questo è stato il modo migliore:

1. Controlla le modifiche e unisci i conflitti git fetch
2. Crea un nuovo ramo git branch my-changese passa al telecomando
3. Passa a monte al nuovo ramo creato git master -u upstream-branch remotes/origin/my-changes
4. Spingi i tuoi commit nella nuova filiale a monte.
5. Torna al precedente upstream git branch master --set-upstream-to remotes/origin/master