Ricevo errori "trailing whitespace" nel tentativo di eseguire il commit di alcuni file in git.

Voglio rimuovere automaticamente questi caratteri finali vuoti prima di salvare i file Python.

Puoi configurare vim per fare questo? Se é cosi, come?

Ho trovato la risposta qui .

L'aggiunta di quanto segue al mio file .vimrc ha funzionato.

autocmd BufWritePre *.py :%s/\s\+$//e

Compilazione sopra e salvataggio della posizione del cursore:

fun! <SID>StripTrailingWhitespaces()
    let l = line(".")
    let c = col(".")
    keepp %s/\s\+$//e
    call cursor(l, c)
endfun

autocmd FileType c,cpp,java,php,ruby,python autocmd BufWritePre <buffer> :call <SID>StripTrailingWhitespaces()

Se si desidera applicare questo al salvataggio su qualsiasi file, tralasciare il secondo autocmde utilizzare un carattere jolly *:

autocmd BufWritePre * :call <SID>StripTrailingWhitespaces()

Di solito ho anche un:

match Todo /\s\+$/

nel mio .vimrcfile, in modo che gli spazi bianchi di fine riga siano oscurati.

Todo è un nome di gruppo di hilighting di sintassi che viene utilizzato per parole chiave di hilighting come TODO, FIXMEo XXX. Ha un colore di sfondo giallastro fastidiosamente brutto e trovo che sia il migliore per le cose di hilight che non vuoi nel tuo codice :-)

Evidenzi entrambi gli spazi vuoti finali esistenti e spoglio anche gli spazi bianchi finali.

Configuro il mio editor (vim) per mostrare uno spazio bianco alla fine, ad es

con questo in fondo al mio .vimrc:

highlight ExtraWhitespace ctermbg=red guibg=red
match ExtraWhitespace /\s\+$/
autocmd BufWinEnter * match ExtraWhitespace /\s\+$/
autocmd InsertEnter * match ExtraWhitespace /\s\+\%#\@<!$/
autocmd InsertLeave * match ExtraWhitespace /\s\+$/
autocmd BufWinLeave * call clearmatches()

e lo "spoglio automaticamente" dai file quando li salvo, nel mio caso * .rb per i file ruby, sempre nel mio ~ / .vimrc

function! TrimWhiteSpace()
    %s/\s\+$//e
endfunction
autocmd BufWritePre     *.rb :call TrimWhiteSpace()

Ecco un modo per filtrare per più di un FileType.

autocmd FileType c,cpp,python,ruby,java autocmd BufWritePre <buffer> :%s/\s\+$//e

Copiato e incollato da http://blog.kamil.dworakowski.name/2009/09/unobtrusive-highlighting-of-trailing.html (il link non funziona più, ma il bit che ti serve è sotto)

"Questo ha il vantaggio di non evidenziare ogni spazio digitato alla fine della riga, solo quando si apre un file o si esce dalla modalità di inserimento. Molto pulito."

highlight ExtraWhitespace ctermbg=red guibg=red
au ColorScheme * highlight ExtraWhitespace guibg=red
au BufEnter * match ExtraWhitespace /\s\+$/
au InsertEnter * match ExtraWhitespace /\s\+\%#\@<!$/
au InsertLeave * match ExtraWhiteSpace /\s\+$/

Ho visto questa soluzione in un commento su VIM Wikia - Rimuovere gli spazi indesiderati

Mi è veramente piaciuto. Aggiunge .a agli spazi bianchi indesiderati.

Metti questo nel tuo .vimrc

" Removes trailing spaces
function TrimWhiteSpace()
  %s/\s*$//
  ''
endfunction

set list listchars=trail:.,extends:>
autocmd FileWritePre * call TrimWhiteSpace()
autocmd FileAppendPre * call TrimWhiteSpace()
autocmd FilterWritePre * call TrimWhiteSpace()
autocmd BufWritePre * call TrimWhiteSpace()

Ecco come lo sto facendo. Non ricordo dove l'ho rubato da TB.

autocmd BufWritePre * :call <SID>StripWhite()
fun! <SID>StripWhite()
    %s/[ \t]\+$//ge
    %s!^\( \+\)\t!\=StrRepeat("\t", 1 + strlen(submatch(1)) / 8)!ge
endfun

Una soluzione che rimuove semplicemente gli spazi bianchi finali dal file non è accettabile in tutte le circostanze. Funzionerà in un progetto che ha avuto questa politica sin dall'inizio, e quindi non ci sono spazi bianchi tali da non aggiungerti al tuo prossimo impegno.

Supponiamo di voler semplicemente non aggiungere nuove istanze di spazi bianchi finali, senza influire sugli spazi bianchi esistenti in righe che non sono state modificate, al fine di mantenere il commit libero da modifiche irrilevanti per il tuo lavoro.

In tal caso, con git, puoi usare uno script come questo:

#!/bin/sh

set -e # bail on errors

git stash save commit-cleanup
git stash show -p | sed '/^\+/s/ *$//' | git apply
git stash drop

Vale a dire, nascondiamo le modifiche e quindi filtriamo tutte le +linee nel diff per rimuovere il loro spazio bianco finale mentre applichiamo nuovamente la modifica alla directory di lavoro. Se questa pipe di comando ha esito positivo, eliminiamo la scorta.

Gli altri approcci qui in qualche modo non hanno funzionato per me in MacVim quando usato nel .vimrcfile. Quindi eccone uno che fa ed evidenzia gli spazi finali:

set encoding=utf-8
set listchars=trail:·
set list

autocmd BufWritePre * :%s/\s\+$//<CR>:let @/=''<CR>

Per le persone che vogliono eseguirlo per tipi di file specifici (FileTypes non sono sempre affidabili):

autocmd BufWritePre *.c,*.cpp,*.cc,*.h,*.hpp,*.py,*.m,*.mm :%s/\s\+$//e

O con vim7:

autocmd BufWritePre *.{c,cpp,cc,h,hpp,py,m,mm} :%s/\s\+$//e

Se tagli gli spazi bianchi, dovresti farlo solo su file che sono già puliti. "Quando a Roma...". Questa è una buona etichetta quando si lavora su basi di codice in cui i cambiamenti spuri sono sgraditi.

Questa funzione rileva gli spazi bianchi finali e attiva il taglio solo se era già pulito.

Il merito di questa idea va alla gemma di un commento qui: https://github.com/atom/whitespace/issues/10 (il più lungo flusso di commenti sui ticket dei bug di sempre)

autocmd BufNewFile,BufRead *.test call KarlDetectWhitespace()

fun! KarlDetectWhitespace()
python << endpython
import vim
nr_unclean = 0
for line in vim.current.buffer:
    if line.rstrip() != line:
        nr_unclean += 1

print "Unclean Lines: %d" % nr_unclean
print "Name: %s" % vim.current.buffer.name
cmd = "autocmd BufWritePre <buffer> call KarlStripTrailingWhitespace()"
if nr_unclean == 0:
    print "Enabling Whitespace Trimming on Save"
    vim.command(cmd)
else:
    print "Whitespace Trimming Disabled"
endpython
endfun

fun! KarlStripTrailingWhitespace()
    let l = line(".")
    let c = col(".")
    %s/\s\+$//e
    call cursor(l, c)
endfun