Merge branch 'release-3.0.0'

Author: kopischke

autoload/fetch.vim

@@ -10,7 +10,6 @@ set cpoptions&vim
 let s:specs = {}
 
 " - trailing colon, i.e. ':lnum[:colnum[:]]'
-"   trigger with '?*:[0123456789]*' pattern
 let s:specs.colon = {'pattern': '\m\%(:\d\+\)\{1,2}:\?'}
 function! s:specs.colon.parse(file) abort
   let l:file = substitute(a:file, self.pattern, '', '')
@@ -19,7 +18,6 @@ function! s:specs.colon.parse(file) abort
 endfunction
 
 " - trailing parentheses, i.e. '(lnum[:colnum])'
-"   trigger with '?*([0123456789]*)' pattern
 let s:specs.paren = {'pattern': '\m(\(\d\+\%(:\d\+\)\?\))'}
 function! s:specs.paren.parse(file) abort
   let l:file = substitute(a:file, self.pattern, '', '')
@@ -28,16 +26,14 @@ function! s:specs.paren.parse(file) abort
 endfunction
 
 " - Plan 9 type line spec, i.e. '[:]#lnum'
-"   trigger with '?*#[0123456789]*' pattern
 let s:specs.plan9 = {'pattern': '\m:#\(\d\+\)'}
 function! s:specs.plan9.parse(file) abort
   let l:file = substitute(a:file, self.pattern, '', '')
   let l:pos  = matchlist(a:file, self.pattern)[1]
   return [l:file, ['cursor', [l:pos, 0]]]
 endfunction
 
-" - Pytest type method spec, i.e. ::method
-"   trigger with '?*::?*' pattern
+" - Pytest type method spec, i.e. '::method'
 let s:specs.pytest = {'pattern': '\m::\(\w\+\)'}
 function! s:specs.pytest.parse(file) abort
   let l:file   = substitute(a:file, self.pattern, '', '')
@@ -84,140 +80,174 @@ endfunction " }}}
 "                and returning a List of
 "                0 unspec'ed path String
 "                1 position setting |call()| arguments List
-" @notes:      the autocommand match patterns are not included
 function! fetch#specs() abort " {{{
   return deepcopy(s:specs)
 endfunction " }}}
 
-" Resolve {spec} for the current buffer, substituting the resolved
-" file (if any) for it, with the cursor placed at the resolved position:
+" Resolve the buffer {bufname}, substituting the resolved file (if any) for
+" it, with the cursor placed at the resolved position:
 " @signature:  fetch#buffer({spec:String})
 " @returns:    Boolean
-function! fetch#buffer(spec) abort " {{{
-  let l:bufname = expand('%')
-  let l:spec    = s:specs[a:spec]
+" @note:       only buffers visible in the current tab page are resolved
+" @vimlint(EVL103, 1, a:bufname)
+function! fetch#buffer(bufname) abort " ({{{
+  " no need for switching if the buffer is not on display
+  let l:bufwinnr = bufwinnr(a:bufname)
+  if l:bufwinnr is -1 | return 0 | endif
 
-  " exclude obvious non-matches
-  if matchend(l:bufname, l:spec.pattern) isnot len(l:bufname)
-    return 0
-  endif
+  " check for a matching spec, return if none matches
+  for l:spec in values(s:specs)
+    if matchend(a:bufname, l:spec.pattern) is len(a:bufname)
+      break
+    endif
+    unlet! l:spec
+  endfor
+  " @vimlint(EVL104, 1, l:spec)
+  if exists('l:spec') isnot 1 | return 0 | endif
 
   " only substitute if we have a valid resolved file
-  " and a spurious unresolved buffer both
-  let [l:file, l:jump] = l:spec.parse(l:bufname)
-  if !filereadable(l:file) || s:bufignore.detect(bufnr('%')) is 1
+  " and a bona fide spurious unresolved buffer both
+  let [l:file, l:jump] = l:spec.parse(a:bufname)
+  if !filereadable(l:file) || s:bufignore.detect(bufnr(a:bufname)) is 1
     return 0
   endif
 
