¿Existe alguna práctica recomendada para plegar un archivo vimrc?

Recientemente me di cuenta de que vimrcahora tiene más de 400 líneas de largo (lo cual es demasiado, intentaré reducir eso) y para que sea más fácil navegarlo, leerlo y editarlo, decidí investigar el concepto de plegado en vim (que No estaba familiarizado con) .

• Traté de establecer el método de plegado indentpero no me gustó el resultado (fue demasiado desordenado principalmente porque una gran parte de mi vimrcno está realmente sangrado).
• También traté de conjunto foldmethodde expry syntaxpero no era capaz de doblar nada correctamente.
• Aquí el uso diffcomo método de plegado no parece relevante. (O si es así, no entiendo cómo usarlo)
• Así que por ahora estoy usando el markermétodo que no me satisface totalmente debido a los marcadores "{{{y "}}}que encontré "ruidosos" en el archivo.

Por lo tanto, me gustaría saber si hay mejores prácticas o pautas comunes sobre cómo plegar correctamente avimrc .

Nota 1: Como todos sabemos, SO no es un foro y no está hecho para recopilar opiniones personales y eso no es lo que estoy buscando: por supuesto, creo que algunas personas tienen sus preferencias, pero me gustaría saber por qué usar los marcadores (por ejemplo) mejoran la legibilidad más que el uso de sangría.

Nota 2: También mi objetivo principal es vimrcaclararme lo más posible, por lo que si existen otras mejores prácticas para crear una buena vimrcidea, tengo curiosidad al respecto.

Edición 1: debería haber precisado que mi vimrcya está subdividido en secciones (y, a veces, subsección), siendo las principales

• opciones generales
• complementos (que contiene una subsección para cada complemento y su configuración)
• mapeos
• navegación (también contiene subsección)
• color
• etc ...

Y es esta estructura la que me hizo pensar en doblar: siento que poder generar solo la sección que me interesa en cierto momento es algo bastante conveniente.

Edición 2: la respuesta que menciona subdivisiones de vimrcen varios archivos es válida, pero como preferencia personal prefiero usar el plegado porque creo que es más fácil mantener solo un archivo en el repositorio git que contiene mis archivos de puntos. Esa es solo una preferencia personal y soy consciente de que también es posible usar este enfoque, pero preferiría usar el plegado.

Tengo las siguientes modelinas en la parte inferior de mi vimrccopia de Godlygeek, el autor de la tabla :

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

Esto hará que cualquier línea que comience con 2+ sea "un pliegue. Cuanto más ", más profundo es el pliegue. Esto le permite subdividir secciones si lo necesita.

Es una buena idea definir primero sus propias categorías en su .vimrc(como una lista con sublistas y sublistas) y agregar todos sus complementos / configuraciones / funciones a las categorías respectivas. Combinado con plegado personalizado, esto puede funcionar muy bien:

El ejemplo anterior muestra las posibles categorías que considero útiles para estructurar mi .vimrc. Utiliza las siguientes configuraciones de plegado personalizadas:

""""""""""""""""""""""""
"  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

Para definir sus propias categorías y subcategorías, use la siguiente sintaxis:

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

La categoría de nivel superior se puede crear realmente fácil si usa vim-snippets (por ejemplo, con UltiSnips ): solo expanda el fragmento boxo el bboxfragmento proporcionado por vim-snippets (escriba boxo bboxy presione el disparador de expansión).

Para alternar los pliegues abiertos y cerrados aún más rápido presionando el espacio dos veces:

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

De esa manera, tiene un sistema bien estructurado .vimrcque se puede navegar fácilmente.

Uso mi vimrcarchivo primario como un enlace a varios otros archivos categorizados, obteniendo cada uno de ellos a medida que avanza, por ejemplo, las opciones de Vim en un archivo, la configuración del complemento en otro.

"--- 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

Como una respuesta más directa a la pregunta de OP, utilizo el método de marcador, pero hacia el lado derecho con espaciado, y alrededor de más categorías que individuales, en su mayor parte. Sin embargo, hago cada complemento por separado.

Se podría decir que la "mejor práctica" es principalmente una cuestión de opinión, :) pero hay dos enfoques que (1) tienen un sentido obvio y (2) se pueden aplicar a todos los archivos de configuración, no solo a los de Vim: plegado por secciones lógicas y subsecciones (o incluso más profundas, si te sientes valiente), y dividiendo tu configuración en varios archivos más pequeños y :sourceponiéndolos.

Personalmente prefiero doblar porque hace que las cosas sean más fáciles de acceder, a la vez que me da cierta jerarquía para elegir. Plegar funciones autocmdys en los niveles más internos también es una buena idea, ya que estas forman unidades lógicas "naturales". markerel plegado tiene más sentido para todo esto, porque las jerarquías lógicas no se reflejan necesariamente en niveles de sangría o en resaltado de sintaxis. También aumento foldcolumn, lo que me da una pista visual de dónde estoy:

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

En una nota al margen, esta foldtextfunción (una modificación de una función similar por Drew Neil, IIRC) tiene más sentido para mí que el predeterminado:

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()

Con el otro enfoque, dividir archivos, los principales problemas son encontrar cosas y cambiar de un archivo a otro. Una forma muy agradable de abordar ambos es usar un complemento como CtrlSF , CtrlP o similar. Pero probablemente ya estés usando uno de esos de todos modos.

Mejores prácticas básicas:

• Dividir en secciones:

  • Complementos
  • Configuraciones
  • Vuelve a unir

• Comente cada sección / reenlace

• (copia de seguridad de su .vimrco _vimrcen Github)

Solo mi preferencia personal. Aunque quizás no sea de mucha ayuda.

Inspirado por la respuesta de @ PeterRincker, diseñé lo siguiente para usar encabezados de estilo ATX. Agréguelo al final de su.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)\:'='

Si tiene funciones grandes como yo, puede usar esto para plegar sus funciones:

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

Y agregue esta línea de modelo a su vimrc:

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

Ampliando la idea de @Peter Rincker y @ go2null. Si no desea establecer las opciones de plegado en la línea de modo Vim. Puede usar el siguiente autocmd para establecer el método de plegado y la expresión de plegado.

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

Hice pequeñas modificaciones para hacer la respuesta original para que funcione como comando vim regular (no es necesario escapar de los dos puntos, pero se debe escapar la comilla doble).

Si no le gusta la foldexprcadena larga , podemos definir una función para eso:

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

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

endfunction

Luego reemplace la línea de autocmd a punto foldexprde

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