new file mode 100644

@@ -0,0 +1,252 @@

+"" Guard

+if exists('g:autoloaded_unobtrusive_folds') || &compatible

+  finish

+endif

+let g:autoloaded_unobtrusive_folds = 1

+

+"" Configuration

+

+""

+" @section Configuration, config

+" Since this method of folding is more involved than the built-in ones it can

+" be slow for very big files. Options are provided to mitigate this.

+

+""" g:unobtrusive_fold_max_lines

+if !exists('g:unobtrusive_fold_max_lines')

+  ""

+  " Set to non-zero value to make the commands below do nothing if the number

+  " of lines in the current buffer is higher than the given value. Defaults to

+  " 0.

+  let g:unobtrusive_fold_max_lines = 0

+endif

+

+""" g:unobtrusive_fold_max_prevlines

+if !exists('g:unobtrusive_fold_max_prevlines')

+  ""

+  " Set to non-zero value to look at at most this many previous lines when

+  " calculating folds. Defaults to 0.

+  let g:unobtrusive_fold_max_prevlines = 0

+endif

+

+"" Constants

+

+let s:pattern_prefix = '\V\c\^\s\*'

+

+"" Functions

+

+""" #text()

+

+""

+" @public

+" Set 'foldtext' to this function to get an improved version of

+" `getline(v:foldstart)`. Leading tabs are expanded to 'tabstop' spaces. If

+" 'fillchars' `fold:` is not space, the number of lines included in the fold is

+" printed, padded with `fold:` so that it lines up with one column short of the

+" right edge of the window, or 'textwidth' (if not 0), whichever is smaller.

+" The empty column at the far right is nice for people who set 'colorcolumn' to

+" `+1`. The rest of the line is cleared (i.e. not filled automatically by Vim

+" with 'fillchars' `fold:`). A good value for `fold:` might be the box drawing

+" character `─`.

+function! unobtrusive_fold#text() abort

+  let line = getline(v:foldstart)

+  let line = substitute(line, '\t', repeat(' ', &l:tabstop), 'g')

+  let fillchar = matchstr(&fillchars, '.*\(^\|,\)fold:\zs.\ze')

+  if empty(fillchar)

+    let fillchar = '-'

+  endif

+  if fillchar !=# ' '

+    let foldlines = v:foldend - v:foldstart + 1

+    let signs = len(split(execute('sign place buffer=' . bufnr()), '\n')) - 1

+    let numbers = &l:number ? line('$') : &l:relativenumber ? winheight(0) : 0

+    let winwidth = winwidth(0)

+    \ - &l:foldcolumn

+    \ - (signs && &l:signcolumn ==# 'auto' || &l:signcolumn ==# 'yes' ? 2 : 0)

+    \ - (numbers ? max([&l:numberwidth, strlen(numbers) + 1]) : 0)

+    let width = winwidth - 1

+    if &l:textwidth

+      let width = min([width, &l:textwidth])

+    endif

+    let fill = repeat(fillchar, width - strlen(line) - strlen(foldlines) - 2)

+    let pad = repeat(' ', winwidth - width)

+    let line = line . ' ' . fill . ' ' . foldlines . pad

+  endif

+  return line

+endfunction

+

+""" #comment()

+

+function! unobtrusive_fold#comment(bang) abort

+  if empty(&l:commentstring)

+    return

+  endif

