I seguenti file dell'albero di lavoro non tracciati verrebbero sovrascritti dall'unione, ma non mi interessa

Sul mio ramo avevo alcuni file in .gitignore

Su un ramo diverso questi file non lo sono.

Voglio unire il diverso ramo nel mio e non mi interessa se quei file non vengono più ignorati o meno.

Purtroppo ottengo questo:

I seguenti file dell'albero di lavoro non tracciati verrebbero sovrascritti dall'unione

Come potrei modificare il mio comando pull per sovrascrivere quei file, senza che io debba trovare, spostare o eliminare quei file da solo?

Il problema è che non stai monitorando i file localmente ma i file identici vengono tracciati da remoto, quindi per "tirare" il tuo sistema sarebbe costretto a sovrascrivere i file locali che non sono controllati dalla versione.

Prova a correre

git add * 
git stash
git pull

Ciò terrà traccia di tutti i file, rimuoverà tutte le modifiche locali a tali file e quindi otterrà i file dal server.

Puoi provare a cancellare i file non tracciati dal comando locale

Git 2.11 e versioni più recenti:

git clean  -d  -f .

Versioni precedenti di Git:

git clean  -d  -f ""

Dove -dpuò essere sostituito con il seguente:

• -x vengono rimossi anche i file ignorati e i file sconosciuti a Git.

• -d rimuovere le directory non tracciate oltre ai file non tracciati.

• -f è necessario per forzare l'esecuzione.

Ecco il link che può anche essere utile.

Gli unici comandi che hanno funzionato per me sono stati:

git fetch --all
git reset --hard origin/{{your branch name}}

Una sostituzione per git mergequesto sovrascriverà i file non tracciati

I commenti qui sotto usano 'FOI' per i 'file di interesse', i file che

• esiste nel ramo donatore,
• non esistono nel ramo ricevente,
• e stanno bloccando l'unione perché sono presenti e non tracciati nella directory di lavoro.

git checkout -f donor-branch   # replace FOI with tracked `donor` versions
git checkout receiving-branch  # FOI are not in `receiving`, so they disapppear
git merge donor-branch  # now the merge works

Una sostituzione per git pullquesto sovrascriverà i file non tracciati

pull = fetch + merge, quindi seguiamo git fetchil git checkout -f, git checkout, git mergetrucco sopra.

git fetch origin  # fetch remote commits
git checkout -f origin/mybranch  # replace FOI with tracked upstream versions
git checkout mybranch  # FOI are not in mybranch, so they disapppear
git merge origin/mybranch  # Now the merge works. fetch + merge completes the pull.

Spiegazione dettagliata

git merge -fnon esiste, ma git checkout -fesiste.

Utilizzeremo git checkout -f+ git checkoutper rimuovere i file di interesse (vedi sopra), quindi la tua unione può procedere normalmente.

Passaggio 1. Questo passaggio sostituisce forzatamente FOI non monitorato con versioni tracciate del ramo donatore (verifica anche il ramo donatore e aggiorna il resto della directory di lavoro).

git checkout -f donor-branch

Passaggio 2. Questo passaggio rimuove i FOI perché vengono tracciati nel nostro ramo (donatore) corrente e assenti nel receiving-branchpassaggio a.

git checkout receiving-branch

Passaggio 3. Ora che gli FOI sono assenti, l'unione nel ramo del donatore non sovrascriverà alcun file non tracciato, quindi non otteniamo errori.

git merge donor-branch

Rimuovi tutti i file non tracciati:

git clean  -d  -fx .

Se si tratta di un'operazione una tantum, potresti semplicemente rimuovere tutti i file non tracciati dalla directory di lavoro prima di eseguire il pull. Leggi Come rimuovere i file locali (non tracciati) dall'albero di lavoro Git corrente? per informazioni su come rimuovere tutti i file non tracciati.

Assicurati di non rimuovere accidentalmente file non tracciati di cui hai ancora bisogno;)

Puoi provare quel comando

git clean -df

Aggiornamento: una versione migliore

