Como confirmar alterações de nome de arquivo com distinção entre maiúsculas e minúsculas no Git?

Eu mudei um nome de alguns arquivos de-capitalizar a primeira letra, como em Name.jpga name.jpg. O Git não reconhece essas alterações e eu tive que excluir os arquivos e enviá-los novamente. Existe uma maneira de o Git fazer distinção entre maiúsculas e minúsculas ao verificar alterações nos nomes dos arquivos? Eu não fiz nenhuma alteração no próprio arquivo.

Você pode usar o git mv :

git mv -f OldFileNameCase newfilenamecase

Git tem uma configuração que diz que se deve ser sensível a maiúsculas ou minúsculas: core.ignorecase. Para dizer ao Git que faz distinção entre maiúsculas e minúsculas, basta definir esta configuração como false:

git config core.ignorecase false

Documentação

A partir da git configdocumentação :

core.ignorecase

Se true, essa opção permite várias soluções alternativas para permitir que o git funcione melhor em sistemas de arquivos que não diferenciam maiúsculas de minúsculas, como FAT. Por exemplo, se uma listagem de diretório descobrir makefilequando o git espera Makefile, o git assumirá que ele é realmente o mesmo arquivo e continuará lembrando-o como Makefile.

O padrão é falso, exceto que o git-clone (1) ou o git-init (1) analisará e definirá core.ignorecasetrue se apropriado quando o repositório for criado.

Sistemas de arquivos que não diferenciam maiúsculas de minúsculas

Os dois sistemas operacionais mais populares que possuem sistemas de arquivos que não diferenciam maiúsculas de minúsculas são

• janelas
• OS X

Usando o SourceTree, consegui fazer tudo isso a partir da interface do usuário

1. Renomeie FILE.ext parawhatever.ext
2. Preparar esse arquivo
3. Agora renomeie whatever.ext parafile.ext
4. Prepare esse arquivo novamente

É um pouco entediante, mas se você precisar fazer apenas alguns arquivos, é muito rápido

Isto é o que eu fiz no OS X:

git mv File file.tmp
git mv file.tmp file

Duas etapas, porque, caso contrário, recebi o erro "arquivo existe". Talvez isso possa ser feito em uma etapa adicionando --cachedou algo assim.

Às vezes, é útil alterar temporariamente a distinção entre maiúsculas e minúsculas do Git:

Método # 1 - Altere a distinção entre maiúsculas e minúsculas para um único comando:

git -c core.ignorecase=true checkout mybranchpara desativar a distinção entre maiúsculas e minúsculas para um único checkoutcomando. Ou, mais geralmente: . (Agradeço ao VonC por sugerir isso nos comentários.)git -c core.ignorecase= <<true or false>> <<command>>

Método # 2 - Altere a distinção entre maiúsculas e minúsculas para vários comandos:

Para alterar a configuração por mais tempo (por exemplo, se vários comandos precisarem ser executados antes de alterá-la novamente):

1. git config core.ignorecase(isso retorna a configuração atual, por exemplo false).
2. git config core.ignorecase <<true or false>> - defina a nova configuração desejada.
3. ... Execute vários outros comandos ...
4. git config core.ignorecase <<false or true>> - defina o valor de configuração de volta à sua configuração anterior.

No OSX, para evitar esse problema e outros problemas no desenvolvimento de um sistema de arquivos que não diferenciam maiúsculas de minúsculas, você pode usar o Disk Utility para criar uma unidade / imagem de disco virtual que diferencia maiúsculas de minúsculas .

Execute o utilitário de disco, crie uma nova imagem de disco e use as seguintes configurações (ou altere conforme desejar, mas mantenha a distinção entre maiúsculas e minúsculas):

Certifique-se de informar ao git que agora está em um FS que diferencia maiúsculas de minúsculas:

git config core.ignorecase false

Tentei as seguintes soluções com outras respostas e elas não funcionaram:

• git mv filename
• git rm -f filename

Se o seu repositório estiver hospedado remotamente (GitHub, GitLab, BitBucket), você poderá renomear o arquivo na origem (GitHub.com) e forçar a renomeação do arquivo de maneira descendente.

As instruções abaixo pertencem ao GitHub, no entanto, a idéia geral por trás delas deve se aplicar a qualquer plataforma de hospedagem de repositório remoto. Lembre-se do tipo de arquivo que você está tentando renomear é importante, seja um tipo de arquivo que o GitHub considere editável (código, texto, etc.) ou não editável (imagem, binário, etc.) no navegador.

1. Visite o GitHub.com
2. Navegue para o seu repositório no GitHub.com e selecione a filial em que está trabalhando
3. Usando a ferramenta de navegação de arquivos do site, navegue até o arquivo que você deseja renomear
4. O GitHub permite editar o arquivo no navegador?
   • a.) Editável
     1. Clique no ícone "Editar este arquivo" (parece um lápis)
     2. Alterar o nome do arquivo na entrada de texto do nome do arquivo
   • b.) Não editável
     1. Abra o botão "Download" em uma nova guia e salve o arquivo no seu computador
     2. Renomeie o arquivo baixado
     3. Na guia anterior do GitHub.com, clique no ícone "Excluir este arquivo" (parece uma lixeira)
     4. Verifique se o branchnamebotão de opção "Confirmar diretamente na ramificação" está selecionado e clique no botão "Confirmar alterações"
     5. No mesmo diretório do GitHub.com, clique no botão "Upload de arquivos"
     6. Carregue o arquivo renomeado do seu computador
