Em um projeto em que alguns dos arquivos contêm ^ M como separadores de nova linha. A difusão desses arquivos é aparentemente impossível, pois o git-diff vê como o arquivo inteiro é apenas uma única linha.

Como alguém se diferencia da versão anterior?

Existe uma opção como "tratar ^ M como nova linha ao diferir"?

prompt> git-diff "HEAD^" -- MyFile.as 
diff --git a/myproject/MyFile.as b/myproject/MyFile.as
index be78321..a393ba3 100644
--- a/myproject/MyFile.cpp
+++ b/myproject/MyFile.cpp
@@ -1 +1 @@
-<U+FEFF>import flash.events.MouseEvent;^Mimport mx.controls.*;^Mimport mx.utils.Delegate
\ No newline at end of file
+<U+FEFF>import flash.events.MouseEvent;^Mimport mx.controls.*;^Mimport mx.utils.Delegate
\ No newline at end of file
prompt>

ATUALIZAR:

agora escrevi um script Ruby que verifica as últimas 10 revisões e converte CR em LF.

require 'fileutils'

if ARGV.size != 3
  puts "a git-path must be provided"
  puts "a filename must be provided"
  puts "a result-dir must be provided"
  puts "example:"
  puts "ruby gitcrdiff.rb project/dir1/dir2/dir3/ SomeFile.cpp tmp_somefile"
  exit(1)
end

gitpath = ARGV[0]
filename = ARGV[1]
resultdir = ARGV[2]

unless FileTest.exist?(".git")
  puts "this command must be run in the same dir as where .git resides"
  exit(1)
end

if FileTest.exist?(resultdir)
  puts "the result dir must not exist"
  exit(1)
end
FileUtils.mkdir(resultdir)

10.times do |i|
  revision = "^" * i
  cmd = "git show HEAD#{revision}:#{gitpath}#{filename} | tr '\\r' '\\n' > #{resultdir}/#{filename}_rev#{i}"
  puts cmd 
  system cmd
end

O GitHub sugere que você deve usar \ n apenas como um caractere de nova linha em repositórios manipulados por git. Há uma opção para converter automaticamente:

$ git config --global core.autocrlf true

Obviamente, isso é dito para converter crlf em lf, enquanto você deseja converter crlf em lf. Espero que isso ainda funcione ...

E depois converta seus arquivos:

# Remove everything from the index
$ git rm --cached -r .

# Re-add all the deleted files to the index
# You should get lots of messages like: "warning: CRLF will be replaced by LF in <file>."
$ git diff --cached --name-only -z | xargs -0 git add

# Commit
$ git commit -m "Fix CRLF"

core.autocrlf é descrito na página do manual .

Desenvolvendo no Windows, encontrei esse problema ao usar git tfs. Eu resolvi assim:

git config --global core.whitespace cr-at-eol

Isso basicamente diz ao Git que um CR de fim de linha não é um erro. Como um resultado, essas irritantes ^Mcaracteres já não aparecem no fim das linhas no git diff, git showetc.

Parece deixar outras configurações como estão; por exemplo, espaços extras no final de uma linha ainda aparecem como erros (destacados em vermelho) no diff.

(Outras respostas aludiram a isso, mas o acima é exatamente como definir a configuração. Para definir a configuração para apenas um projeto, omita o --global.)

EDIT :

Depois de muitas tarefas de final de linha, tive a melhor sorte, ao trabalhar em uma equipe .NET, com estas configurações:

• SEM configuração core.eol
• SEM configuração core.whitespace
• NENHUMA configuração core.autocrlf
• Ao executar o instalador do Git para Windows, você terá estas três opções:
  • Faça checkout no estilo Windows, confirme finais de linha no estilo Unix <- escolha este
  • Faça o checkout como está, confirme finais de linha no estilo Unix
  • Fazer check-out como está, confirmar como está

Se você precisar usar a configuração de espaço em branco, provavelmente deverá ativá-la somente por projeto, se precisar interagir com o TFS. Apenas omita o --global:

git config core.whitespace cr-at-eol

Se você precisar remover algumas configurações principais. *, A maneira mais fácil é executar este comando:

git config --global -e

Isso abre seu arquivo .gitconfig global em um editor de texto e você pode excluir facilmente as linhas que deseja remover. (Ou você pode colocar '#' na frente deles para comentar.)

Tente git diff --ignore-space-at-eol, ou git diff --ignore-space-change, ou git diff --ignore-all-space.

Veja também:

core.whitespace = cr-at-eol

ou equivalente,

[core]
    whitespace = cr-at-eol

onde whitespaceé precedido por um caractere de tabulação .

Por que você os coloca ^Mno seu git diff?

No meu caso, eu estava trabalhando em um projeto desenvolvido no Windows e usei o OS X. Quando alterei algum código, vi ^Mno final das linhas adicionadas git diff. Eu acho ^Mque eles estavam aparecendo porque eram finais de linha diferentes dos demais arquivos. Como o restante do arquivo foi desenvolvido no Windows, ele utilizava CRfinais de linha e, no OS X, LFfinal de linha.

Aparentemente, o desenvolvedor do Windows não usou a opção "Fazer checkout no estilo Windows, confirmar finais de linha no estilo Unix " durante a instalação do Git.

Então, o que devemos fazer sobre isso?

Você pode fazer com que os usuários do Windows reinstale o git e use a opção " Checkout no estilo Windows, confirme finais de linha no estilo Unix ". É isso que eu preferiria, porque vejo o Windows como uma exceção em seus caracteres de final de linha e o Windows corrige seu próprio problema dessa maneira.

Se você optar por esta opção, deverá corrigir os arquivos atuais (porque eles ainda estão usando as CRterminações de linha). Eu fiz isso seguindo estas etapas:

1. Remova todos os arquivos do repositório, mas não do seu sistema de arquivos.

   git rm --cached -r .
   

2. Adicione um .gitattributesarquivo que imponha certos arquivos para usar um LFfinal de linha. Coloque isso no arquivo:

   *.ext text eol=crlf
   

   Substitua .extpelas extensões de arquivo que você deseja corresponder.

3. Adicione todos os arquivos novamente.

   git add .
   

   Isso mostrará mensagens como esta:

   warning: CRLF will be replaced by LF in <filename>.
   The file will have its original line endings in your working directory.
   

4. Você pode remover o .gitattributesarquivo, a menos que tenha usuários teimosos do Windows que não desejam usar a opção " Checkout no estilo Windows, confirmar finalizações de linha no estilo Unix ".

5. Comprometa e empurre tudo.

6. Remova e faça o check-out dos arquivos aplicáveis ​​em todos os sistemas em que são usados. Nos sistemas Windows, certifique-se de que agora eles usem a opção " Checkout no estilo Windows, confirme finais de linha no estilo Unix ". Você também deve fazer isso no sistema em que executou essas tarefas, porque quando você adicionou os arquivos, o git disse:

   The file will have its original line endings in your working directory.
   

   Você pode fazer algo assim para remover os arquivos:

   git ls | grep ".ext$" | xargs rm -f
   

   E então, para recuperá-los com as terminações de linha corretas:

   git ls | grep ".ext$" | xargs git checkout
   

   É claro que substituindo .extpela extensão que você deseja.

Agora, seu projeto usa apenas LFcaracteres para as terminações de linha, e os CRcaracteres desagradáveis nunca mais voltarão :).

A outra opção é aplicar as terminações de linha de estilo do Windows. Você também pode usar o .gitattributesarquivo para isso.

Mais informações: https://help.github.com/articles/dealing-with-line-endings/#platform-all

Existe uma opção como "tratar ^ M como nova linha ao diferir"?

Haverá um com o Git 2.16 (primeiro trimestre de 2018), como o "diff família de comandos " aprendeu a ignorar as diferenças no retorno de carro no final da linha.

Veja commit e9282f0 (26 de outubro de 2017) por Junio ​​C Hamano ( gitster) .
Ajudado por: Johannes Schindelin ( dscho) .
^{(Mesclado por Junio ​​C Hamano - gitster- na confirmação 10f65c2 , 27 de novembro de 2017)}

diff: --ignore-cr-at-eol

Uma nova opção --ignore-cr-at-eolinforma ao equipamento diff para tratar um retorno de carro no final de uma linha (completa) como se ela não existisse.

Assim como outras " --ignore-*" opções para ignorar vários tipos de diferenças de espaço em branco, isso ajudará a revisar as mudanças reais que você fez sem se distrair com CRLF<->LFconversões espúrias feitas pelo seu programa de edição.

TL; DR

Mude core.pagerpara para "tr -d '\r' | less -REX", não para o código fonte

Isso é por que

Os incômodos ^ M mostrados são um artefato da colorização e do pager. É causada por less -Ruma opção padrão do git pager. (o pager padrão do git é less -REX)

A primeira coisa a observar é que git diff -bnão mostrará alterações no espaço em branco (por exemplo, \ r \ n vs \ n)

configuração:

git clone https://github.com/CipherShed/CipherShed
cd CipherShed

Um teste rápido para criar um arquivo unix e alterar as terminações de linha não mostrará alterações com git diff -b:

echo -e 'The quick brown fox\njumped over the lazy\ndogs.' > test.txt
git add test.txt
unix2dos.exe test.txt
git diff -b test.txt

Observamos que forçar um tubo para menos não mostra o ^ M, mas ativando a cor e less -R:

git diff origin/v0.7.4.0 origin/v0.7.4.1 | less
git -c color.ui=always diff origin/v0.7.4.0 origin/v0.7.4.1 | less -R

A correção é mostrada usando um tubo para remover o \ r (^ M) da saída:

git diff origin/v0.7.4.0 origin/v0.7.4.1
git -c core.pager="tr -d '\r' | less -REX"  diff origin/v0.7.4.0 origin/v0.7.4.1

Uma alternativa imprudente é usar less -r, porque passará por todos os códigos de controle, não apenas pelos códigos de cores.

Se você quiser apenas editar seu arquivo de configuração git diretamente, esta é a entrada para atualizar / adicionar:

[core]
        pager = tr -d '\\r' | less -REX

Eu lutei com esse problema por um longo tempo. De longe, a solução mais fácil é não se preocupar com os caracteres ^ M e apenas usar uma ferramenta visual diff que possa lidar com eles.

Em vez de digitar:

git diff <commitHash> <filename>

tentar:

git difftool <commitHash> <filename>

No meu caso, o que foi esse comando:

git config  core.whitespace cr-at-eol

Fonte: https://public-inbox.org/git/[email protected]/T/

Conforme observado pelo VonC, isso já foi incluído no git 2.16+. Infelizmente, o nome da opção ( --ignore-cr-at-eol) difere daquele usado pelo GNU diff com o qual estou acostumado ( --strip-trailing-cr).

Quando fui confrontado com esse problema, minha solução foi chamar o GNU diff em vez do diff interno do git, porque meu git é mais antigo que 2.16. Eu fiz isso usando esta linha de comando:

GIT_EXTERNAL_DIFF='diff -u --strip-trailing-cr "$2" "$5";true;#' git diff --ext-diff

Isso permite o uso --strip-trailing-cre qualquer outra opção de diferença GNU.

Há também esta outra maneira:

git difftool -y -x 'diff -u --strip-trailing-cr'

mas não usa as configurações do pager, e é por isso que prefiro o primeiro.