-  " we have a spurious unresolved buffer: set up for wiping
-  set buftype=nowrite       " avoid issues voiding the buffer
-  set bufhidden=wipe        " avoid issues with |bwipeout|
+  " activate the correct window (if needed)
+  let l:oldwinnr = s:gotowin(l:bufwinnr)
 
-  " substitute resolved file for unresolved buffer on arglist
-  if has('listcmds')
-    let l:argidx = index(argv(), l:bufname)
-    if  l:argidx isnot -1
-      execute 'argdelete' fnameescape(l:bufname)
-      execute l:argidx.'argadd' fnameescape(l:file)
+  try
+    " we have a spurious unresolved buffer: set up for wiping
+    set buftype=nowrite       " avoid issues voiding the buffer
+    set bufhidden=wipe        " avoid issues with |bwipeout|
+
+    " substitute resolved file for unresolved buffer on arglist
+    let l:argidx = index(argv(), a:bufname)
+    if l:argidx isnot -1
+      if has('listcmds')
+        " execute l:argidx.'argadd' fnameescape(l:file)
+        execute 'argdelete' fnameescape(a:bufname)
+      endif
+      " set arglist index to resolved file if required
+      let l:cmd = l:argidx.'argedit'
     endif
-  endif
 
-  " set arglist index to resolved file if required
-  " (needs to happen independently of arglist switching to work
-  " with the double processing of the first -o/-O/-p window)
-  if index(argv(), l:file) isnot -1
-    let l:cmd = 'argedit'
-  endif
+    " edit resolved file and place cursor at position spec; we need to
+    " suppress regular error handling or files after the offending one will
+    " not be processed in VimEnter
+    let l:shortmess = &shortmess
+    set shortmess+=oO " avoid "Press ENTER" prompt on switch
+    try
+      execute 'keepalt' get(l:, 'cmd', 'edit').v:cmdarg fnameescape(l:file)
+    catch
+      echohl ErrorMsg | echomsg v:errmsg | echohl None
+      if bufname('%') isnot l:file " do not return on unrelated errors
+        return 0
+      endif
+    finally
+      let &shortmess = l:shortmess
+    endtry
+
+    if !empty(v:swapcommand)
+      execute 'normal' v:swapcommand
+    endif
+    return s:setpos(l:jump)
 
-  " edit resolved file and place cursor at position spec
-  let l:shortmess = &shortmess
-  set shortmess+=oO " avoid "Press ENTER" prompt on switch
-  try
-    execute 'keepalt' get(l:, 'cmd', 'edit').v:cmdarg fnameescape(l:file)
   finally
-    let &shortmess = l:shortmess
+    call s:gotowin(l:oldwinnr)
   endtry
-  if !empty(v:swapcommand)
-    execute 'normal' v:swapcommand
-  endif
-  return s:setpos(l:jump)
 endfunction " }}}
+" @vimlint(EVL103, 0, a:bufname)
+" @vimlint(EVL104, 0, l:spec)
 