Questo strumento ( https://github.com/mklepaczewski/git-clean-before-merge ):

• elimina i file non tracciati identici ai loro git pullequivalenti,
• ripristinare le modifiche ai file modificati la cui versione modificata è identica ai loro git pullequivalenti,
• segnalare file modificati / non tracciati che differiscono dalla loro git pullversione,
• lo strumento ha l' --pretendopzione che non modificherà alcun file.

Vecchia versione

In che modo questa risposta differisce dalle altre risposte?

Il metodo presentato qui rimuove solo i file che verrebbero sovrascritti dall'unione. Se nella directory sono presenti altri file non monitorati (probabilmente ignorati), questo metodo non li rimuoverà.

La soluzione

Questo frammento estrarrà tutti i file non tracciati che verrebbero sovrascritti git pulle li eliminerà.

git pull 2>&1|grep -E '^\s'|cut -f2-|xargs -I {} rm -rf "{}"

e poi fai semplicemente:

git pull

Questo non è il comando git porcelain, quindi ricontrolla sempre cosa farebbe con:

git pull 2>&1|grep -E '^\s'|cut -f2-|xargs -I {} echo "{}"

Spiegazione - perché una fodera fa paura:

Ecco una ripartizione di ciò che fa:

1. git pull 2>&1- cattura l' git pulloutput e reindirizza tutto su stdout in modo da poterlo catturare facilmente con grep.
2. grep -E '^\s- l'intenzione è quella di acquisire l'elenco dei file non tracciati che verrebbero sovrascritti git pull. I nomi dei file hanno un sacco di caratteri bianchi davanti a loro, quindi li usiamo per ottenerli.
3. cut -f2- - rimuove gli spazi bianchi dall'inizio di ogni riga catturata in 2.
4. xargs -I {} rm -rf "{}"- ci xargsconsente di scorrere su tutti i file, salvare il loro nome in "{}" e chiamare rmper ciascuno di essi. Usiamo -rfper forzare l'eliminazione e rimuovere le directory non tracciate.

Sarebbe bello sostituire i passaggi 1-3 con il comando di porcellana, ma non sono a conoscenza di alcun equivalente.

Se si considera l'utilizzo del -fflag, è possibile eseguirlo prima come dry-run. Solo che sai in anticipo che tipo di situazione interessante finirai dopo ;-P

-n 
--dry-run 
    Don’t actually remove anything, just show what would be done.

Oltre alla risposta accettata, puoi ovviamente rimuovere i file se non sono più necessari specificando il file:

git clean -f '/path/to/file/'

Ricordati di eseguirlo prima con il flag -n se vuoi vedere quali file git clean rimuoverà. Si noti che questi file verranno eliminati. Nel mio caso, comunque, non mi importava di loro, quindi quella era una soluzione migliore per me.

Un modo per farlo è nascondere le modifiche locali ed estrarre dal repository remoto. In questo modo, non perderai i tuoi file locali poiché i file andranno allo stash.

git add -A
git stash
git pull

Puoi controllare i tuoi file locali nascosti usando questo comando - git stash list

Per chi non lo sapesse, git ignora le differenze di nome maiuscole / minuscole in file e cartelle. Questo risulta essere un incubo quando li rinomini con lo stesso nome esatto con un caso diverso.

Ho riscontrato questo problema quando ho rinominato una cartella da "Petstore" a "petstore" (maiuscolo e minuscolo). Avevo modificato il mio file .git / config per smettere di ignorare il caso, apportato modifiche, annullato i miei commit e bloccato le mie modifiche per passare a un altro ramo. Non ho potuto applicare le mie modifiche nascoste a questo altro ramo.

La correzione che ho scoperto che ha funzionato è stata modificare temporaneamente il mio file .git / config per ignorare nuovamente temporaneamente il caso. Questo ha git stash applyavuto successo. Quindi, ho cambiato nuovamente ignoreCase a false. Ho quindi aggiunto tutto tranne i nuovi file nella cartella del petstore che git ha affermato stranamente che sono stati eliminati, per qualsiasi motivo. Ho eseguito il commit delle mie modifiche, quindi sono corso git reset --hard HEADper sbarazzarmi di quei nuovi file non tracciati. Il mio commit è apparso esattamente come previsto: i file nella cartella sono stati rinominati.

Spero che questo ti aiuti a evitare il mio stesso incubo.

Né clean / reset / hard checkout / rebase hanno funzionato per me.

Quindi ho appena rimosso i file di cui Git si è lamentato *

rm /path/to/files/that/git/complained/about

* Ho verificato se questi file possono essere rimossi controllando un repository nuovo di zecca in una cartella separata (i file non erano lì)

Nel mio caso quando ho avuto questo problema. Avevo un file locale che avevo rinominato sul telecomando.

Quando git pullho provato a Git mi ha detto che il nuovo nome file non è stato rintracciato, che era sul telecomando sebbene non esistesse ancora su local.

Perché non c'era un esempio locale a livello locale, non ho potuto farlo git pullfino a quando non ho fatto git rmil vecchio nome di file (che all'inizio non era ovvio a causa della mia stupida idea di rinominarlo).

Se hai i file scritti sotto .gitignore, rimuovi i file ed esegui nuovamente git pull. Questo mi ha aiutato.

Il problema è quando abbiamo modifiche in entrata che uniranno file non tracciati, git si lamenta. Questi comandi mi hanno aiutato:

git clean -dxf
git pull origin master