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

21

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.

statox
quelle
Ich denke, die Verwendung von "{{{ist die "vim like"
-Methode

Antworten:

22

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.

Peter Rincker
quelle
Ich kann es momentan nicht testen, aber das scheint mir eine ideale Lösung zu sein! Danke für das Teilen!
statox
Einige erklären: getline (v: lnum) gibt den String der durch die Zeilennummer (v: lnum) gegebenen Zeile zurück; = ~ bedeutet Übereinstimmung mit regulären Ausdrücken; '^ ""' bedeutet, dass alle Zeilen mit zwei "s beginnen; matchend (getline (v: lnum), '" *') - 2 zählt die zusätzliche Zahl von ", das heißt," "" wird mit Stufe 1 gefaltet. " "" wird mit Level 2 und so weiter klappen; getline (v: lnum) = ~ '^ "" gibt wahr oder falsch zurück, je nachdem, ob die v: lnum-Zeile mit zwei beginnt "" oder nicht; Wenn true, wird fde auf >extra number of "( Startlevel, das durch die Zahl nach <in dieser Zeile festgelegt wird) oder '='(Level der vorherigen Zeile verwenden) gesetzt. Die Bedeutung ist zu finden unterfold-expr
van abel
nach dem letzten vim update 8.1.1517) "" erhalte ich einen fehler bei der verarbeitung von modelines "mit dieser konfiguration.
apollo
9

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:

Beispiel

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.

cbaumhardt
quelle
+1 für das nette animierte GIF :) Nur neugierig, was hast du verwendet, um die eingegebenen Tasten anzuzeigen?
MMontu
@mMontu: Ich habe screenkey verwendet, um die Schlüssel anzuzeigen, und gtk-recordmydesktop, um sie aufzuzeichnen (beide in Debian-Repos). Mit 5fps sind 45 Sekunden weniger Clips als eine MiB. Dann konvertierte es online in ein GIF (dort kamen die Verzerrungen, bevor die Bildqualität perfekt war).
Cbaumhardt
7

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.

Kometengesang
quelle
Ich habe vergessen, dies in meiner Frage zu präzisieren: Ich bin kein Fan davon, vimrcin verschiedenen Dateien zu "trennen" , weil (IMO) dies die Komplexität erhöht und die Wartung erschwert. Was meinen Sie mit "mit Abstand zur rechten Seite"?
statox
Ich meine, " {{{mit so vielen Leerzeichen wie Ihrem, textwidthso dass die Markierungen in der Nähe der rechten Ränder sind. Ich habe auch eine personalisierte FoldText-Funktion in der Datei folding.vim. Ich bevorzuge separate Dateien, damit mein Git nur eine bestimmte Art von Mod pro Commit repo.
Cometsong
7

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.

lcd047
quelle
Also gehst du mit marker. In der Tat ist das Anpassen foldcolumneine nette Sache, ich werde sehen, welcher Wert am besten zu meinem Bedarf passt. Ich teile auch Ihre Meinung zu den geteilten Dateien, aber ich wusste nicht, dass CtrlSFich es mir ansehen werde, auch wenn ich ziemlich zufrieden bin CtrlP.
statox
Können Sie uns auch erklären, wie Sie die benutzerdefinierte Falzmethode anwenden können? Ich habe versucht , setzen fdmauf foldtextund MyFoldText()aber es scheint , als ob es nicht der richtige Weg , es zu benutzen.
statox
@statox CtrlSFfunktioniert am besten mit ag oder ack , bei denen es sich im Wesentlichen um spezialisierte Versionen von handelt grep. foldtextist keine benutzerdefinierte Faltmethode, sondern eine Funktion zum Ändern des Aussehens von gefaltetem Text. Die letzte Zeile in meinem Code - Schnipsel zeigt , wie es verwendet wird : set foldtext=MyFoldText().
lcd047
2

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.

Gustav Blomqvist
quelle
Ich persönlich benutze kein Falzen, und das solltest du auch nicht müssen. Organisieren Sie einfach Ihre vimrc und es sollte alles gut sein.
Gustav Blomqvist
Mein vimrc ist bereits in Abschnitte unterteilt (allgemeine Optionen, Plugins, Zuordnungen, Navigation, Farbe usw.). Die Tatsache, dass Sie einen Abschnitt (oder Unterabschnitt) falten können, ist eigentlich gut, um sich auf das zu konzentrieren, was Sie bearbeiten / suchen.
statox
Okay. Entschuldigung für die schlechte Antwort.
Gustav Blomqvist
Das ist keine schlechte Antwort , und ich bin auch schuldig , nicht detailliert genug Frage geben, keine Notwendigkeit zu bereuen ;-)
Statox
2

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)\:'='
go2null
quelle
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:
MichalH
quelle
0

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)
jdhao
quelle