L'unione di Git riporta "Già aggiornato" anche se c'è una differenza

Ho un repository git con 2 rami: master e test.

Esistono differenze tra rami master e rami di test.

Entrambe le filiali hanno tutti i cambiamenti impegnati.

Se lo faccio:

git checkout master

test git diff

Viene visualizzata una schermata piena di modifiche che mostra le differenze. Voglio unire le modifiche nel ramo di prova e quindi fare:

git merge test

Ma ricevi il messaggio "Già aggiornato"

Tuttavia, l'esame dei file in ciascun ramo diverso mostra chiaramente differenze.

Qual è il problema qui e come posso risolverlo?

Il messaggio "Già aggiornato" indica che tutte le modifiche dal ramo che stai tentando di unire sono già state unite al ramo in cui ti trovi attualmente. Più specificamente, significa che il ramo che stai cercando di unire è un genitore del ramo corrente . Congratulazioni, è la fusione più semplice che tu abbia mai fatto. :)

Usa gitkper dare un'occhiata al tuo repository. L'etichetta per il ramo "test" dovrebbe trovarsi da qualche parte sotto l'etichetta del ramo "master".

La tua filiale è aggiornata rispetto alla sua società madre. Secondo l'unione non ci sono nuove modifiche nel genitore dall'ultima unione. Ciò non significa che i rami siano gli stessi, perché puoi avere molti cambiamenti nel tuo ramo di lavoro e sembra che tu lo faccia.

Modifica il 10/12/2019:

Per Charles Drake nel commento a questa risposta, una soluzione per risolvere il problema è:

git checkout master
git reset --hard test

Questo lo riporta al livello di "test".

Quindi fa:

git push --force origin master

per forzare le modifiche al repository centrale.

Questo succede spesso a me quando so che ci sono cambiamenti sul master remoto, quindi provo a unirli usando git merge master. Tuttavia, ciò non si fonde con il master remoto, ma con il master locale.

Quindi, prima di fare l'unione, controlla il master e poi git pulllì. Quindi sarai in grado di unire le nuove modifiche nel tuo ramo.

Supponi di avere una filiale mastercon la seguente cronologia di commit:

A -- B -- C -- D

Ora, crei un test di diramazione, ci lavori e fai 4 commit:

                 E -- F -- G -- H
                /
A -- B -- C -- D

masterla testa punta a D e testla testa punta a H.

Il messaggio "Già aggiornato" viene visualizzato quando HEAD del ramo in cui si sta unendo è un genitore della catena di commit del ramo che si desidera unire. Ecco il caso, qui: Dè un genitore di E.

Non c'è niente da unione da testa master, dal momento che nulla è cambiato sul masterda allora. Quello che vuoi fare qui è letteralmente dire a Git di avere masterla testa per indicare H, quindi il ramo del maestro ha la seguente cronologia di commit:

A -- B -- C -- D -- E -- F -- G -- H

Questo è un lavoro per il comando Git reset. Vuoi anche che la directory di lavoro rifletta questa modifica, quindi eseguirai un hard reset:

git reset --hard H

Quello che funziona per me, diciamo che hai branch1 e vuoi unire in branch2.

Apri la riga di comando di git vai nella cartella principale di branch2 e digita:

git checkout branch1
git pull branch1
git checkout branch2
git merge branch1
git push

Se hai confidenza non devi fare git push, ma prima risolvi i conflitti e poi push.

Un'unione è sempre tra HEAD corrente e uno o più commit (di solito, branch head o tag)
e il file di indice deve corrispondere all'albero del commit HEAD (ovvero il contenuto dell'ultimo commit) quando inizia.
In altre parole, non git diff --cached HEADdeve segnalare alcuna modifica.

Il commit unito è già contenuto in HEAD. Questo è il caso più semplice, chiamato "Già aggiornato".

Ciò dovrebbe significare che i commit in test sono già uniti nel master, ma dal momento che altri commit vengono eseguiti nel master, git diff testdarebbe comunque alcune differenze.

Ciò accade perché la tua copia locale della filiale che desideri unire non è aggiornata. Ho il mio ramo, chiamato MyBranche voglio unirlo ProjectMaster.

_>git status
On branch MyBranch-Issue2
Your branch is up-to-date with 'origin/MyBranch-Issue2'.

nothing to commit, working tree clean

_>git merge ProjectMaster
Already up-to-date.

Ma so che ci sono cambiamenti che devono essere uniti!

Ecco la cosa, quando git merge ProjectMasterscrivo, git guarda la mia copia locale di questo ramo, che potrebbe non essere attuale . Per vedere se questo è il caso, desidero innanzitutto dire Git per controllare e vedere se i miei rami sono aggiornati a prenderlo eventuali modifiche, se così utilizzando, uh, fetch. Poi salto nel ramo che voglio unire per vedere cosa sta succedendo lì ...

_>git fetch origin

_>git checkout ProjectMaster
Switched to branch ProjectMaster
**Your branch is behind 'origin/ProjectMaster' by 85 commits, and can be fast-forwarded.**
  (use "git pull" to update your local branch)

Ah-ah! La mia copia locale è stantia di 85 commit, il che spiega tutto! Ora, Pullgiù le modifiche che mi mancano, quindi salto a MyBranche riprovo a unire.

_>git pull
Updating 669f825..5b49912
Fast-forward

_>git checkout MyBranch-Issue2
Switched to branch MyBranch-Issue2
Your branch is up-to-date with 'origin/MyBranch-Issue2'.

