reorganiza automaticamente as linhas ao escrever remarcações no VIM

Muitas vezes, eu escrevo remarcações no VIM, e haverá parágrafos nessas remarcações. Para ajudar na minha edição, configurei meu Vim para quebrar uma linha em 80 caracteres. Funciona bem se eu continuar digitando, mas o problema é que, se eu precisar fazer alguma correção, isso se torna muito irritante.

demo (extraído da lógica de primeira ordem da wikipedia):

The adjective "first-order" distinguishes first-order logic from higher-order logic 
in which there are predicates having predicates or functions as arguments. In first-order 
theories, predicates are often associated with sets. In interpreted higher-order 
theories, predicates may be interpreted as sets of sets.

Por enquanto, tudo bem. Mas quando eu revisar o artigo, posso decidir adicionar algo no meio, dizer:

The adjective "first-order" distinguishes first-order logic from higher-order logic 
in which there are predicates having predicates or functions as arguments,
or in which one or both of predicate quantifiers or function quantifiers are permitted.
In first-order theories, predicates are often associated with sets. In interpreted higher-order
theories, predicates may be interpreted as sets of sets.

a linha de aviso 3 é a que eu quero agrupar. Se eu fizer isso no VIM, precisarei juntar manualmente as linhas e refazer a quebra do parágrafo inteiro.

Alguém tem idéia de como fazer o VIM fazer isso automaticamente?

Ainda mais simples: o asinalizador para 'formatoptions'permite a formatação automática de parágrafos sempre que o texto é inserido ou excluído. Veja :help fo-tablepara detalhes sobre 'formatoptions'bandeiras e :help autoformat.

:set formatoptions+=a

gqe gwformatará as linhas pelas quais o movimento a seguir se move.

Formatting is done with one of three methods:
                1. If 'formatexpr' is not empty the expression is
                   evaluated.  This can differ for each buffer.
                2. If 'formatprg' is not empty an external program
                   is used.
                3. Otherwise formatting is done internally.

                In the third case the 'textwidth' option controls the
                length of each formatted line

A diferença entre os dois é que gqdeixará o cursor no primeiro não espaço em branco da última linha formatada. gwcolocará o cursor de volta onde começou.

Você pode facilmente reorganizar manualmente o parágrafo com o qual o cursor está atualmente gwap, ou o documento inteiro com gggwG, embora isso mova o cursor graças à liderança gg.

Com um comando automático, é possível que a formatação ocorra automaticamente. Aqui está um exemplo que formata o parágrafo atual ao sair do modo de inserção:

augroup myformatting
    autocmd!
    autocmd InsertLeave * normal gwap<CR>
augroup END

Existem outros gatilhos de comando automático que podem ser úteis para você. Você pode explorar as opções em :help autocmd-events. Os mais relevantes estão provavelmente na subposição "vários".

Eu daria uma olhada :help 'textwidth'. Ele quebrará automaticamente as linhas enquanto você digita. No entanto, isso não funciona se você estiver editando o meio de uma linha.

Pessoalmente, prefiro deixar de textwidthlado, por isso criei uma função que se juntará automaticamente e dividirá um parágrafo. (Basicamente, formate-o automaticamente para 80 caracteres) É assim:

function! ParagraphToEightyChars()
   while (len(getline(".")) > 80)
      normal! 0
      " Find the first white-space character before the 81st character.
      call search('\(\%81v.*\)\@<!\s\(.*\s.\{-}\%81v\)\@!', 'c', line('.'))
      " Replace it with a new line.
      exe "normal! r\<CR>"
      " If the next line has words, join it to avoid weird paragraph breaks.
      if (getline(line('.')+1) =~ '\w')
         normal! J
      endif
   endwhile
   " Trim any accidental trailing whitespace
   :s/\s\+$//e
endfunction

Em seguida, tenho um mapeamento para chamá-lo sempre que preciso:

nnoremap <silent><A-J> :call ParagraphToEightyChars()<CR>

Essa função funciona muito bem formatoptions+=jrpara formatar comentários no código também! Basta colocar o cursor na primeira linha com mais de 80 caracteres e chamar a função.

(Nota: eu não fiz essa função geral fazer comprimentos diferentes de 80, mas acho que você só precisa alterar os anos 80 e 81 se quiser fazer outra coisa)

Veja :help 'textwidth'e :help 'formatoptions'para mais informações.

Por uma questão de integridade, gostaria de mencionar a opção baseada em plug-in.

Se você usar algo como ALE, que suporta a execução de seus buffers por meio de um embelezador ao salvar, você pode permitir que o Prettier manipule novamente o código.

Eu consegui isso colocando isso em ~/.vim/ftplugin/markdown.vim:

let b:ale_fixers = ['prettier', 'remove_trailing_lines', 'trim_whitespace']
let b:ale_javascript_prettier_options = '--prose-wrap always'

... e colocando isso em ~/.vimrc:

let g:ale_fix_on_save = 1