neosnippet.vim/autoload/neosnippet/parser.vim

"=============================================================================
" FILE: parser.vim
" AUTHOR:  Shougo Matsushita <Shougo.Matsu at gmail.com>
" License: MIT license
"=============================================================================

let s:Cache = neosnippet#util#get_vital().import('System.Cache.Deprecated')

function! neosnippet#parser#_parse_snippets(filename) abort
  if !filereadable(a:filename)
    call neosnippet#util#print_error(
          \ printf('snippet file "%s" is not found.', a:filename))
    return {}
  endif

  if neosnippet#util#is_sudo()
    return s:parse(a:filename)[0]
  endif

  let cache_dir = neosnippet#variables#data_dir()
  let snippets = {}
  if !s:Cache.check_old_cache(cache_dir, a:filename)
    try
      let snippets = neosnippet#helpers#json2vim(
            \ s:Cache.readfile(cache_dir, a:filename)[0])
    catch
    endtry
  endif
  if empty(snippets) || s:Cache.check_old_cache(cache_dir, a:filename)
    let [snippets, sourced] = s:parse(a:filename)
    if len(snippets) > 5 && !sourced
      call s:Cache.writefile(
            \ cache_dir, a:filename,
            \ [neosnippet#helpers#vim2json(snippets)])
    endif
  endif

  return snippets
endfunction
function! neosnippet#parser#_parse_snippet(filename, trigger) abort
  if !filereadable(a:filename)
    call neosnippet#util#print_error(
          \ printf('snippet file "%s" is not found.', a:filename))
    return {}
  endif

  let snippet_dict = {
        \ 'word' : join(readfile(a:filename), "\n\t"),
        \ 'name' : a:trigger,
        \ 'options' : neosnippet#parser#_initialize_snippet_options()
        \ }

  return neosnippet#parser#_initialize_snippet(
        \ snippet_dict, a:filename, 1, '', a:trigger)
endfunction

function! s:parse(snippets_file) abort
  let dup_check = {}
  let snippet_dict = {}
  let linenr = 1
  let snippets = {}
  let sourced = 0

  for line in readfile(a:snippets_file)
    if line =~ '^\h\w*.*\s$'
      " Delete spaces.
      let line = substitute(line, '\s\+$', '', '')
    endif

    if line =~ '^#'
      " Ignore.
    elseif line =~ '^include'
      " Include snippets file.
      let snippets = extend(snippets, s:include_snippets(
            \ [matchstr(line, '^include\s\+\zs.*$')]))
    elseif line =~ '^extends'
      " Extend snippets files.
      let fts = split(matchstr(line, '^extends\s\+\zs.*$'), '\s*,\s*')
      for ft in fts
        let snippets = extend(snippets, s:include_snippets(
              \ [ft.'.snip', ft.'.snippets', ft.'/*']))
      endfor
    elseif line =~ '^source'
      " Source Vim script file.
      for file in split(globpath(join(
            \ neosnippet#helpers#get_snippets_directory(), ','),
            \ matchstr(line, '^source\s\+\zs.*$')), '\n')
        execute 'source' fnameescape(file)
        let sourced = 1
      endfor
    elseif line =~ '^delete\s'
      let name = matchstr(line, '^delete\s\+\zs.*$')
      if name != '' && has_key(snippets, name)
        call filter(snippets, 'v:val.real_name !=# name')
      endif
    elseif line =~ '^snippet\s'
      if !empty(snippet_dict)
        " Set previous snippet.
        call s:set_snippet_dict(snippet_dict,
              \ snippets, dup_check, a:snippets_file)
      endif

      let snippet_dict = s:parse_snippet_name(
            \ a:snippets_file, line, linenr, dup_check)
    elseif !empty(snippet_dict)
      if line =~ '^\s' || line == ''
        if snippet_dict.word == ''
          " Substitute head tab character.
          let line = substitute(line, '^\t', '', '')
        endif

        let snippet_dict.word .=
              \ substitute(line, '^ *', '', '') . "\n"
      else
        call s:add_snippet_attribute(
              \ a:snippets_file, line, linenr, snippet_dict)
      endif
    endif

    let linenr += 1
  endfor

  if !empty(snippet_dict)
    " Set previous snippet.
    call s:set_snippet_dict(snippet_dict,
          \ snippets, dup_check, a:snippets_file)
  endif

  return [snippets, sourced]
endfunction

function! s:parse_snippet_name(snippets_file, line, linenr, dup_check) abort
  " Initialize snippet dict.
  let snippet_dict = {
        \ 'word' : '',
        \ 'linenr' : a:linenr,
        \ 'options' : neosnippet#parser#_initialize_snippet_options()
        \ }

  " Try using the name without the description (abbr).
  let snippet_dict.name = matchstr(a:line, '^snippet\s\+\zs\S\+')

  " Fall back to using the name and description (abbr) combined.
  " SnipMate snippets may have duplicate names, but different
  " descriptions (abbrs).
  let description = matchstr(a:line, '^snippet\s\+\S\+\s\+\zs.*$')
  if g:neosnippet#enable_snipmate_compatibility
        \ && description != '' && description !=# snippet_dict.name
    " Convert description.
    let snippet_dict.name .= '_' .
          \ substitute(substitute(
          \    substitute(description, '\a\zs\a\+', '', 'g'),
          \ '\W\+', '_', 'g'), '_\+$', '', '')
  endif

  " Collect the description (abbr) of the snippet, if set on snippet line.
  " This is for compatibility with SnipMate-style snippets.
  let snippet_dict.abbr = matchstr(a:line,
        \ '^snippet\s\+\S\+\s\+\zs.*$')

  " Check for duplicated names.
  if has_key(a:dup_check, snippet_dict.name)
    let dup = a:dup_check[snippet_dict.name]
    call neosnippet#util#print_error(printf(
          \ '%s:%d is overriding `%s` from %s:%d',
          \ a:snippets_file, a:linenr, snippet_dict.name,
          \ dup.action__path, dup.action__line))
    call neosnippet#util#print_error(printf(
          \ 'Please rename the snippet name or use `delete %s`.',
          \ snippet_dict.name))
  endif

  return snippet_dict
