¿Hay alguna manera de ocultar entre líneas?

Aquí está mi caso de uso:

Tengo un montón de código que, debido a la aplicación de estilo, escribimos nuevas líneas después y antes de cada llave de apertura y cierre (respectivamente).

Ejemplo:

function func(args) {

    statement 1;
    statement 2;

    if (condition) {

        statement 3; 

    }

}

Si bien esto es agradable y fácil de leer, considero que es un desperdicio de espacio digno de improperio, pero mis compañeros de equipo no están de acuerdo conmigo. Básicamente así es como estamos registrando nuestro código y eso es todo.

Estaba pensando que tal vez pueda usar las funciones de Vim para ayudarme a guardar el espacio real de la pantalla, al tiempo que me permite escribir el código de forma detallada. No me importa escribirlo, solo quiero un uso más eficiente del espacio. Pensé que quizás podría hacer que Vim colapsara automáticamente las líneas vacías gratuitas.

Me resulta un tanto difícil configurar esto usando reglas de sintaxis porque lo que escribo parece entrar en conflicto con las reglas de sintaxis existentes, pero lo que decidí hacer como primer intento fue escribir estas reglas que no colisionarían:

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

La segunda regla aquí está cerca de lo que quiero, que para el caso de paréntesis abierto es algo así como /\v\{(\n\s*){2,}: hacer coincidir un paréntesis abierto con cualquier número mayor o igual a 2 de una nueva línea seguido de solo espacios en blanco.

Sin embargo, lo que sucede dentro de vim es lo siguiente:

1. Si escribo abcduna línea, se oculta Acomo se esperaba.

2. Si escribo efen una línea y ghen la siguiente, AMBAS líneas quedan ocultas B.

Realmente esperaba que las dos líneas ef\nghse hubieran ocultado en una sola línea para poder ahorrar algo de espacio de búfer vertical de esta manera.

Pero ahora veo que probablemente sea un problema de detalles de implementación de Vim. El colapso de líneas es un problema que debe resolver el plegado de código, probablemente fuera de alcance en lo que respecta a la ocultación.

Así que me pregunto si todavía hay alguna forma de hacer lo que quiero hacer. ¿Tal vez usando marcadores de plegado de alguna manera? El problema es que solo necesito plegar el espacio en blanco vacío.

Es posible abusar de los pliegues para ocultar líneas vacías adicionales. Así es como uno podría hacerlo:

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

Se vería algo así:

Como puede ver, no hay resaltado de sintaxis en las líneas plegadas, aún podría ser algo más soportable que muchas líneas vacías innecesarias. También puede activar y desactivar los pliegues con ziacceso directo en caso de que se interpongan en su camino.

Los pliegues no son un tema pequeño y Vim tiene un archivo de ayuda separado sobre ellos . Las opciones relacionadas también están vinculadas allí.

El comportamiento detallado del cursor y la búsqueda se puede controlar mediante 'foldopen', que combinado con 'foldclose'define cuándo los pliegues se abrirán y cerrarán automáticamente.

En primer lugar, es una aplicación de estilo de mierda y tienes mis condolencias. En lugar de esconderse, ¿qué tal crear un mapeo o funciones (como se muestra a continuación) para eliminar las líneas innecesarias antes de editarlas y agregarlas cuando haya terminado? algo en la línea:

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

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

La idea básica comienza: elimine las líneas vacías en la lectura y reemplácelas en la escritura, no lo intenté, pero siento que esto se puede agregar como un autocmd de esta manera:

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