Gibt es eine bewährte Methode zum Falten einer vimrc-Datei

Ich habe kürzlich festgestellt, dass meine vimrcZeilen jetzt mehr als 400 Zeilen lang sind (was meiner Meinung nach zu viel ist, um das zu reduzieren), und um das Navigieren, Lesen und Bearbeiten zu vereinfachen, habe ich mich entschlossen, das Konzept des Falzens in vim (welches) zu untersuchen Ich war nicht vertraut mit) .

• Ich habe versucht, die Faltmethode auf einzustellen, indentaber das Ergebnis hat mir nicht gefallen (es war meistens zu chaotisch, weil ein großer Teil von mir vimrcnicht wirklich eingerückt ist).
• Ich habe auch versucht zu Satz foldmethodzu exprund syntaxaber ich war nicht in der Lage etwas richtig zu falten.
• Hier diffscheint die Verwendung als Faltmethode nicht relevant zu sein. (Oder wenn es so ist, habe ich nicht verstanden, wie man es benutzt)
• Im Moment verwende ich die markerMethode, die mich aufgrund der "{{{und "}}}-Zeichen, die ich in der Datei als "verrauscht" empfand, nicht ganz zufrieden stellt .

Daher würde ich gerne wissen, ob es bewährte Methoden oder allgemeine Richtlinien für das ordnungsgemäße Falten von a gibtvimrc .

Anmerkung 1: Wie wir alle wissen, ist SO kein Forum und nicht dazu gemacht, persönliche Meinungen zu sammeln, und das ist auch nicht das, wonach ich suche: Natürlich haben einige Leute ihre Vorlieben, aber ich möchte gerne wissen, warum Marker (zum Beispiel) verbessern die Lesbarkeit mehr als die Verwendung von Einrückungen.

Anmerkung 2: Auch mein Hauptziel ist es, mein Wissen vimrcso klar wie möglich zu machen. Wenn es also andere Best Practices gibt, um ein Nettes zu schaffen, vimrcbin ich gespannt darauf.

Edit 1: Ich hätte genau sagen sollen, dass meine vimrcbereits in Abschnitte (und manchmal Unterabschnitte) unterteilt ist, wobei die wichtigsten sind

• Allgemeine Optionen
• Plugins (enthält einen Unterabschnitt für jedes Plugin und seine Konfiguration)
• Zuordnungen
• Navigation (enthält auch Unterabschnitt)
• Farbe
• etc...

Und genau diese Struktur hat mich zum Falten gebracht: Ich denke, dass es ziemlich praktisch ist, nur den Abschnitt ausgeben zu können, der mich an einem bestimmten Punkt interessiert.

Edit 2: Antwort Erwähnung von Unterteilungen der vimrcin mehreren Dateien sind gültig, aber als persönliche Präferenz würde ich lieber Falten verwenden, weil ich denke, es ist einfacher, nur eine Datei im Git-Repo zu pflegen, die meine Punktedateien enthält. Das ist nur eine persönliche Präferenz und ich bin mir bewusst, dass es auch möglich ist, diesen Ansatz zu verwenden, aber ich würde es vorziehen, zu falten.

Ich habe folgende -Modelines am unteren Rand meiner , vimrcdie ich von godlygeek kopiert, dem Autor von tabellarischen :

"" vim:fdm=expr:fdl=0
"" vim:fde=getline(v\:lnum)=~'^""'?'>'.(matchend(getline(v\:lnum),'""*')-2)\:'='

Dadurch wird jede Zeile, die mit 2+ beginnt ", gefaltet. Je mehr desto "tiefer ist die Falte. Auf diese Weise können Sie bei Bedarf Abschnitte unterteilen.

Es ist eine gute Idee, zuerst Ihre eigenen Kategorien in Ihrer .vimrc(wie eine Liste mit Unterlisten und Unterlisten) zu definieren und all Ihre Plugins / Einstellungen / Funktionen zu den jeweiligen Kategorien hinzuzufügen. In Kombination mit individuellem Falten kann dies großartig funktionieren:

Das obige Beispiel zeigt mögliche Kategorien, die ich für die Strukturierung meiner hilfreich finde .vimrc. Es werden die folgenden benutzerdefinierten Falzeinstellungen verwendet:

