Esiste un’opzione di git-merge –dry-run?

Mi sto unendo in un ramo remoto che potrebbe avere molti conflitti. Come posso sapere se avrà conflitti o no?

Non vedo nulla di simile a --dry-run su git-merge .

Come notato in precedenza, passa il flag --no-commit , ma per evitare un commit veloce, passa anche in --no-ff , in questo modo:

 $ git merge --no-commit --no-ff $BRANCH 

Per esaminare le modifiche graduali:

 $ git diff --cached 

E puoi annullare l’unione, anche se si tratta di un’operazione di unione rapida:

 $ git merge --abort 

Ho appena dovuto implementare un metodo che trova automaticamente i conflitti tra un repository e il suo remoto. Questa soluzione esegue l’unione in memoria in modo che non tocchi l’indice, né l’albero di lavoro. Penso che questo sia il modo più sicuro ansible per risolvere questo problema. Ecco come funziona:

  1. Scarica il telecomando nel tuo repository. Ad esempio: git fetch origin master
  2. Esegui git merge-base: git merge-base FETCH_HEAD master
  3. Esegui git merge-tree: git merge-tree mergebase master FETCH_HEAD ( mergebase è l’id esadecimale che merge-base stampato nel passaggio precedente)

Ora supponiamo di voler unire il master remoto con il tuo master locale, ma puoi usare qualsiasi ramo. git merge-tree eseguirà l’unione in memoria e stamperà il risultato sullo standard output. Grep per lo schema << o >> . Oppure puoi stampare l'output in un file e controllarlo. Se trovi una linea che inizia con 'cambiato in entrambi' allora molto probabilmente ci sarà un conflitto.

La mia soluzione semplice a forza bruta per questo è:

1: crea un ramo pre-master (dal master ovviamente)
2: unisci tutte le cose che vuoi fare a questo pre-master
allora puoi vedere come è avvenuta la fusione senza toccare il maestro allora.
3a: unire il pre-master in master o
3b: unisci tutti i rami rilasciati da wannabe in master

Ad ogni modo vorrei seguire @ orange80 consigliare.

Annullare un’unione con git è così semplice che non dovresti nemmeno preoccuparti della corsa a secco:

 $ git pull $REMOTE $BRANCH # uh oh, that wasn't right $ git reset --hard ORIG_HEAD # all is right with the world 

EDIT: Come notato nei commenti qui sotto, se hai delle modifiche nella tua directory di lavoro o nell’area di staging, probabilmente vorrai metterle da parte prima di fare quanto sopra (altrimenti scompariranno dopo il git reset sopra)

Ho fatto un alias per farlo e funziona come un fascino, lo faccio:

  git config --global alias.mergetest '!f(){ git merge --no-commit --no-ff "$1"; git merge --abort; echo "Merge aborted"; };f ' 

Ora chiamo

 git mergetest  

Per scoprire se ci sono conflitti.

Semplicemente diff il tuo ramo attuale contro il ramo remoto, questo ti dirà cosa cambierà quando fai un pull / unisci.

 #see diff between current master and remote branch git diff master origin/master 

Io uso il comando git request-pull per farlo. Permette di vedere ogni cambiamento che potrebbe accadere durante l’unione, ma senza fare nulla sui repository locali o remoti .

Ad esempio, immagina di voler unire un ramo chiamato “feature-x” nel tuo ramo principale

 git request-pull master origin feature-x 

ti mostrerà un riassunto di cosa sarebbe successo (senza fare nulla):

 The following changes since commit fc01dde318: Layout updates (2015-06-25 11:00:47 +0200) are available in the git repository at: http://fakeurl.com/myrepo.git/ feature-x for you to fetch changes up to 841d3b41ad: ---------------------------------------------------------------- john (2): Adding some layout Refactoring ioserver.js | 8 +++--- package.json | 7 +++++- server.js | 4 +-- layout/ldkdsd.js | 277 +++++++++++++++++++++++++++++++++++++ 4 files changed, 289 insertions(+), 7 deletions(-) create mode 100644 layout/ldkdsd.js 

Se aggiungi il parametro -p , otterrai anche il testo completo della patch, esattamente come se stessi facendo un git diff su ogni file modificato.

Sono sorpreso che nessuno abbia ancora suggerito di usare le patch.

your_branch di your_branch testare una fusione da your_branch in master (presumo che tu abbia estratto il master ):

 $ git diff master your_branch > your_branch.patch $ git apply --check your_branch.patch $ rm your_branch.patch 

Questo dovrebbe fare il trucco.

Se ricevi errori come

 error: patch failed: test.txt:1 error: test.txt: patch does not apply 

ciò significa che la patch non ha avuto successo e una fusione genera conflitti. Nessun output significa che la patch è pulita e potresti facilmente unire il ramo


Nota che questo non cambierà il tuo albero di lavoro (a parte la creazione del file di patch, ovviamente, ma puoi tranquillamente cancellarlo in seguito). Dalla documentazione di git-apply:

 --check Instead of applying the patch, see if the patch is applicable to the current working tree and/or the index file and detects errors. Turns off "apply". 

Nota a tutti coloro che sono più intelligenti / più esperti con Git di me: per favore fatemi sapere se ho torto qui e questo metodo mostra un comportamento diverso rispetto a un’unione regolare. Sembra strano che negli 8+ anni in cui questa domanda è esistita nessuno suggerirebbe questa soluzione apparentemente ovvia.

Questo potrebbe essere interessante: Dalla documentazione:

Se hai provato un’unione che ha provocato conflitti complessi e vuoi ricominciare da capo, puoi recuperare con git merge –abort .

Ma potresti anche farlo in modo ingenuo (ma lento):

 rm -Rf /tmp/repository cp -r repository /tmp/ cd /tmp/repository git merge ... ...if successful, do the real merge. :) 

(Nota: non funzionerà solo clonando in / tmp, avresti bisogno di una copia, per essere sicuro che le modifiche non vincolate non saranno in conflitto).

Sono consapevole che questa è una vecchia domanda, ma è la prima a comparire su una ricerca su Google.

Git ha introdotto un’opzione –ff-only durante l’unione.

Da: http://git-scm.com/docs/git-merge


–ff-only

Rifiuta di unire e uscire con uno stato diverso da zero a meno che l’HEAD corrente sia già aggiornato o l’unione possa essere risolta come un avanzamento rapido.

In questo modo si tenterà di unire e avanzare rapidamente e, se non è ansible, interromperà e ti chiederà che l’avanzamento veloce non può essere eseguito, ma lascia intatto il tuo ramo di lavoro. Se può avanzare velocemente, eseguirà l’unione sul ramo di lavoro. Questa opzione è disponibile anche su git pull . Quindi, puoi fare quanto segue:

 git pull --ff-only origin branchA #See if you can pull down and merge branchA git merge --ff-only branchA branchB #See if you can merge branchA into branchB 

Io uso git log per vedere cosa è cambiato su un ramo di funzionalità dal ramo principale

 git log does_this_branch..contain_this_branch_changes 

es. – per vedere quali commit si trovano in un branch feature che è stato / non è stato unito al master:

 git log master..feature_branch 

Se vuoi avanzare velocemente da B ad A, devi assicurarti che git log B..A non ti mostri nulla, cioè A non ha nulla che B non abbia. Ma anche se B..A ha qualcosa, potresti ancora essere in grado di unire senza conflitti, quindi quanto sopra mostra due cose: che ci sarà un avanzamento rapido, e quindi non otterrai un conflitto.

Crea una copia temporanea della tua copia di lavoro, quindi unisci a quella e diff i due.