Como forçar uma substituição de arquivos locais em um git pull?

O cenário é o seguinte:

• Um membro da equipe está modificando os modelos para um site em que estamos trabalhando
• Eles estão adicionando algumas imagens ao diretório images (mas esquecem de adicioná-las sob controle de origem)
• Eles estão enviando as imagens por correio, mais tarde, para mim
• Estou adicionando as imagens sob o controle de origem e enviando-as para o GitHub junto com outras alterações
• Eles não podem receber atualizações do GitHub porque o Git não deseja substituir seus arquivos.

Este é o erro que estou recebendo:

erro: O arquivo da árvore de trabalho não rastreado 'public / images / icon.gif' seria substituído por mesclagem

Como forço o Git a substituí-los? A pessoa é designer - geralmente, eu resolvo todos os conflitos manualmente, para que o servidor tenha a versão mais recente que eles precisam atualizar no computador.

Importante: Se você tiver alterações locais, elas serão perdidas. Com ou sem --hardopção, quaisquer confirmações locais que não foram enviadas serão perdidas. ^[*]

Se você tiver algum arquivo que não seja rastreado pelo Git (por exemplo, conteúdo do usuário enviado), esses arquivos não serão afetados.

Eu acho que este é o caminho certo:

git fetch --all

Então, você tem duas opções:

git reset --hard origin/master

OU Se você estiver em outro ramo:

git reset --hard origin/<branch_name>

Explicação:

git fetch baixa a versão mais recente do controle remoto sem tentar mesclar ou refazer nada.

Em seguida, git resetredefine o ramo mestre para o que você acabou de buscar. A --hardopção altera todos os arquivos em sua árvore de trabalho para corresponder aos arquivos emorigin/master

Manter confirmações locais atuais

^[*] : Vale a pena notar que é possível manter confirmações locais atuais criando uma ramificação masterantes de redefinir:

git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master

Depois disso, todos os commits antigos serão mantidos new-branch-to-save-current-commits.

Alterações não confirmadas

Alterações não confirmadas, no entanto (mesmo preparadas), serão perdidas. Certifique-se de esconder e cometer o que precisar. Para isso, você pode executar o seguinte:

git stash

E, em seguida, reaplicar essas alterações não confirmadas:

git stash pop

Tente o seguinte:

git reset --hard HEAD
git pull

Deve fazer o que você quiser.

AVISO: git cleanexclui todos os seus arquivos / diretórios não rastreados e não pode ser desfeito.

Às vezes simplesmente clean -fnão ajuda. No caso de você não acompanhar o diretório, a opção -d também é necessária:

# WARNING: this can't be undone!

git reset --hard HEAD
git clean -f -d
git pull

AVISO: git cleanexclui todos os seus arquivos / diretórios não rastreados e não pode ser desfeito.

Considere usar o sinalizador -n( --dry-run) primeiro. Isso mostrará o que será excluído sem excluir nada:

git clean -n -f -d

Exemplo de saída:

Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
...

Como o Hedgehog, acho que as respostas são terríveis. Mas, embora a resposta de Hedgehog possa ser melhor, não acho que seja tão elegante quanto poderia ser. A maneira que descobri isso é usando "buscar" e "mesclar" com uma estratégia definida. O que deve garantir que as alterações locais sejam preservadas, desde que não sejam um dos arquivos com os quais você está tentando forçar uma substituição.

Primeiro faça um commit das suas alterações

 git add *
 git commit -a -m "local file server commit message"

Em seguida, busque as alterações e substitua se houver um conflito

 git fetch origin master
 git merge -s recursive -X theirs origin/master

"-X" é um nome de opção e "deles" é o valor dessa opção. Você está optando por usar as alterações "deles", em vez de "suas", se houver um conflito.

Em vez de fazer:

git fetch --all
git reset --hard origin/master

Eu recomendaria fazer o seguinte:

git fetch origin master
git reset --hard origin/master

Não é necessário buscar todos os controles remotos e ramificações para redefinir a ramificação de origem / mestre, certo?

Parece que a melhor maneira é fazer primeiro:

git clean

Para excluir todos os arquivos não rastreados e continuar com o procedimento usual git pull...

Atenção, isso excluirá permanentemente seus arquivos se você tiver alguma entrada de diretório / * no seu arquivo gitignore.

Algumas respostas parecem terríveis. Terrível no sentido do que aconteceu com @Lauri, seguindo a sugestão de David Avsajanishvili.

Em vez disso (git> v1.7.6):

git stash --include-untracked
git pull

Mais tarde, você pode limpar o histórico de stash.

Manualmente, um por um:

$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...

$ git stash drop stash@{0}
$ git stash drop stash@{1}

Brutalmente, tudo de uma vez:

$ git stash clear

Obviamente, se você quiser voltar ao que escondeu:

$ git stash list
...
$ git stash apply stash@{5}

Você pode achar este comando útil para descartar as alterações locais:

git checkout <your-branch> -f

E, em seguida, faça uma limpeza (remove arquivos não rastreados da árvore de trabalho):

git clean -f

Se você deseja remover diretórios não rastreados, além de arquivos não rastreados:

git clean -fd

Em vez de mesclar com git pull, tente o seguinte:

git fetch --all

Seguido por:

git reset --hard origin/master.

A única coisa que funcionou para mim foi:

git reset --hard HEAD~5

Isso levará de volta cinco commits e depois com

git pull

Eu descobri isso pesquisando como desfazer uma mesclagem do Git .

O problema com todas essas soluções é que elas são muito complexas ou, um problema ainda maior, é que elas removem todos os arquivos não rastreados do servidor da Web, o que não queremos, pois sempre há arquivos de configuração necessários que estão em uso. o servidor e não no repositório Git.

Aqui está a solução mais limpa que estamos usando:

# Fetch the newest code
git fetch

# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    rm -f -- "$file"
done

# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
do
    git checkout -- "$file"
done

# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull

• O primeiro comando busca os dados mais recentes.

• O segundo comando verifica se há arquivos que estão sendo adicionados ao repositório e exclui esses arquivos não rastreados do repositório local, o que causaria conflitos.

• O terceiro comando faz check-out de todos os arquivos que foram modificados localmente.

• Finalmente, fazemos um esforço para atualizar para a versão mais recente, mas desta vez sem conflitos, pois os arquivos não rastreados que estão no repositório não existem mais e todos os arquivos modificados localmente já são os mesmos do repositório.

Primeiro de tudo, tente da maneira padrão:

git reset HEAD --hard # To remove all not committed changes!
git clean -fd         # To remove all untracked (non-git) files and folders!

^{Aviso : Os comandos acima podem resultar em perda de dados / arquivos somente se você não os confirmar! Se você não tiver certeza, faça o backup primeiro de toda a pasta do repositório.}

Em seguida, puxe-o novamente.

Se o procedimento acima não ajudar e você não se importar com seus arquivos / diretórios não rastreados (faça o backup primeiro, por precaução), tente as seguintes etapas simples:

cd your_git_repo  # where 'your_git_repo' is your git repository folder
rm -rfv *         # WARNING: only run inside your git repository!
git pull          # pull the sources again

Isso REMOVERá todos os arquivos git (excempt .git/dir, onde você tem todos os commit) e o puxará novamente.

Por que git reset HEAD --hardpoderia falhar em alguns casos?

1. Regras personalizadas em .gitattributes file

   Tendo eol=lf regra em .gitattributes pode fazer com que o git modifique algumas alterações de arquivo, convertendo as terminações de linha CRLF em LF em alguns arquivos de texto.

   Se for esse o caso, você deve confirmar essas alterações de CRLF / LF (revisando-as git status) ou tente: git config core.autcrlf falseignorá-las temporariamente.

2. Incompatibilidade do sistema de arquivos

   Quando você estiver usando um sistema de arquivos que não suporta atributos de permissão. No exemplo, você tem dois repositórios, um no Linux / Mac ( ext3/ hfs+) e outro no sistema de arquivos baseado em FAT32 / NTFS.

   Como você percebe, existem dois tipos diferentes de sistemas de arquivos, então o que não suporta permissões Unix basicamente não pode redefinir as permissões de arquivos no sistema que não suporta esse tipo de permissões, portanto, não importa como --hardvocê tente, git sempre detecte algumas "alterações".

Eu tive o mesmo problema. Ninguém me deu essa solução, mas funcionou para mim.

Eu resolvi isso por:

1. Exclua todos os arquivos. Deixe apenas o .gitdiretório.
2. git reset --hard HEAD
3. git pull
4. git push

Agora funciona.

Bônus:

Ao falar sobre puxar / buscar / mesclar nas respostas anteriores, gostaria de compartilhar um truque interessante e produtivo,

git pull --rebase

Este comando acima é o comando mais útil na minha vida no Git, que economizou muito tempo.

Antes de enviar o commit recentemente ao servidor, tente este comando e ele sincronizará automaticamente as alterações mais recentes do servidor (com uma busca + mesclagem) e colocará o commit no topo do log do Git. Não há necessidade de se preocupar com puxar / mesclar manualmente.

Encontre detalhes em O que "git pull --rebase" faz? .

Eu tive um problema parecido. Eu tive que fazer isso:

git reset --hard HEAD
git clean -f
git pull

Resumi outras respostas. Você pode executar git pullsem erros:

git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull

Aviso : este script é muito poderoso, para que você possa perder suas alterações.

Com base em minhas próprias experiências semelhantes, a solução oferecida por Strahinja Kustudic acima é de longe a melhor. Como outros já apontaram, a simples reinicialização total removerá todos os os arquivos não rastreados, que podem incluir muitas coisas que você não deseja remover, como arquivos de configuração. O mais seguro é remover apenas os arquivos que estão prestes a serem adicionados e, nesse caso, é provável que você também deseje fazer check-out dos arquivos modificados localmente que estão prestes a serem atualizados.