""""""""""""""""""""""""
"  THIS IS A CATEGORY  "
""""""""""""""""""""""""
"" Autofolding .vimrc
" see http://vimcasts.org/episodes/writing-a-custom-fold-expression/
""" defines a foldlevel for each line of code
function! VimFolds(lnum)
  let s:thisline = getline(a:lnum)
  if match(s:thisline, '^"" ') >= 0
    return '>2'
  endif
  if match(s:thisline, '^""" ') >= 0
    return '>3'
  endif
  let s:two_following_lines = 0
  if line(a:lnum) + 2 <= line('$')
    let s:line_1_after = getline(a:lnum+1)
    let s:line_2_after = getline(a:lnum+2)
    let s:two_following_lines = 1
  endif
  if !s:two_following_lines
      return '='
    endif
  else
    if (match(s:thisline, '^"""""') >= 0) &&
       \ (match(s:line_1_after, '^"  ') >= 0) &&
       \ (match(s:line_2_after, '^""""') >= 0)
      return '>1'
    else
      return '='
    endif
  endif
endfunction

""" defines a foldtext
function! VimFoldText()
  " handle special case of normal comment first
  let s:info = '('.string(v:foldend-v:foldstart).' l)'
  if v:foldlevel == 1
    let s:line = ' ◇ '.getline(v:foldstart+1)[3:-2]
  elseif v:foldlevel == 2
    let s:line = '   ●  '.getline(v:foldstart)[3:]
  elseif v:foldlevel == 3
    let s:line = '     ▪ '.getline(v:foldstart)[4:]
  endif
  if strwidth(s:line) > 80 - len(s:info) - 3
    return s:line[:79-len(s:info)-3+len(s:line)-strwidth(s:line)].'...'.s:info
  else
    return s:line.repeat(' ', 80 - strwidth(s:line) - len(s:info)).s:info
  endif
endfunction

""" set foldsettings automatically for vim files
augroup fold_vimrc
  autocmd!
  autocmd FileType vim 
                   \ setlocal foldmethod=expr |
                   \ setlocal foldexpr=VimFolds(v:lnum) |
                   \ setlocal foldtext=VimFoldText() |
     "              \ set foldcolumn=2 foldminlines=2
augroup END

Verwenden Sie die folgende Syntax, um Ihre eigenen Kategorien und Unterkategorien zu definieren:

""""""""""""""
"  Category  "
""""""""""""""
"" Subcategory
""" Subsubcategory
" Just a comment, gets ignored no matter where

Die Kategorie der obersten Ebene kann sehr einfach erstellt werden, wenn Sie Vim-Snippets verwenden (z. B. mit UltiSnips ): Erweitern Sie einfach das boxoder bboxdas von Vim-Snippets bereitgestellte Snippet (schreiben Sie boxoder bboxund drücken Sie den Auslöser zum Erweitern).

Um Falten noch schneller zu öffnen und zu schließen, drücken Sie zweimal die Leertaste:

let mapleader = "\<space>"
" Toggle folds
nnoremap <silent> <leader><Space> @=(foldlevel('.')?'za':"\<Space>")<CR>
vnoremap <leader><space> zf

Auf diese Weise haben Sie eine gut strukturierte, .vimrcdie leicht navigiert werden kann.

Ich verwende meine Primärdatei vimrcals Verknüpfung zu mehreren anderen kategorisierten Dateien, wobei jede nach Belieben ausgewählt wird, z. B. Vim-Optionen in einer Datei, Plugin-Einstellungen in einer anderen.

"--- Vim Options
source ~/.vim/config/vim_options.vim

"--- Here Be Functions!
" (need to be sourced before stuff that uses 'em)
runtime! functions/*.vim

"--- Key Mapping
source ~/.vim/config/key_mapping.vim

"--- Folding
source ~/.vim/config/folding.vim

"--- Autocmds
source ~/.vim/config/autocmds.vim

"--- We Are Plugged In!
source ~/.vim/config/plugins.vim

" vim: ft=vim fdm=marker

Als direktere Antwort auf die OP-Frage verwende ich die Markierungsmethode, aber zum größten Teil auf der rechten Seite mit Abstand und in der Nähe von mehr Kategorien als Einzelpersonen. Ich mache jedes Plugin separat.

Man könnte sagen, dass "Best Practice" in erster Linie eine Ansichtssache ist, :) aber es gibt zwei Ansätze, die (1) offensichtlich Sinn machen und (2) auf alle Konfigurationsdateien angewendet werden können, nicht nur auf die von Vim: Falten nach logischen Abschnitten und Unterabschnitte (oder noch tiefer, wenn Sie sich mutig fühlen), und teilen Sie Ihre Konfiguration in mehrere kleinere Dateien und :source-en Sie diese.

Ich persönlich bevorzuge das Falten, weil es den Zugang erleichtert und mir trotzdem eine gewisse Hierarchie bietet, von der ich lernen kann. Faltungsfunktionen und autocmds auf innerster Ebene sind ebenfalls eine gute Idee, da diese "natürliche" logische Einheiten bilden. markerFolding ist für all dies am sinnvollsten, da sich logische Hierarchien nicht unbedingt in Einzugsebenen oder in Syntaxhervorhebungen widerspiegeln. Ich erhöhe auch foldcolumn, was mir einen visuellen Hinweis gibt, wo ich bin:

# vim: filetype=vim foldmethod=marker foldlevel=0 foldcolumn=3

foldtextNebenbei bemerkt, diese Funktion (eine Modifikation einer ähnlichen Funktion von Drew Neil, IIRC) ist für mich sinnvoller als die Standardfunktion:

function! MyFoldText()
    let line = getline(v:foldstart)

    let nucolwidth = &foldcolumn + &number * &numberwidth
    let windowwidth = winwidth(0) - nucolwidth - 3
    let foldedlinecount = v:foldend - v:foldstart

    " expand tabs into spaces
    let chunks = split(line, "\t", 1)
    let line = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - strwidth(v:val) % &tabstop)'), '') . chunks[-1]

    let line = strpart(line, 0, windowwidth - 2 - len(foldedlinecount))
    let fillcharcount = windowwidth - len(line) - len(foldedlinecount) - 1
    return line . '...' . repeat(' ', fillcharcount) . foldedlinecount . ' '
endfunction
set foldtext=MyFoldText()

Bei der anderen Methode besteht das Hauptproblem beim Teilen von Dateien darin, Dinge zu finden und von einer Datei zur anderen zu wechseln. Eine sehr gute Möglichkeit, beide zu adressieren, ist die Verwendung eines Plugins wie CtrlSF , CtrlP oder Ähnliches. Aber wahrscheinlich verwenden Sie sowieso schon eine davon.

Grundlegende Best Practices:

• Teilen Sie in Abschnitte:

  • Plugins
  • die Einstellungen
  • Rebinds

• Kommentiere jeden Abschnitt / binde ihn neu

• (sichern Sie Ihr .vimrcoder _vimrcauf Github)

Nur meine persönliche Präferenz. Vielleicht hilft nicht so viel.

Inspiriert von der Antwort von @ PeterRincker , habe ich Folgendes entworfen, um ATX-Header zu verwenden. Fügen Sie es am Ende Ihrer.vimrc

"# Folding

" Fold with ATX style headers - "# is H1, "## is H2, and so on
" vim:fdm=expr:fdl=0
" vim:fde=getline(v\:lnum)=~'^"#'?'>'.(matchend(getline(v\:lnum),'"#*')-1)\:'='

Wenn Sie große Funktionen wie ich haben, können Sie dies verwenden, um Ihre Funktionen zu falten:

fun! MyFoldLevel(linenum)
    if ! exists('w:nextline')
        let w:nextline = 0
        let w:insideafun = 0
    endif

    if w:nextline == 1
        let w:nextline = 0
        let w:insideafun = 0
    endif

    let l:line = getline(a:linenum)

    if l:line =~# '^[[:space:]]*fun'
        let w:insideafun = 1
        return '>1'
    elseif l:line =~# '^[[:space:]]*endf'
        let w:nextline = 1
        return '<1'
    endif

    if w:insideafun == 1
        return 1
    else
        return 0
    endif
endfun

Und füge diese Modeline zu deinem Vimrc hinzu:

" vim:fde=MyFoldLevel(v\:lnum):fdm=expr:

Erweiterung der Idee von @Peter Rincker und @ go2null. Wenn Sie die Falzoptionen nicht in Vim Modeline einstellen möchten. Mit dem folgenden Befehl können Sie die Faltmethode und den Faltausdruck festlegen.

augroup vim_folding
    autocmd!
    autocmd FileType vim set foldmethod=expr foldlevel=0
    " note that double quote in foldexpr has to be escaped with backslash
    autocmd FileType vim set foldexpr=getline(v:lnum)=~'^\"#'?'>'.(matchend(getline(v:lnum),'\"#*')-1):'='
augroup END

Ich habe kleine Änderungen vorgenommen, um die ursprüngliche Antwort so zu gestalten, dass sie als regulärer vim-Befehl funktioniert (kein Escapezeichen, aber doppelte Anführungszeichen müssen maskiert werden).

Wenn Ihnen die lange foldexprZeichenfolge nicht gefällt , können wir eine Funktion dafür definieren:

function! VimFolds(lnum)
    let s:cur_line = getline(a:lnum)

    if s:cur_line =~ '^"#'
        return '>' . (matchend(s:cur_line, '"#*')-1)
    else
        return '='
    endif

endfunction

Ersetzen Sie dann die autocmd-Zeile ungefähr foldexprum

autocmd FileType vim set foldexpr=VimFolds(v:lnum)