+  let commentstart = escape(split(&l:commentstring, '\s*%s')[0], '\')

+  let commentlast  = escape(commentstart[-1:],                   '\')

+  call unobtrusive_fold#set(

+  \   a:bang,

+  \   commentstart . '\zs' . commentlast . '\+\ze',

+  \   commentstart,

+  \   []

+  \ )

+endfunction

+

+""" #char()

+

+function! unobtrusive_fold#char(bang, char) abort

+  let char = escape(a:char, '\')

+  call unobtrusive_fold#set(

+  \   a:bang,

+  \   '\zs' . char . '\+\ze',

+  \   '',

+  \   ['Comment', 'Code', 'Snippet']

+  \ )

+endfunction

+

+""" #set()

+

+function! unobtrusive_fold#set(bang, pattern, commentstart, ignore) abort

+  if g:unobtrusive_fold_max_lines && line('$') > g:unobtrusive_fold_max_lines

+    return

+  endif

+  let w:unobtrusive_fold_indent       = !empty(a:bang)

+  let w:unobtrusive_fold_pattern      = a:pattern . '\s\*\S'

+  let w:unobtrusive_fold_ignore       = a:ignore

+  let w:unobtrusive_fold_commentstart = a:commentstart

+  let &l:foldexpr   = 'unobtrusive_fold#expr()'

+  let &l:foldmethod = 'expr'

+endfunction

+

+""" s:foldlevel()

+

+function! s:foldlevel(lnum) abort

+  let foldlevel = strlen(matchstr(

+  \   getline(a:lnum),

+  \   s:pattern_prefix . w:unobtrusive_fold_pattern

+  \ ))

+  if foldlevel && !empty(w:unobtrusive_fold_ignore)

+    for syntax in map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")')

+      for ignore in w:unobtrusive_fold_ignore

+        if syntax =~# '\v' . '(^|[a-z])' . ignore . '([A-Z]|$)'

+          return 0

+        endif

+      endfor

+    endfor

+  endif

+  return foldlevel

+endfunction

+

+""" s:indent()

+

+function! s:indent(lnum, ...) abort

+  if (a:lnum < 1 && line('$') < a:lnum) || (a:0 && s:foldlevel(a:lnum))

+    return 0

+  endif

+  return !empty(getline(a:lnum)) + indent(a:lnum) / shiftwidth()

+endfunction

+

+""" s:prevfoldlevelbase()

+

+function! s:prevfoldlevelbase(lnum) abort

+  let stopline = g:unobtrusive_fold_max_prevlines

+  \ ? max(1, a:lnum - g:unobtrusive_fold_max_prevlines)

+  \ : 0

+  let pattern_column = '\%<' . (indent(a:lnum) + 2) . 'v'

+  let pos = getpos('.')

+  call cursor(a:lnum, 1)

+  let prev = search(

+  \   s:pattern_prefix . pattern_column . w:unobtrusive_fold_pattern,

+  \   'bW',

+  \   stopline

+  \ )

+  call setpos('.', pos)

+  if !prev

+    return [0, 0]

+  endif

+  let foldlevel = s:foldlevel(prev)

+  return [foldlevel, foldlevel - indent(prev) / shiftwidth()]

+endfunction

+

+""" s:nextnonblank()

+

+function! s:nextnonblank(lnum)

+  if empty(w:unobtrusive_fold_commentstart)

+    return nextnonblank(a:lnum)

+  endif

+  let pos = getpos('.')

+  call cursor(a:lnum, 1)

+  let next = search(

+  \   '\V\^\(' . w:unobtrusive_fold_commentstart . '\[[:punct:]]\*\$\)\@!\.',

+  \   'Wc'

+  \ )

+  call setpos('.', pos)

+  return next

+endfunction

+

+""" #expr()

+

+function! unobtrusive_fold#expr() abort

+  """" Empty line

+  if empty(getline(v:lnum))

+    return '='

+  endif

+  """" Marker...

+  """" ...start

+  let foldlevel = s:foldlevel(v:lnum)

+  if foldlevel

+    return '>' . foldlevel

+  endif

+  """" ...end...

+  let next = s:nextnonblank(v:lnum + 1)

+  """" ...foldlevel

+  let nextfoldlevel = s:foldlevel(next)

+  if nextfoldlevel

+    let prevfoldlevel = s:prevfoldlevelbase(v:lnum)[0]

+    return '<' . (min([nextfoldlevel, prevfoldlevel]) + 1)

+  endif

+  """" ...indent

+  if indent(next) < indent(v:lnum)

+    let prevfoldlevel = s:prevfoldlevelbase(v:lnum)[0]

+    let nextfoldlevel = s:prevfoldlevelbase(next)[0]

+    if nextfoldlevel < prevfoldlevel

+      return '<' . (nextfoldlevel + 1)

+    endif

+  endif

+  """" Indent...

+  if w:unobtrusive_fold_indent

+    let indent      = s:indent(v:lnum)

+    let nextindent  = s:indent(next)

+    let aboveindent = s:indent(v:lnum - 1, 1)

+    let belowindent = s:indent(v:lnum + 1, 1)

+    """" ...start

+    if aboveindent < indent && (belowindent >= indent || nextindent > indent)

+      let prevbase = s:prevfoldlevelbase(v:lnum)[1]

+      return '>' . (prevbase + indent)

+    endif

+    """" ...end

+    if belowindent < indent && (aboveindent || belowindent)

+      let prevbase = s:prevfoldlevelbase(v:lnum)[1]

+      return '<' . (prevbase + min([indent, nextindent + !!belowindent]))

+    endif

+  endif

+  """" No change

+  return '='

+endfunction

+

+""" #debug()

+

+function! unobtrusive_fold#debug() abort

+  let lines  = range(1, line('$'))

+  let exprs  = map(copy(lines), 'execute("let v:lnum=v:val|echon ".&foldexpr)')

+  for l in lines

+    let e = exprs[l-1]

+    if len(e) == 1

+      let exprs[l-1] = e =~# '^[0-9]$' ? ' '.e : e.' '

+    endif

+  endfor

+  let levels = map(copy(lines), 'foldlevel(v:val)')

+  let debugs = map(copy(lines), '"[".exprs[v:val-1]."|".levels[v:val-1]."]"')

+

+  let pos = getpos('.')

+  call setreg('"', join(debugs, "\n"), 'b')

+  normal! gg0""P

+  call setpos('.', pos)

+endfunction