5. Verifique se o branchnamebotão de opção "Confirmar diretamente na ramificação" está selecionado e clique no botão "Confirmar alterações"
6. Localmente, faça checkout / busque / puxe o ramo
7. Feito

Semelhante à resposta de @ Sijmen, foi o que funcionou para mim no OSX ao renomear um diretório (inspirado nesta resposta de outro post):

git mv CSS CSS2
git mv CSS2 css

Simplesmente git mv CSS cssdeu o erro de argumento inválido: fatal: renaming '/static/CSS' failed: Invalid argumenttalvez porque o sistema de arquivos do OSX não diferencia maiúsculas de minúsculas

ps BTW, se você estiver usando o Django, o collectstatic também não reconheceria a diferença entre maiúsculas e minúsculas e você teria que fazer o acima, manualmente, também no diretório raiz estático

1) renomeie o arquivo Name.jpgparaname1.jpg

2) confirmar arquivo removido Name.jpg

3) renomeie o arquivo name1.jpgparaname.jpg

4) emendar arquivo adicionado name.jpgao commit anterior

git add
git commit --amend

Eu usei as seguintes etapas:

git rm -r --cached .
git add --all .
git commit -a -m "Versioning untracked files"
git push origin master

Para mim é uma solução simples

Podemos usar o comando git mv. Exemplo abaixo, se renomearmos o arquivo abcDEF.js para abcdef.js, podemos executar o seguinte comando no terminal

git mv -f .\abcDEF.js  .\abcdef.js

O Mac OSX High Sierra 10.13 corrige isso um pouco. Basta criar uma partição APFS virtual para seus projetos git; por padrão, ela não tem limite de tamanho e não ocupa espaço.

1. No Utilitário de Disco, clique no botão + enquanto o disco Container está selecionado
2. Selecione APFS (diferencia maiúsculas de minúsculas) no formato
3. Diga Sensitive
4. Lucro
5. Opcional: Crie uma pasta no Sensitive chamada giteln -s /Volumes/Sensitive/git /Users/johndoe/git

Sua unidade estará em /Volumes/Sensitive/

Como confirmar alterações de nome de arquivo com distinção entre maiúsculas e minúsculas no Git?

Já enfrentei esse problema várias vezes no MacOS. O Git diferencia maiúsculas de minúsculas, mas o Mac preserva apenas maiúsculas e minúsculas.

Alguém confirma um arquivo: Foobar.javae após alguns dias decide renomeá-lo para FooBar.java. Quando você pega o código mais recente, ele falha comThe following untracked working tree files would be overwritten by checkout...

A única maneira confiável que vi que corrige isso é:

1. git rm Foobar.java
2. Confirme com uma mensagem que você não pode perder git commit -m 'TEMP COMMIT!!'
3. Puxar
4. Isso abrirá um conflito forçando você a mesclar o conflito - porque sua alteração o excluiu, mas a outra alteração renomeou (daí o problema)
   1. Aceite sua alteração, que é a "exclusão"
   2. git rebase --continue
5. Agora solte sua solução alternativa git rebase -i HEAD~2e dropasTEMP COMMIT!!
6. Confirme se o arquivo agora é chamado FooBar.java

Quando você renomeia muitos arquivos e alguns deles são apenas uma mudança de maiúsculas e minúsculas, é difícil lembrar qual é qual. "git moving" manualmente o arquivo pode ser bastante trabalhoso. Então, o que eu faria durante minhas tarefas de alteração de nome de arquivo é:

1. remova todos os arquivos e pastas não-git para uma pasta / repositório diferente.
2. confirmar a pasta git vazia atual (isso será exibido como todos os arquivos excluídos.)
3. adicione todos os arquivos de volta à pasta / repositório git original.
4. confirmar a pasta git não vazia atual.

Isso resolverá todos os problemas do caso sem tentar descobrir quais arquivos ou pastas você renomeou.

Se nada funcionou, use git rm filename para excluir o arquivo do disco e adicioná-lo novamente.

Tomei @CBarr resposta e escreveu um Script 3 Python para fazê-lo com uma lista de arquivos:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import os
import shlex
import subprocess

def run_command(absolute_path, command_name):
    print( "Running", command_name, absolute_path )

    command = shlex.split( command_name )
    command_line_interface = subprocess.Popen( 
          command, stdout=subprocess.PIPE, cwd=absolute_path )

    output = command_line_interface.communicate()[0]
    print( output )

    if command_line_interface.returncode != 0:
        raise RuntimeError( "A process exited with the error '%s'..." % ( 
              command_line_interface.returncode ) )

def main():
    FILENAMES_MAPPING = \
    [
        (r"F:\\SublimeText\\Data", r"README.MD", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\Alignment", r"readme.md", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\AmxxEditor", r"README.MD", r"README.md"),
    ]

    for absolute_path, oldname, newname in FILENAMES_MAPPING:
        run_command( absolute_path, "git mv '%s' '%s1'" % ( oldname, newname ) )
        run_command( absolute_path, "git add '%s1'" % ( newname ) )
        run_command( absolute_path, 
             "git commit -m 'Normalized the \'%s\' with case-sensitive name'" % (
              newname ) )

        run_command( absolute_path, "git mv '%s1' '%s'" % ( newname, newname ) )
        run_command( absolute_path, "git add '%s'" % ( newname ) )
        run_command( absolute_path, "git commit --amend --no-edit" )

if __name__ == "__main__":
    main()