Existe uma maneira de esconder através das linhas?

Aqui está o meu caso de uso:

Eu tenho muito código que, devido à aplicação do estilo, escrevemos novas linhas antes e antes de cada chave de abertura e fechamento (respectivamente).

Exemplo:

function func(args) {

    statement 1;
    statement 2;

    if (condition) {

        statement 3; 

    }

}

Embora isso seja agradável e fácil de ler, considero um desperdício de espaço digno de palavrões, mas meus colegas de equipe não concordam comigo. Basicamente, é assim que estamos verificando nosso código e é isso.

Eu estava pensando que talvez eu possa usar os recursos do Vim para me ajudar a economizar espaço na tela, enquanto ainda me permite escrever o código da maneira detalhada. Não me importo de digitar, só quero um uso mais eficiente do espaço. Imaginei que talvez eu pudesse fazer com que o Vim colapsasse automaticamente as linhas vazias gratuitas.

Estou achando um pouco desafiador configurá-lo usando regras de sintaxe, porque tudo o que escrevo parece conflitar com as regras de sintaxe existentes, mas o que decidi fazer como primeira tentativa foi escrever essas regras que não colidirão:

syntax match aaaaaaaaa "\vabcd" conceal cchar=A
syntax match bbbbbbbbb "\vef\ngh" conceal cchar=B

A segunda regra aqui está próxima do que eu quero, que para o caso de colchete aberto é algo como /\v\{(\n\s*){2,}: combine um colchete aberto com qualquer número maior ou igual a 2 de uma nova linha seguida por apenas espaço em branco.

O que acontece dentro do vim, no entanto, é o seguinte:

1. Se eu digitar abcduma linha, ela ficará oculta Aconforme o esperado.

2. Se eu digitar efem uma linha e ghna seguinte, AMBAS as linhas ficam ocultas B.

Eu realmente estava realmente esperando que as duas linhas ef\nghestivessem ocultas em uma única linha, para que eu pudesse economizar espaço de buffer vertical dessa maneira.

Mas agora vejo que provavelmente é um problema de detalhes de implementação do Vim. O colapso de linhas é um problema para resolver o dobramento de código, provavelmente apenas fora do escopo no que diz respeito à ocultação.

Então, eu me pergunto se ainda há alguma maneira de fazer o que eu quero fazer. Talvez usando marcadores de dobra de alguma forma? O problema é que eu preciso dobrar apenas o espaço em branco vazio.

É possível abusar das dobras para ocultar linhas vazias extras. Aqui está como alguém poderia fazer isso:

function! SkipNewlineFoldExpr()
    let l:curline = getline(v:lnum)
    " fold begins at {$ or one line before }$
    if l:curline[-1:] == '{' || getline(v:lnum + 1)[-1:] == '}'
        return '>1'
    endif
    " fold ends one line after {$ or at }$
    if getline(v:lnum - 1)[-1:] == '{' || l:curline[-1:] == '}'
        return '<1'
    endif
    return 0
endfunction

function! SkipNewlineFoldText()
    " fold text matches non-empty line
    return getline(getline(v:foldstart)[-1:] == '{' ? v:foldstart : v:foldend)
endfunction

" customize how fold is defined
set foldexpr=SkipNewlineFoldExpr()
" customize how fold looks like
set foldtext=SkipNewlineFoldText()
" use 'foldexpr'
set foldmethod=expr

" Optional:
" drop highlighting of folds
" highlight clear Folded
" automatically close folds
" set foldclose=all
" automatically open folds on any actions on folded lines
" set foldopen=all

Seria algo como isto:

Como você pode ver, não há realce de sintaxe nas linhas dobradas, ainda pode ser algo mais suportável do que muitas linhas vazias desnecessárias. Você também pode ativar e desativar as dobras com ziatalho, caso elas estejam no seu caminho.

As dobras não são um tópico pequeno e o Vim possui um arquivo de ajuda separado . As opções relacionadas também estão vinculadas.

O comportamento detalhado do cursor e da pesquisa pode ser controlado via 'foldopen', que combinado com 'foldclose'define quando as dobras serão automaticamente abertas e fechadas para você.

Primeiro, é uma imposição de estilo de merda e você tem minhas simpatias. Em vez de esconder, que tal criar um mapeamento ou funções (como mostrado abaixo) para excluir as linhas desnecessárias antes de editá-las e adicioná-las quando terminar? algo ao longo das linhas:

function! Clean()
    %s/{\n^$/{/
    %s/^$\n\(\s*}\)/\1/
endfunction

function! Pollute()
    %s/{$/{\r/
    %s/\(\s*}\)/\r\1/
endfunction

A idéia básica começa, exclua as linhas vazias na leitura e substitua-as na gravação, não tentei, mas acho que isso pode ser adicionado como um autocmd assim:

au BufReadPost *.cpp call Clean()
au BufWritePost *.cpp call Pollute()