C'è un modo per nascondere attraverso le linee?

Ecco il mio caso d'uso:

Ho un sacco di codice che a causa dell'applicazione dello stile scriviamo nuove righe dopo e prima di ogni parentesi aperta e chiusa (rispettivamente).

Esempio:

function func(args) {

    statement 1;
    statement 2;

    if (condition) {

        statement 3; 

    }

}

Mentre questo è bello e facile da leggere, lo considero uno spreco di spazio deplorevole, ma i miei compagni di squadra non sono d'accordo con me. Fondamentalmente questo è il modo in cui stiamo controllando il nostro codice e basta.

Stavo pensando che forse potrei usare le funzionalità di Vim per aiutarmi a salvare lo schermo immobiliare, pur permettendomi di scrivere il codice in modo dettagliato. Non mi dispiace digitarlo, voglio solo un uso più efficiente dello spazio. Ho pensato che forse avrei potuto far crollare automaticamente le linee vuote gratuite di Vim.

Sto trovando un po 'difficile impostare questo usando le regole di sintassi perché tutto ciò che scrivo sembra essere in conflitto con le regole di sintassi esistenti, ma quello che ho deciso di fare come primo tentativo è stato quello di scrivere queste regole che non si scontreranno:

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

La seconda regola qui è vicina a ciò che voglio, che per il caso parentesi aperta è qualcosa di simile /\v\{(\n\s*){2,}: abbina una parentesi aperta con qualsiasi numero maggiore o uguale a 2 di una nuova riga seguito da solo uno spazio bianco.

Ciò che accade all'interno di Vim è tuttavia il seguente:

1. Se scrivo abcduna riga, viene nascosto Acome previsto.

2. Se scrivo efsu una riga e ghsu quella successiva, ENTRAMBI le linee diventano nascoste B.

Speravo davvero che le due linee ef\nghsarebbero state nascoste in una sola riga in modo da poter salvare un po 'di spazio nel buffer verticale in questo modo.

Ma vedo ora che è probabilmente un problema di dettaglio dell'implementazione di Vim. Il collasso delle linee è un problema da risolvere per la piegatura del codice, probabilmente al di fuori del campo di applicazione per quanto riguarda l'occultamento.

Quindi mi chiedo se c'è ancora un modo per fare quello che voglio fare. Forse in qualche modo usando i marker di piega? Il problema è che ho bisogno di piegare solo gli spazi vuoti.

È possibile abusare delle pieghe per nascondere righe vuote in più. Ecco come si potrebbe fare:

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

Sarebbe simile a questo:

Come puoi vedere non c'è evidenziazione della sintassi sulle linee piegate, potrebbe comunque essere qualcosa di più sopportabile di molte linee vuote non necessarie. Puoi anche attivare e disattivare le pieghe con la ziscorciatoia nel caso si trovino sulla tua strada.

Le pieghe non sono un piccolo argomento e Vim ha un file di aiuto separato su di esse . Anche le opzioni correlate sono collegate lì.

Il comportamento dettagliato del cursore e della ricerca può essere controllato tramite 'foldopen', che combinato con 'foldclose'definisce quando le pieghe saranno automaticamente aperte e chiuse per te.

Prima di tutto, è un'applicazione di merda e hai le mie simpatie. Invece di nascondere come creare una mappatura o funzioni (come mostrato di seguito) per eliminare le righe non necessarie prima di modificarle e aggiungerle al termine? qualcosa del genere:

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

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

L'idea di base inizia, elimina le righe vuote in lettura e le sostituisce in scrittura, non l'ho provato ma penso che questo possa essere aggiunto come un autocmd in questo modo:

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