endfunction

function! s:add_snippet_attribute(snippets_file, line, linenr, snippet_dict) abort
  " Allow overriding/setting of the description (abbr) of the snippet.
  " This will override what was set via the snippet line.
  if a:line =~ '^abbr\s'
    let a:snippet_dict.abbr = matchstr(a:line, '^abbr\s\+\zs.*$')
  elseif a:line =~ '^alias\s'
    let a:snippet_dict.alias = split(matchstr(a:line,
          \ '^alias\s\+\zs.*$'), '[,[:space:]]\+')
  elseif a:line =~ '^prev_word\s'
    let prev_word = matchstr(a:line,
          \ '^prev_word\s\+[''"]\zs.*\ze[''"]$')
    if prev_word == '^'
      " For backward compatibility.
      let a:snippet_dict.options.head = 1
    else
      call neosnippet#util#print_error(
            \ 'prev_word must be "^" character.')
    endif
  elseif a:line =~ '^regexp\s'
    let a:snippet_dict.regexp = matchstr(a:line,
          \ '^regexp\s\+[''"]\zs.*\ze[''"]$')
  elseif a:line =~ '^options\s\+'
    for option in split(matchstr(a:line,
          \ '^options\s\+\zs.*$'), '[,[:space:]]\+')
      if !has_key(a:snippet_dict.options, option)
        call neosnippet#util#print_error(
              \ printf('%s:%d', a:snippets_file, a:linenr))
        call neosnippet#util#print_error(
              \ printf('Invalid option name : "%s"', option))
      else
        let a:snippet_dict.options[option] = 1
      endif
    endfor
  else
    call neosnippet#util#print_error(
          \ printf('%s:%d', a:snippets_file, a:linenr))
    call neosnippet#util#print_error(
          \ printf('Invalid syntax : "%s"', a:line))
  endif
endfunction

function! s:set_snippet_dict(snippet_dict, snippets, dup_check, snippets_file) abort
  if empty(a:snippet_dict)
    return
  endif

  let action_pattern = '^snippet\s\+' . a:snippet_dict.name . '$'
  let snippet = neosnippet#parser#_initialize_snippet(
        \ a:snippet_dict, a:snippets_file,
        \ a:snippet_dict.linenr, action_pattern,
        \ a:snippet_dict.name)
  let a:snippets[a:snippet_dict.name] = snippet
  let a:dup_check[a:snippet_dict.name] = snippet

  for alias in get(a:snippet_dict, 'alias', [])
    let alias_snippet = copy(snippet)
    let alias_snippet.word = alias

    let a:snippets[alias] = alias_snippet
    let a:dup_check[alias] = alias_snippet
  endfor
endfunction

function! neosnippet#parser#_initialize_snippet(dict, path, line, pattern, name) abort
  let a:dict.word = substitute(a:dict.word, '\n\+$', '', '')
  if a:dict.word !~
        \    neosnippet#get_placeholder_marker_substitute_pattern().'$'
        \ && a:dict.word !~
        \    neosnippet#get_placeholder_marker_substitute_zero_pattern()
    " Add placeholder.
    let a:dict.word .= '${0}'
  endif

  if !has_key(a:dict, 'abbr') || a:dict.abbr == ''
    " Set default abbr.
    let abbr = substitute(a:dict.word,
        \   neosnippet#get_placeholder_marker_pattern(). '\|'.
        \   neosnippet#get_mirror_placeholder_marker_pattern().
        \   '\|\s\+\|\n\|TARGET', ' ', 'g')
    let abbr = substitute(abbr, '\\\(\\\|`\|\$\)', '\1', 'g')
    let a:dict.abbr = a:dict.name
  else
    let abbr = a:dict.abbr
  endif

  let snippet = {
        \ 'word': a:dict.name, 'snip': a:dict.word,
        \ 'description': a:dict.word,
        \ 'menu_template': abbr,
        \ 'menu_abbr': abbr,
        \ 'options': a:dict.options,
        \ 'real_name': a:name,
        \ 'action__path': a:path,
        \ 'action__line': a:line,
        \ 'action__pattern': a:pattern,
        \}

  if exists('*json_encode')
    let snippet.user_data = json_encode({
          \   'snippet': a:dict.word,
          \   'snippet_trigger': a:dict.name
          \ })
  endif

  if has_key(a:dict, 'regexp')
    let snippet.regexp = a:dict.regexp
  endif

  return snippet