Com isso em mente, atualizei o script de Kustudic para fazer exatamente isso. Também corrigi um erro de digitação (um ausente 'no original).

#/bin/sh

# Fetch the newest code
git fetch

# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    echo "Deleting untracked file $file..."
    rm -vf "$file"
done

# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
do
    echo "Checking out modified file $file..."
    git checkout $file
done

# Finally merge all the changes (you could use merge here as well)
git pull

Acredito que existem duas causas possíveis de conflito, que devem ser resolvidas separadamente e, até onde sei, nenhuma das respostas acima lida com os dois:

• Os arquivos locais não rastreados precisam ser excluídos, manualmente (mais seguro) ou conforme sugerido em outras respostas, git clean -f -d

• As confirmações locais que não estão na ramificação remota também precisam ser excluídas. Na IMO, a maneira mais fácil de conseguir isso é: git reset --hard origin/master(substitua 'master' por qualquer filial em que você esteja trabalhando e execute pela git fetch originprimeira vez)

Uma maneira mais fácil seria:

git checkout --theirs /path/to/file.extension
git pull origin master

Isso substituirá seu arquivo local pelo arquivo no git

Parece que a maioria das respostas aqui está focada no masterramo; no entanto, há momentos em que estou trabalhando no mesmo ramo de recursos em dois lugares diferentes e quero que uma rebase em um seja refletida no outro sem muito esforço.

Com base em uma combinação de resposta de RNA e resposta de Torek a uma pergunta semelhante , eu vim acima com este que funciona esplendidamente:

git fetch
git reset --hard @{u}

Execute isso a partir de uma ramificação e ela redefinirá apenas sua ramificação local para a versão upstream.

Isso pode ser bem colocado em um alias do git ( git forcepull):

git config alias.forcepull "!git fetch ; git reset --hard @{u}"

Ou, no seu .gitconfigarquivo:

[alias]
  forcepull = "!git fetch ; git reset --hard @{u}"

Aproveitar!

Eu tive o mesmo problema e, por algum motivo, até um git clean -f -d não o faria. Aqui está o porquê: Por algum motivo, se o seu arquivo for ignorado pelo Git (via uma entrada .gitignore, presumo), ele ainda se preocupa em substituí-lo com um puxão posterior , mas uma limpeza não o removerá, a menos que você o adicione -x.

Conheço um método muito mais fácil e menos doloroso:

$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp

É isso aí!

Acabei de resolver isso sozinho:

git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp

onde o último comando fornece uma lista de quais foram suas alterações locais. Continue modificando a ramificação "tmp" até que seja aceitável e, em seguida, retorne ao master com:

git checkout master && git merge tmp

Da próxima vez, você provavelmente poderá lidar com isso de uma maneira mais limpa pesquisando "git stash branch", embora o stash provavelmente cause problemas nas primeiras tentativas, faça o primeiro experimento em um projeto não crítico ...

Eu tenho uma situação estranha que nem git cleanou git resetobras. Eu tenho que remover o arquivo conflitante git indexusando o seguinte script em todos os arquivos não rastreados:

git rm [file]

Então eu sou capaz de puxar muito bem.

git fetch --all && git reset --hard origin/master && git pull

Apesar da pergunta original, as principais respostas podem causar problemas para pessoas que têm um problema semelhante, mas não querem perder seus arquivos locais. Por exemplo, consulte os comentários de Al-Punk e crizCraig.

A versão a seguir confirma as alterações locais em uma ramificação temporária ( tmp), verifica a ramificação original (que eu suponho que seja master) e mescla as atualizações. Você poderia fazer isso com stash, mas eu descobri que geralmente é mais fácil simplesmente usar a abordagem de ramificação / mesclagem.

git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master

git fetch origin master
git merge -s recursive -X theirs origin master

onde assumimos que o outro repositório está origin master.

Esses quatro comandos funcionam para mim.

git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master

Para verificar / puxar após executar esses comandos

git pull origin master

Eu tentei muito, mas finalmente obtive sucesso com esses comandos.

Apenas faça

git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname

Assim, você evita todos os efeitos colaterais indesejados, como excluir arquivos ou diretórios que deseja manter etc.

Redefina o índice e a cabeça para origin/master, mas não redefina a árvore de trabalho:

git reset origin/master

Requisitos:

1. Acompanhe as alterações locais para que ninguém aqui as perca.
2. Faça o repositório local corresponder ao repositório de origem remoto.

Solução:

1. Esconda as alterações locais.

2. Busque com uma limpeza de arquivos e diretórios, ignorando .gitignore e redefinição total da origem .

   git stash --include-untracked
   git fetch --all
   git clean -fdx
   git reset --hard origin/master