Existe-t-il un moyen de masquer les lignes?

Voici mon cas d'utilisation:

J'ai beaucoup de code qui, en raison de l'application du style, nous écrivons des sauts de ligne après et avant chaque accolade ouverte et fermée (respectivement).

Exemple:

function func(args) {

    statement 1;
    statement 2;

    if (condition) {

        statement 3; 

    }

}

Bien que cela soit agréable et facile à lire, je considère que c'est un gaspillage d'espace digne d'explications, mais mes coéquipiers ne sont pas d'accord avec moi. Fondamentalement, c'est ainsi que nous vérifions notre code et c'est tout.

Je pensais que je pourrais peut-être utiliser les fonctionnalités de Vim pour m'aider à économiser de l'espace sur l'écran, tout en me permettant d'écrire le code de manière verbeuse. Cela ne me dérange pas de le taper, je veux juste une utilisation plus efficace de l'espace. Je me suis dit que je pourrais peut-être demander à Vim de réduire automatiquement les lignes vides gratuites.

Je trouve un peu difficile de configurer cela en utilisant des règles de syntaxe parce que tout ce que j'écris semble entrer en conflit avec les règles de syntaxe existantes, mais ce que j'ai décidé de faire comme première tentative était d'écrire ces règles qui n'entreront pas en collision:

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

La deuxième règle ici est proche de ce que je veux, ce qui pour le cas du crochet ouvert est quelque chose comme /\v\{(\n\s*){2,}: faire correspondre un crochet ouvert avec un nombre supérieur ou égal à 2 d'une nouvelle ligne suivi uniquement d'un espace.

Cependant, ce qui se passe à l'intérieur de vim est le suivant:

1. Si je tape abcdune ligne, elle est cachée Acomme prévu.

2. Si je tape efsur une ligne et ghsur la suivante, les DEUX lignes deviennent cachées avec B.

J'espérais vraiment que les deux lignes ef\nghauraient été cachées en une seule ligne afin de pouvoir économiser de l'espace tampon vertical de cette façon.

Mais je vois maintenant que c'est probablement un problème de détail d'implémentation de Vim. La réduction des lignes est un problème à résoudre pour le pliage de code, probablement juste hors de portée en ce qui concerne la dissimulation.

Je me demande donc s'il y a encore un moyen de faire ce que je veux faire. Peut-être utiliser des marqueurs de pliage d'une manière ou d'une autre? Le problème est que je dois replier uniquement les espaces vides.

Il est possible d'abuser des plis pour masquer des lignes vides supplémentaires. Voici comment on pourrait le faire:

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

Cela ressemblerait à quelque chose comme ceci:

Comme vous pouvez le voir, il n'y a pas de coloration syntaxique sur les lignes pliées, mais peut-être encore plus supportable que beaucoup de lignes vides inutiles. Vous pouvez également activer et désactiver les plis avec un ziraccourci au cas où ils vous gêneraient.

Les plis ne sont pas un petit sujet et Vim a un fichier d'aide distinct sur eux . Les options connexes y sont également liées.

Le comportement détaillé du curseur et de la recherche peut être contrôlé via 'foldopen', ce qui combiné avec 'foldclose'définit quand les plis seront automatiquement ouverts et fermés pour vous.

Tout d'abord, c'est une application de style merdique et vous avez ma sympathie. Au lieu de cacher comment créer un mappage ou des fonctions (comme indiqué ci-dessous) pour supprimer les lignes inutiles avant de les modifier et de les ajouter lorsque vous avez terminé? quelque chose le long des lignes:

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

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

L'idée de base commence, supprimez les lignes vides à la lecture et remplacez-les à l'écriture, ne l'essayez pas, mais je pense que cela peut être ajouté comme un autocmd comme ceci:

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