-" Edit |<cfile>|, resolving a possible trailing spec:
-" @signature:  fetch#cfile({count:Number})
-" @returns:    Boolean
-" @notes:      - will test all available specs for a match
-"              - will fall back on Vim's |gF| when no spec matches
-function! fetch#cfile(count) abort " {{{
-  let l:cfile = expand('<cfile>')
-
-  if !empty(l:cfile)
-    " locate '<cfile>' in current line
-    let l:pattern  = '\M'.escape(l:cfile, '\')
-    let l:position = searchpos(l:pattern, 'bcn', line('.'))
-    if l:position == [0, 0]
-      let l:position = searchpos(l:pattern, 'cn', line('.'))
-    endif
+if has('file_in_path') " {{{
+  " Edit |<cfile>|, resolving a possible trailing spec:
+  " @signature:  fetch#cfile({count:Number})
+  " @returns:    Boolean
+  " @notes:      - will test all available specs for a match
+  "              - will fall back on Vim's |gF| when no spec matches
+  function! fetch#cfile(count) abort " {{{
+    let l:cfile = expand('<cfile>')
 
-    " test for a trailing spec, accounting for multi-line '<cfile>' matches
-    let l:lines  = split(l:cfile, "\n")
-    let l:line   = getline(l:position[0] + len(l:lines) - 1)
-    let l:offset = (len(l:lines) > 1 ? 0 : l:position[1]) + len(l:lines[-1]) - 1
-    for l:spec in values(s:specs)
-      if match(l:line, l:spec.pattern, l:offset) is l:offset
-        let l:match = matchstr(l:line, l:spec.pattern, l:offset)
-        " leverage Vim's own |gf| for opening the file
-        execute 'normal!' a:count.'gf'
-        return s:setpos(l:spec.parse(l:cfile.l:match)[1])
+    if !empty(l:cfile)
+      " locate '<cfile>' in current line
+      let l:pattern  = '\M'.escape(l:cfile, '\')
+      let l:position = searchpos(l:pattern, 'bcn', line('.'))
+      if l:position == [0, 0]
+        let l:position = searchpos(l:pattern, 'cn', line('.'))
       endif
-    endfor
-  endif
 
-  " fall back to Vim's |gF|
-  execute 'normal!' a:count.'gF'
-  return 1
-endfunction " }}}
+      " test for a trailing spec, accounting for multi-line '<cfile>' matches
+      let l:lines  = split(l:cfile, "\n")
+      let l:line   = getline(l:position[0] + len(l:lines) - 1)
+      let l:offset = (len(l:lines) > 1 ? 0 : l:position[1]) + len(l:lines[-1]) - 1
+      for l:spec in values(s:specs)
+        if match(l:line, l:spec.pattern, l:offset) is l:offset
+          let l:match = matchstr(l:line, l:spec.pattern, l:offset)
+          " leverage Vim's own |gf| for opening the file
+          execute 'normal!' a:count.'gf'
+          return s:setpos(l:spec.parse(l:cfile.l:match)[1])
+        endif
+      endfor
+    endif
 
-" Edit the visually selected file, resolving a possible trailing spec:
-" @signature:  fetch#visual({count:Number})
-" @returns:    Boolean
-" @notes:      - will test all available specs for a match
-"              - will fall back on Vim's |gF| when no spec matches
-function! fetch#visual(count) abort " {{{
-  " get text between last visual selection marks
-  " adapted from http://stackoverflow.com/a/6271254/990363
-  let [l:startline, l:startcol] = getpos("'<")[1:2]
-  let [l:endline,   l:endcol]   = getpos("'>")[1:2]
-  let l:endcol  = min([l:endcol, col([l:endline, '$'])]) " 'V' col nr. bug
-  let l:endcol -= &selection is 'inclusive' ? 0 : 1
-  let l:lines   = getline(l:startline, l:endline)
-  if visualmode() isnot? 'v' " block-wise selection
-    let l:endexpr = 'matchstr(v:val, "\\m^.*\\%'.string(l:endcol).'c.\\?")'
-    call map(l:lines, 'strpart('.l:endexpr.', '.string(l:startcol-1).')')
-  else
-    let l:lines[-1] = matchstr(lines[-1], '\m^.*\%'.string(l:endcol).'c.\?')
-    let l:lines[0]  = strpart(l:lines[0], l:startcol-1)
-  endif
-  let l:selection = join(l:lines, "\n")
-
-  " test for a trailing spec
-  if !empty(l:selection)
-    let l:line = getline(l:endline)
-    for l:spec in values(s:specs)
-      if match(l:line, l:spec.pattern, l:endcol) is l:endcol
-        let l:match = matchstr(l:line, l:spec.pattern, l:endcol)
-        call s:dovisual(a:count.'gf') " leverage Vim's |gf| to get the file
-        return s:setpos(l:spec.parse(l:selection.l:match)[1])
+    " fall back to Vim's |gF|
+    execute 'normal!' a:count.'gF'
+    return 1
+  endfunction " }}}
+
+  if has('visual') " {{{
+    " Edit the visually selected file, resolving a possible trailing spec:
+    " @signature:  fetch#visual({count:Number})
+    " @returns:    Boolean
+    " @notes:      - will test all available specs for a match
+    "              - will fall back on Vim's |gF| when no spec matches
+    function! fetch#visual(count) abort " {{{
+      " get text between last visual selection marks
+      " adapted from http://stackoverflow.com/a/6271254/990363
+      let [l:startline, l:startcol] = getpos("'<")[1:2]
+      let [l:endline,   l:endcol]   = getpos("'>")[1:2]
+      let l:endcol  = min([l:endcol, col([l:endline, '$'])]) " 'V' col nr. bug
+      let l:endcol -= &selection is 'inclusive' ? 0 : 1
+      let l:lines   = getline(l:startline, l:endline)
+      if visualmode() isnot? 'v' " block-wise selection
+        let l:endexpr = 'matchstr(v:val, "\\m^.*\\%'.string(l:endcol).'c.\\?")'
+        call map(l:lines, 'strpart('.l:endexpr.', '.string(l:startcol-1).')')
+      else
+        let l:lines[-1] = matchstr(lines[-1], '\m^.*\%'.string(l:endcol).'c.\?')
+        let l:lines[0]  = strpart(l:lines[0], l:startcol-1)
       endif
-    endfor
-  endif
+      let l:selection = join(l:lines, "\n")
 
-  " fall back to Vim's |gF|
-  call s:dovisual(a:count.'gF')
-  return 1
-endfunction " }}}
+      " test for a trailing spec
+      if !empty(l:selection)
+        let l:line = getline(l:endline)
+        for l:spec in values(s:specs)
+          if match(l:line, l:spec.pattern, l:endcol) is l:endcol
+            let l:match = matchstr(l:line, l:spec.pattern, l:endcol)
+            call s:dovisual(a:count.'gf') " leverage Vim's |gf| to get the file
+            return s:setpos(l:spec.parse(l:selection.l:match)[1])
+          endif
+        endfor
+      endif
+
+      " fall back to Vim's |gF|
+      call s:dovisual(a:count.'gF')
+      return 1
+    endfunction " }}}
+  endif " }}}
+endif " }}}
 
 " Private helper functions: {{{
+" - go to window {winnr} without affecting editor state
+"   returns the original window number
+function! s:gotowin(winnr) abort
+  let l:curwinnr = bufwinnr('%')
+  if a:winnr isnot -1 && l:curwinnr isnot a:winnr
+    execute 'silent keepjumps noautocmd '.a:winnr.'wincmd w'
+  endif
+  return l:curwinnr
+endfunction
+
 " - place the current buffer's cursor, triggering the "BufFetchPosX" events
 "   see :h call() for the format of the {calldata} List
 function! s:setpos(calldata) abort
@@ -239,11 +269,13 @@ function! s:doautocmd(pattern) abort
   endif
 endfunction
 
-" - send command to the last visual selection
-function! s:dovisual(command) abort
-  let l:cmd = index(['v', 'V', ''], mode()) is -1 ? 'gv'.a:command : a:command
-  execute 'normal!' l:cmd
-endfunction
+if has('visual')
+  " - send command to the last visual selection
+  function! s:dovisual(command) abort
+    let l:cmd = index(['v', 'V', ''], mode()) is -1 ? 'gv'.a:command : a:command
+    execute 'normal!' l:cmd
+  endfunction
+endif
 " }}}
 
 let &cpoptions = s:cpoptions