Bir vimrc dosyasını katlamak için en iyi yöntem var mı

Kısa süre önce vimrc400 satırdan daha uzun olduğumu anladım (ki bu IMO çok düşürmeye çalışacağım) ve gezinmeyi, okumayı ve düzenlemeyi kolaylaştırmak için vim'de katlama kavramını araştırmaya karar verdim (ki Ben aşina değildim) .

• Katlama yöntemini ayarlamaya çalıştım indentama sonucu beğenmedim (çoğunlukla çok dağınıktı çünkü benim büyük bir kısmı vimrcgerçekten girintili değildi).
• Ayrıca sette çalıştım foldmethodetmek exprve syntaxama düzgün bir şey katlamak mümkün değildi.
• Burada diffkatlama yöntemi olarak kullanmak önemli görünmüyor. (Ya da eğer nasıl kullanılacağını anlamadım)
• Şimdilik dosyada "gürültülü" bulduğum ve işaretleyicilerimden markerdolayı beni tamamen tatmin etmeyen bir yöntem kullanıyorum ."{{{"}}}

Bu yüzden, düzgün bir şekilde katlanmayla ilgili en iyi uygulamalar veya ortak kurallar olup olmadığını bilmek istiyorumvimrc .

Not 1: Hepimizin bildiği gibi SO bir forum değil ve kişisel görüşler toplamak için yapılmadı ve aradığım şey bu değil: elbette bazı insanların tercihleri ​​var sanırım ama neden kullandığını bilmek istiyorum İşaretçiler (örneğin) okunabilirliği girinti kullanmaktan daha fazla geliştirir.

Not 2: Asıl amacım, vimrcmümkün olduğu kadar açık olmamı sağlamaktır, bu yüzden başka iyi uygulamalar varsa, vimrcmerak ediyorum güzel bir şeyler yaratır .

Düzenleme 1: Önceden söylemeliydim ki vimrc, ana bölümler zaten alt bölümlere (ve bazen de alt bölümlere) ayrılmıştı.

• Genel seçenekler
• eklentiler (her eklenti ve yapılandırması için bir alt bölüm içeren)
• eşleştirmeleri
• navigasyon (ayrıca alt bölüm içeren)
• renk
• vb...

Ve bu beni katlamayı düşündüren bu yapıydı: Sadece ilgilendiğim kısmı belli bir noktaya çıkabilmenin oldukça uygun bir şey olduğunu hissediyorum.

Düzenleme 2:vimrc Birkaç dosyadaki alt bölümlerden bahseden cevap geçerlidir, ancak kişisel bir tercih olarak katlama kullanmayı tercih ederim, çünkü nokta dosyalarım içeren git repoda yalnızca bir dosyayı saklamanın daha kolay olduğunu düşünüyorum. Bu sadece kişisel bir tercih ve bu yaklaşımı da kullanmanın mümkün olduğunu biliyorum ama katlamayı kullanmayı tercih ediyorum.

vimrcTabağımın altında, tabuların yazarı olan godlygeek'ten kopyaladığım aşağıdaki modellere sahibim :

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

Bu, 2+ "'s katı ile başlayan herhangi bir satırı yapacaktır . Kapak ne kadar "derinse o kadar derin. Bu, gerekirse bölümleri alt bölmenize izin verir.

Öncelikle kendi kategorilerinizi .vimrc(alt listeler ve alt listeler içeren bir liste gibi) kendi kategorilerinizde tanımlamak ve tüm eklentilerinizi / ayarlarınızı / işlevlerinizi ilgili kategorilere eklemek iyi bir fikirdir . Özelleştirilmiş katlama ile birlikte bu harika çalışabilir:

Yukarıdaki örnekte benim yapmamda yardımcı olabileceğim olası kategoriler gösterilmektedir .vimrc. Aşağıdaki özelleştirilmiş katlama ayarlarını kullanır:

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

Kendi kategorilerinizi ve alt kategorilerinizi tanımlamak için aşağıdaki sözdizimini kullanın:

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

