243 lines
7.2 KiB
VimL
243 lines
7.2 KiB
VimL
" Query Command Complete
|
|
" ======================
|
|
"
|
|
" Vim plugin to suggest completions with the results of an external
|
|
" query command.
|
|
"
|
|
" The original intention is to use it as a mutt query_command wrapper
|
|
" to complete addresses in the mail headers, but it can be adapted
|
|
" to any other kind of functionality by modifying the exposed setting
|
|
" parameters.
|
|
"
|
|
" Last Change: 2013 Jun 16
|
|
" Author: Caio Romão (http://caioromao.com)
|
|
" License: This file is placed in the public domain
|
|
" Contributors:
|
|
" Brian Henderson https://github.com/bhenderson
|
|
" Mark Stillwell https://github.com/marklee77
|
|
" Rui Abreu Ferreira http://ruiabreu.org
|
|
"
|
|
" Setup:
|
|
" This plugin exports the completion function QueryCommandComplete,
|
|
" which can be set as the complete function (or omni function) for
|
|
" any filetype. If you have a working mutt setup with query_command
|
|
" configured, the plugin works out of the box.
|
|
"
|
|
" Example:
|
|
" let g:qcc_query_command='abook'
|
|
" au BufRead /tmp/mutt* setlocal omnifunc=QueryCommandComplete
|
|
"
|
|
" Settings:
|
|
" Note: Overriding settings on a buffer-basis is supported. So
|
|
" b:qcc_query_command takes precedence over g:qcc_query_command
|
|
"
|
|
" g:qcc_query_command
|
|
" External command that queries for contacts
|
|
" If empty, QueryCommandComplete tries to guess what command to
|
|
" run by executing `mutt -Q query_command`.
|
|
"
|
|
" g:qcc_line_separator
|
|
" Separator for each entry in the result from the query
|
|
" default: '\n'
|
|
"
|
|
" g:qcc_field_separator
|
|
" Separator for the fields of an entry from the result
|
|
" default: '\t'
|
|
"
|
|
" g:qcc_pattern
|
|
" Pattern used to match against the current line to decide
|
|
" whether to call the query command
|
|
" default: '^\(To\|Cc\|Bcc\|From\|Reply-To\):'
|
|
"
|
|
" g:qcc_multiline
|
|
" Whether to try matching g:qcc_pattern against the current
|
|
" and any previous line
|
|
" default: 0
|
|
"
|
|
" g:qcc_multiline_pattern
|
|
" Pattern to match against the current line when deciding
|
|
" wether to keep looking for a line that matches g:qcc_pattern
|
|
" This provides finer control over the recursion, which
|
|
" is useful if calling the completion on really big files.
|
|
" default: '.*'
|
|
"
|
|
" g:qcc_format_word
|
|
" Format string to be used when building the word field
|
|
" of the completion (i.e.: the final result, what gets fed into
|
|
" the current line when you select an option)
|
|
" default: '${1} <${0}>' (as in: FirstName <email@domain.com>)
|
|
"
|
|
" g:qcc_format_abbr
|
|
" Format string to be used when building the abbreviation
|
|
" for the completion menu (i.e.: the first row in the completion
|
|
" menu).
|
|
" default: '${1}'
|
|
"
|
|
" g:qcc_format_menu
|
|
" Format string for the optional second column of the completion
|
|
" menu.
|
|
" default: '${2}'
|
|
"
|
|
|
|
|
|
if exists("g:loaded_QueryCommandComplete") || &cp
|
|
finish
|
|
endif
|
|
|
|
function! s:GetSetting(name)
|
|
let global_option = 'g:qcc_' . a:name
|
|
let local_option = 'b:qcc_' . a:name
|
|
|
|
let result = ''
|
|
if exists(local_option)
|
|
let result = {local_option}
|
|
elseif exists(global_option)
|
|
let result = {global_option}
|
|
endif
|
|
|
|
return result
|
|
endfunction
|
|
|
|
let g:loaded_QueryCommandComplete = 1
|
|
let s:save_cpo = &cpo
|
|
set cpo&vim
|
|
|
|
function! s:DefaultIfUnset(name, default)
|
|
if !exists(a:name)
|
|
let {a:name} = a:default
|
|
endif
|
|
endfunction
|
|
|
|
call s:DefaultIfUnset('g:qcc_line_separator', '\n')
|
|
call s:DefaultIfUnset('g:qcc_field_separator', '\t')
|
|
call s:DefaultIfUnset('g:qcc_pattern', '^\(To\|Cc\|Bcc\|From\|Reply-To\):')
|
|
call s:DefaultIfUnset('g:qcc_multiline', 0)
|
|
call s:DefaultIfUnset('g:qcc_multiline_pattern', '.*')
|
|
call s:DefaultIfUnset('g:qcc_format_word', '${1} <${0}>')
|
|
call s:DefaultIfUnset('g:qcc_format_abbr', '${1} <${0}>')
|
|
call s:DefaultIfUnset('g:qcc_format_menu', '${2}')
|
|
|
|
" Given a format string where the placeholders are in the format
|
|
" '${index}' and index is a valid index the the given 'fields'
|
|
" argument, this function returns a string with all placeholders
|
|
" replaced by the corresponding data in the fields list.
|
|
" FIXME I can't help but think there's a standard way to do this
|
|
" but I failed finding it. Please call me a dumbass if you
|
|
" know The Easy Way.
|
|
function! s:ApplyFieldsToFormatString(fields, format)
|
|
let result = a:format
|
|
|
|
while 1
|
|
let placeholder = matchstr(result, '${[0-9]}')
|
|
|
|
if (empty(placeholder))
|
|
break
|
|
endif
|
|
|
|
let index = matchstr(placeholder, '[0-9]')
|
|
|
|
" If ${NUMBER} is not a valid index in a:fields,
|
|
" use '' as a fallback.
|
|
" FIXME Decide whether to warn/err/whatever here
|
|
let content = ''
|
|
if (len(a:fields) > index)
|
|
let content = a:fields[index]
|
|
endif
|
|
|
|
let result = substitute(result, placeholder, content, 'g')
|
|
|
|
endwhile
|
|
|
|
return result
|
|
endfunction
|
|
|
|
function! s:MakeCompletionEntry(fields)
|
|
let entry = {}
|
|
let entry.word = s:ApplyFieldsToFormatString(a:fields, s:GetSetting('format_word'))
|
|
let entry.abbr = s:ApplyFieldsToFormatString(a:fields, s:GetSetting('format_abbr'))
|
|
let entry.menu = s:ApplyFieldsToFormatString(a:fields, s:GetSetting('format_menu'))
|
|
let entry.icase = 1
|
|
return entry
|
|
endfunction
|
|
|
|
function! s:FindStartingIndex()
|
|
let cur_line = getline('.')
|
|
|
|
" locate the start of the word
|
|
let start = col('.') - 1
|
|
while start > 0 && cur_line[start - 1] =~ '[^:,]'
|
|
let start -= 1
|
|
endwhile
|
|
|
|
" lstrip()
|
|
while cur_line[start] =~ '[ ]'
|
|
let start += 1
|
|
endwhile
|
|
|
|
return start
|
|
endfunction
|
|
|
|
function! s:GenerateCompletions(findstart, base)
|
|
if a:findstart
|
|
return s:FindStartingIndex()
|
|
endif
|
|
|
|
let results = []
|
|
let cmd = s:GetSetting('query_command')
|
|
if cmd !~ '%s'
|
|
let cmd .= ' %s'
|
|
endif
|
|
let cmd = substitute(cmd, '%s', shellescape(a:base), '')
|
|
let lines = split(system(cmd), g:qcc_line_separator)
|
|
|
|
for my_line in lines
|
|
let fields = split(my_line, g:qcc_field_separator)
|
|
|
|
let entry = s:MakeCompletionEntry(fields)
|
|
|
|
call add(results, entry)
|
|
endfor
|
|
|
|
return results
|
|
endfunction
|
|
|
|
function! s:ShouldGenerateCompletions(line_number)
|
|
let current_line = getline(a:line_number)
|
|
|
|
if current_line =~ g:qcc_pattern
|
|
return 1
|
|
endif
|
|
|
|
if ! g:qcc_multiline || a:line_number <= 1 || current_line !~ g:qcc_multiline_pattern
|
|
return 0
|
|
endif
|
|
|
|
return s:ShouldGenerateCompletions(a:line_number - 1)
|
|
endfunction
|
|
|
|
function! s:CheckSettings()
|
|
" Try to use mutt's query_command by default if nothing is set
|
|
if empty(s:GetSetting('query_command'))
|
|
let s:querycmd = system('mutt -Q query_command 2>/dev/null')
|
|
let s:querycmd = substitute(s:querycmd, '^query_command="\(.*\)"\n', '\1','')
|
|
|
|
if len(s:querycmd)
|
|
let g:qcc_query_command = s:querycmd
|
|
let g:qcc_multiline = 1
|
|
autocmd FileType mail setlocal omnifunc=QueryCommandComplete
|
|
else
|
|
echoerr "QueryCommandComplete: g:qcc_query_command not set!"
|
|
return 0
|
|
endif
|
|
endif
|
|
return 1
|
|
endfunction
|
|
|
|
function! QueryCommandComplete(findstart, base)
|
|
if s:CheckSettings() && s:ShouldGenerateCompletions(line('.'))
|
|
return s:GenerateCompletions(a:findstart, a:base)
|
|
endif
|
|
endfunction
|
|
|
|
let &cpo = s:save_cpo
|