tutorial - guida git pdf




ramo principale e 'origine/padrone' sono divergenti, come 'separare' i rami '? (7)

È possibile rivedere le differenze con un:

git log HEAD..origin/master

prima di tirarlo (recupera + unisci) (vedi anche "Come fai a prendere Git per tirare sempre da un ramo specifico?" )

Quando hai un messaggio come:

"Il tuo ramo e 'origine / padrone' sono divergenti, # e hanno 1 e 1 commit (s) ciascuno, rispettivamente."

, controlla se è necessario aggiornare l' origin . Se l' origin è aggiornata, alcuni commit sono stati trasferiti origin da un altro repository mentre si eseguivano i propri commit localmente.

... o ---- o ---- A ---- B  origin/master (upstream work)
                   \
                    C  master (your work)

Hai basato il commit C sul commit A perché quello era l'ultimo lavoro che avevi recuperato da upstream al momento.

Tuttavia, prima di provare a tornare all'origine, qualcun altro ha premuto commit B.
La storia dello sviluppo è divergita in percorsi separati.

È quindi possibile unire o rebase. Vedi Pro Git: Git Branching - Rebasing per i dettagli.

fondersi

Usa il comando git merge:

$ git merge origin/master

Questo dice a Git di integrare le modifiche da origin/master nel tuo lavoro e creare un commit di unione.
Il grafico della storia ora si presenta così:

... o ---- o ---- A ---- B  origin/master (upstream work)
                   \      \
                    C ---- M  master (your work)

La nuova unione, commit M, ha due genitori, ognuno dei quali rappresenta un percorso di sviluppo che ha portato al contenuto memorizzato in quel commit.

Nota che la storia di M è ora non lineare.

rebase

Usa il comando git rebase:

$ git rebase origin/master

Questo dice a Git di ripetere il commit C (il tuo lavoro) come se lo avessi basato su commit B anziché su A.
Gli utenti CVS e Subversion rebase regolarmente le loro modifiche locali sulla parte superiore del lavoro upstream quando aggiornano prima del commit.
Git aggiunge solo una separazione esplicita tra i passi commit e rebase.

Il grafico della storia ora si presenta così:

... o ---- o ---- A ---- B  origin/master (upstream work)
                          \
                           C'  master (your work)

Commit C 'è un nuovo commit creato dal comando git rebase.
È diverso da C in due modi:

  1. Ha una storia diversa: B invece di A.
  2. Il suo contenuto tiene conto delle modifiche sia in B che in C; è lo stesso di M dell'esempio di fusione.

Si noti che la cronologia di C 'è ancora lineare.
Abbiamo scelto (per ora) di consentire solo la cronologia lineare in cmake.org/cmake.git .
Questo approccio preserva il flusso di lavoro basato su CVS utilizzato in precedenza e può facilitare la transizione.
Un tentativo di spingere C 'nel nostro repository funzionerà (presumendo che tu abbia i permessi e nessuno abbia spinto mentre stavi ridiventando).

Il comando git pull fornisce un modo stenografico per recuperare dall'origine e rebase del lavoro locale su di esso:

$ git pull --rebase

Questo combina i passaggi di recupero e rebase sopra in un unico comando.

In qualche modo il mio master e il mio master / origine sono divergenti. In realtà non voglio che siano divergenti. Come posso visualizzare queste differenze e "unirle"?


Ho avuto lo stesso messaggio quando stavo provando a modificare l'ultimo messaggio di commit, di commit già premuto, usando: git commit --amend -m "New message" Quando ho spinto le modifiche usando git push --force-with-lease repo_name branch_name lì non c'erano problemi


Mi sono trovato in questa situazione quando ho provato a rebase un ramo che stava monitorando un ramo remoto, e stavo cercando di rebase su master. In questo scenario, se provi a rebase, molto probabilmente troverai il tuo ramo divergente e potresti creare un casino che non è per git nuvolees!

Diciamo che sei sul ramo my_remote_tracking_branch, che era derivato dal master

$ git status

# Sul ramo my_remote_tracking_branch

niente da commettere (directory di lavoro pulita)

E ora stai provando a rebase dal master come:

git rebase master

FERMATI ORA e risparmia qualche problema! Invece, usa l'unione come:

git merge master

Sì, finirai con altri commit sul tuo ramo. Ma a meno che non si vogliano rami "non divergenti", questo sarà un flusso di lavoro molto più fluido rispetto alla ridefinizione. Vedi questo blog per una spiegazione molto più dettagliata.

D'altra parte, se il tuo ramo è solo un ramo locale (cioè non ancora spinto a nessun telecomando) dovresti assolutamente fare un rebase (e il tuo ramo non divergerà in questo caso).

Ora se stai leggendo questo perché sei già in uno scenario "divergente" a causa di tale rebase, puoi tornare all'ultimo commit da origine (cioè in uno stato non divergente) usando:

git reset --hard origin / my_remote_tracking_branch


Nel mio caso ciò è stato causato dal non aver commesso la risoluzione del conflitto.

Il problema è stato causato dall'esecuzione del comando git pull . I cambiamenti all'origine hanno portato a conflitti con il mio repository locale, che ho risolto. Tuttavia, non li ho commessi. La soluzione a questo punto è di eseguire il commit delle modifiche ( git commit del file risolto)

Se hai anche modificato alcuni file dopo aver risolto il conflitto, il comando git status mostrerà le modifiche locali come modifiche locali non bloccate e la risoluzione di unione come modifiche locali a stadi. Questo può essere risolto correttamente commettendo le modifiche dall'unione prima con git commit , quindi aggiungendo e confermando le modifiche non previste come di consueto (es. Da git commit -a ).


Nel mio caso ho spinto le modifiche origin/master e poi ho realizzato che non avrei dovuto farlo :-( Questo è stato complicato dal fatto che i cambiamenti locali erano in una sottostruttura, quindi sono tornato all'ultimo commit valido prima del " cattive "modifiche locali (usando SourceTree) e poi ho ricevuto il" messaggio di divergenza ".

Dopo aver sistemato il mio pasticcio localmente (i dettagli non sono importanti qui) volevo "tornare indietro nel tempo" del ramo di origin/master remoto in modo che fosse di nuovo sincronizzato con il master locale. La soluzione nel mio caso era:

git push origin master -f

Nota l'interruttore -f (forza). Questo ha cancellato i "cattivi cambiamenti" che erano stati spinti origin/master per errore e ora i rami locali e remoti sono sincronizzati.

Tieni presente che si tratta di un'operazione potenzialmente distruttiva, quindi eseguila solo se sei sicuro al 100% che "lo spostamento" nel tempo del master remoto è OK.


Per visualizzare le differenze:

git difftool --dir-diff master origin/master

Questo mostrerà le modifiche o le differenze tra i due rami. In araxis (il mio preferito) lo visualizza in uno stile di cartella. Mostrando ognuno dei file modificati. Posso quindi fare clic su un file per vedere i dettagli delle modifiche nel file.


git pull --rebase origin/master 

è un singolo comando che può aiutarti la maggior parte del tempo.

Modifica: estrae i commit dall'origine / master e applica le modifiche alla cronologia di succursale appena estratta.





branch