Vim parçacıklarını (örneğin UltiSnips ile ) kullanırsanız, üst düzey kategori gerçekten kolay bir şekilde oluşturulabilir : Sadece vim parçacıklarının sağladığı boxya da bboxparçacığını genişletin ( genişletme tetiğine basın boxveya bboxbasın).

Kıvrımları açmak için, boşluğa iki kez basarak daha hızlı açıp kapatabilirsiniz:

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

Bu şekilde .vimrckolayca gezinilebilecek iyi bir yapıya sahipsiniz .

Birincilimi vimrc, kategorilere eklenmiş birkaç dosyaya bağlantı olarak kullanıyorum , her birini başından itibaren kaynaklanıyor, örneğin bir dosyadaki Vim seçenekleri, başka bir dosyadaki eklenti ayarları.

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

OP sorusuna daha doğrudan bir cevap olarak, marker yöntemini kullanıyorum, ancak boşluk bırakarak sağ tarafa ve çoğunlukla bireyden daha fazla kategoriye gidiyorum. Yine de her eklentiyi ayrı ayrı yapıyorum.

"En iyi uygulama" nın öncelikli olarak bir fikir meselesi olduğunu söyleyebilirsin, :) ama (1) açık bir anlam ifade eden ve (2) yalnızca Vim'in değil tüm yapılandırma dosyalarına uygulanabileceği iki yaklaşım vardır: mantıksal bölümlerle katlama ve alt bölümler (ya da cesur hissediyorsanız daha da derin) ve :sourceconfig'nizi daha küçük dosyalara bölerek -ing.

Ben şahsen katlanmayı tercih ediyorum çünkü erişimin kolaylaşmasını sağlarken bir yandan da almam gereken bir hiyerarşi veriyor. Katlama fonksiyonları ve autocmden içteki seviyeler de iyi bir fikirdir, çünkü bunlar "doğal" mantıksal birimlerdir. markerkatlama, tüm bunlar için en mantıklı olanıdır, çünkü mantıksal hiyerarşiler zorunlu olarak girinti seviyelerine veya sözdizimi vurgulamasına yansıtılmaz. Ayrıca foldcolumn, nerede olduğumun bana görsel bir ipucu vermesi de artar :

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

Bir yandan, bu foldtextişlev (Drew Neil, IIRC tarafından benzer bir işlevin değiştirilmesi) varsayılandan daha mantıklı geliyor:

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

Diğer yaklaşımla, dosyaları bölme, asıl sorun bir şeyleri bulmak ve bir dosyadan diğerine geçmek. Her ikisine de hitap etmenin çok güzel bir yolu, CtrlSF , CtrlP veya benzeri bir eklenti kullanmaktır . Ama muhtemelen zaten zaten bunlardan birini kullanıyorsunuz.

Temel en iyi uygulamalar:

• Bölümlere ayırın:

  • eklentiler
  • Ayarlar
  • rebinds

• Her bölüme yorum yapın / rebind

• (sizin .vimrcveya _vimrcGithub'a yedekleyin )

Sadece kişisel tercihim. Belki de çok fazla yardım değil.

PeterRincker en @ esinlenerek cevap , ben ATX tarzı başlıklarını kullanmak için aşağıdakileri hazırlanmış. Sonuna ekleyin.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)\:'='

Benim gibi büyük işlevleriniz varsa, işlevlerinizi katlamak için bunu kullanabilirsiniz:

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

Ve bu modelini vimrc'nize ekleyin:

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

@Peter Rincker ve @ go2null fikrini genişletmek. Vim modelinde katlama seçeneklerini ayarlamak istemiyorsanız. Katlama yöntemini ve katlama ifadesini ayarlamak için aşağıdaki autocmd'yi kullanabilirsiniz.

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

Düzenli vim komutu olarak çalışması için orijinal cevabı yapmak için küçük değişiklikler yaptım (iki nokta üstesinden kaçmaya gerek yok, ancak çift alıntı yapılması gerekiyor).

Uzun foldexprdizgiyi beğenmezseniz , bunun için bir işlev tanımlayabiliriz:

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

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

endfunction

Sonra yaklaşık autocmd hattını değiştirmek foldexpriçin

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