endfunction

function! neosnippet#parser#_initialize_snippet_options() abort
  return {
        \ 'head' : 0,
        \ 'word' :
        \   g:neosnippet#expand_word_boundary,
        \ 'indent' : 0,
        \ 'oneshot' : 0,
        \ }
endfunction

function! neosnippet#parser#_get_completed_snippet(completed_item, cur_text, next_text) abort
  let item = a:completed_item

  if strridx(a:cur_text, item.word) != len(a:cur_text) - len(item.word)
    return ''
  endif

  " Set abbr
  let abbrs = []
  if get(item, 'info', '') =~# '^.\+('
    call add(abbrs, matchstr(item.info, '^\_s*\zs.*'))
  endif
  if get(item, 'abbr', '') =~# '^.\+('
    call add(abbrs, item.abbr)
  endif
  if get(item, 'menu', '') =~# '^.\+('
    call add(abbrs, item.menu)
  endif
  if item.word =~# '^.\+(' || get(item, 'kind', '') == 'f'
    call add(abbrs, item.word)
  endif
  call map(abbrs, "escape(v:val, '\')")

  " () Only supported
  let pairs = {'(': ')'}
  let no_key = index(keys(pairs), item.word[-1:]) < 0
  let word_pattern = '\<' . neosnippet#util#escape_pattern(item.word)
  let angle_pattern = word_pattern . '<.\+>(.*)'
  let check_pattern = word_pattern . '\%(<.\+>\)\?(.*)'
  let abbrs = filter(abbrs, '!no_key || v:val =~# check_pattern')

  if empty(abbrs)
    return ''
  endif
  let abbr = abbrs[0]

  let key = no_key ? '(' : item.word[-1:]
  if a:next_text[:0] ==# key
    " Disable auto pair
    return ''
  endif

  let pair = pairs[key]

  " Make snippet arguments
  let cnt = 1
  let snippet = ''

  if no_key && abbr !~# angle_pattern
    " Auto key
    let snippet .= key
  endif

  if empty(filter(values(pairs), 'stridx(abbr, v:val) > 0'))
    " Pairs not found pattern
    let snippet .= '${' . cnt . '}'
    let cnt += 1
  endif

  if abbr =~# angle_pattern
    " Add angle analysis
    let snippet .= '<'

    let args = ''
    for arg in split(substitute(
          \ neosnippet#parser#_get_in_paren('<', '>', abbr),
          \ '<\zs.\{-}\ze>', '', 'g'), '[^[]\zs\s*,\s*')
      let args .= neosnippet#parser#_conceal_argument(arg, cnt, args)
      let cnt += 1
    endfor
    let snippet .= args
    let snippet .= '>'

    if no_key
      let snippet .= key
    endif
  endif

  let args = ''
  for arg in split(substitute(
        \ neosnippet#parser#_get_in_paren(key, pair, abbr),
        \ key.'\zs.\{-}\ze'.pair . '\|<\zs.\{-}\ze>', '', 'g'),
        \ '[^[]\zs\s*,\s*')
    if key ==# '(' && (
          \ (&filetype ==# 'python' && arg ==# 'self') ||
          \ (&filetype ==# 'rust' && arg =~# '\m^&\?\(mut \)\?self$'))
      " Ignore self argument
      continue
    endif

    let args .= neosnippet#parser#_conceal_argument(arg, cnt, args)
    let cnt += 1
  endfor
  let snippet .= args

  if key != '(' && snippet == ''
    let snippet .= '${' . cnt . '}'
    let cnt += 1
  endif

  let snippet .= pair
  let snippet .= '${' . cnt . '}'

  return snippet
endfunction

function! neosnippet#parser#_get_in_paren(key, pair, str) abort
  let s = ''
  let level = 0
  for c in split(a:str, '\zs')
    if c ==# a:key
      let level += 1

      if level == 1
        continue
      endif
    elseif c ==# a:pair
      if level == 1 && (s != '' || a:str =~ '()\s*(.\{-})')
        return s
      else
        let level -= 1
      endif
    endif

    if level > 0
      let s .= c
    endif
  endfor

  return ''
endfunction

function! neosnippet#parser#_conceal_argument(arg, cnt, args) abort
  let outside = ''
  let inside = ''
  if a:args != ''
    if g:neosnippet#enable_optional_arguments
      let inside = ', '
    else
      let outside = ', '
    endif
  endif
  return printf('%s${%d:#:%s%s}', outside, a:cnt, inside, escape(a:arg, '{}'))
endfunction

function! s:include_snippets(globs) abort
  let snippets = {}
  for glob in a:globs
      for file in split(globpath(join(
            \ neosnippet#helpers#get_snippets_directory(), ','), glob), '\n')
        call extend(snippets, neosnippet#parser#_parse_snippets(file))
      endfor
  endfor

  return snippets
endfunction