_>git merge ProjectMaster
Auto-merging Runbooks/File1.ps1
CONFLICT (content): Merge conflict in Runbooks/Runbooks/File1.ps1

Automatic merge failed; fix conflicts and then commit the result.

E ora ho un altro problema da risolvere ...

Questo mi è successo perché stranamente GIT pensava che il ramo locale fosse diverso dal ramo remoto. Questo era visibile nel grafico dei rami: mostrava due diversi rami: telecomandi / origine / nome_ramo e nome_ramo.

La soluzione era semplicemente rimuovere il repository locale e clonarlo nuovamente da remoto. In questo modo GIT capirebbe che telecomandi / origine / nome_del ramo> e nome_del ramo sono effettivamente gli stessi e potrei emettere il file git merge branch_name.

rm <my_repo>
git clone <my_repo>
cd <my_repo>
git checkout <branch_name>
git pull
git checkout master
git merge <branch_name>

git merge origin/masterinvece ha git merge masterfunzionato per me. Quindi per unire il master nel ramo delle funzionalità è possibile utilizzare:

git checkout feature_branch
git merge origin/master

Assicurati di verificare prima il ramo che desideri unire e quindi estrarlo (in modo che la versione locale corrisponda alla versione remota).

Quindi torna alla tua filiale su cui desideri eseguire l'unione e la tua unione git dovrebbe funzionare.

mi ha fatto piacere ed è stato inviato a questa pagina, non sono sicuro di avere lo stesso scenario, ma il mio è stato il mio tentativo di "ricongiungere" quel ramo "test".

Quindi in precedenza l'ho unito, ma ho intenzionalmente escluso alcuni cambiamenti specifici durante quell'unione, quindi ha chiaramente qualche differenza tra i rami. Stavo quindi cercando di ricollegarlo perché mi rendo conto / avrei dimenticato che avrei dovuto e voluto aggiungere un particolare cambiamento / file che avevo precedentemente escluso e speravo che se avessi fatto di nuovo una fusione avrei mostrato tutte le modifiche che avevo escluso prima , ma ho sbagliato e ricevo invece il messaggio "Già aggiornato".

Dopo aver letto il commento / risposta di @ Bombe, ha ragione, e penso che si comporti in questo modo, quindi quello che ho fatto è stato fare un backup dei file sul ramo di prova, quindi controllare il ramo principale e incollare manualmente i file in esso e impegnarsi come se fossero nuove modifiche.

non sono sicuro che questo sia il modo giusto o potrebbe aiutare gli altri ad avere lo stesso problema, ma ha fornito una soluzione al mio caso particolare.

Se l'unione del ramo A nel ramo B riporta "Già aggiornato", non è sempre vero il contrario. È vero solo se il ramo B è discendente del ramo A, altrimenti il ​​ramo B può semplicemente avere cambiamenti che non sono in A.

Esempio:

1. Si creano i rami A e B fuori dal master
2. Apportare alcune modifiche nel master e unirle solo nel ramo B (non aggiornando o dimenticando di aggiornare il ramo A).
3. Apportare alcune modifiche nel ramo A e unire A in B.

A questo punto la fusione da A a B riporta "Già aggiornato" ma i rami sono diversi perché il ramo B ha aggiornamenti dal master mentre il ramo A no.

Di fronte a questo scenario usando Git Bash.

Il nostro repository ha più rami e ogni ramo ha un ciclo di commit diverso e l'unione avviene di tanto in tanto. Old_Branch è stato utilizzato come genitore per New_Branch

Old_Branch è stato aggiornato con alcune modifiche che richiedevano la fusione con New_Branch

Stava usando il comando pull sottostante senza alcun ramo per ottenere tutte le fonti da tutti i rami.

git pull origin

Stranamente questo non toglie tutti i commit da tutti i rami. L'avevo pensato così come indicato mostra quasi tutti i rami e tag.

Quindi, per risolvere questo problema, abbiamo verificato che Old_Branch abbia utilizzato l'ultima versione

git checkout Old_Branch

git pull origin Old_Branch

Ora ho verificato New_Branch

git checkout New_Branch

Tirato per essere sicuro

git pull origin New_Branch

git merge Old_Branch

E la viola ha avuto conflitti da risolvere da Old_Branch a New_Branch :) che era previsto

Lo stesso è successo a me. Ma lo scenario era un po 'diverso, avevo un ramo principale e ne ho ricavato il rilascio_1 (diciamo). Ha apportato alcune modifiche al ramo release_1 e le ha unite in origine. poi ho fatto ssh e sul server remoto ho verificato nuovamente release_1 usando il comando git checkout -b release_1 - che in realtà ritaglia un nuovo ramo release_! dal master anziché estrarre il ramo esistente release_1 dall'origine. Risolto il problema rimuovendo l'interruttore "-b"

Ho avuto lo stesso problema. Ho apportato modifiche al telecomando e continuava a mostrare "Già aggiornato". Il ricondizionamento del repository ha risolto il problema per me.

Stupido ma potrebbe succedere. Supponiamo che il nome della tua filiale sia preceduto da un riferimento al problema (ad esempio #91-fix-html-markup), se esegui questa unione:

$ git merge #91-fix-html-markup

non funzionerà come previsto perché tutto ciò che #segue viene ignorato, poiché #avvia un commento incorporato.

In questo caso è possibile rinominare l'omettendo ramo #o utilizzare le virgolette singole per circondare il nome del ramo: git merge '#91-fix-html-markup'.