Estou trabalhando em um plug-in que permite aos usuários criar operadores personalizados. Os operadores aplicariam uma expressão VimL ao objeto de movimento ou texto sobre o qual o operador se move.

Mantendo uma interface de usuário limpa

Eu acho que a interface mais limpa para definir os operadores personalizados seria usar um comando. Eu defini um comando :MapExpressque seria chamado assim:

:MapExpress cd '/* ' . v:val . ' */'

Isso criaria um operador no modo Normal e um mapeamento no modo Visual para cdenvolver o movimento ou a seleção nos delimitadores de comentários no estilo C.

Claro, aqui está um problema. Você não pode chamar um comando definido em um plug-in do seu .vimrcarquivo.

Soluções alternativas pouco satisfatórias

Eu vim com algumas soluções alternativas com as quais não estou totalmente feliz.

O usuário usa autocmd VimEnter *para chamar o comando

Embora isso funcione, ele adiciona muita "sobrecarga mental". Eu acho que muitos usuários do Vim não têm uma sólida compreensão de como autocmdfunciona.

Usuário cria um arquivo no ~/.vim/after/plugin/qual chama o comando

Novamente, isso funcionaria, mas tem a desvantagem de que essa parte da configuração está em seu próprio arquivo, facilmente perdida e esquecida.

Movo as definições de comando para o autoload/diretório do meu plug-in e o usuário chama algum método que aciona o carregamento do arquivo e, portanto, os comandos a serem definidos

Isso ficaria assim:

call express#init()
MapExpress cd '/* ' . v:val . ' */'

Um pouco melhor, mas isso causaria confusão sobre se o express#init()método é necessário para o plugin funcionar.

Alternativas ao uso de um comando

Também considerei algumas alternativas ao uso de um comando para definir o operador, mas cada uma tem suas ressalvas.

O usuário chama uma função para definir os operadores

Isso seria algo como isto:

call express#operator('cd', '"/* ".v:val." */"')

Isso não é terrível, mas tem a desvantagem de exigir uma expressão citada. Isso pode ser irritante quando você deseja usar aspas em sua expressão.

Usuário usa um <expr>mapeamento

Como isso:

nmap <expr> cd express#nmap('"/* ".v:val." */"')
xmap <expr> cd express#xmap('"/* ".v:val." */"')

Ele tem o mesmo requisito de expressão tediosa e também viola o DRY, a menos que você introduza uma variável (não ideal).

Ok, e daí?

Aqui estão todas as minhas idéias e por que não gosto de nenhuma delas. Estou sendo muito exigente? Existe alguma solução melhor que eu não tenha pensado?

Parece-me que você está procurando :runtime. Você pode executar perfeitamente os comandos definidos nos plugins do seu .vimrc, mas precisa saber o nome do plug-in (que o define) antes disso.

" 1- Prepare the plugin-suite if it's managed through VAM/Vundle/NeoBundle/...
ActivateAddons FooBar

" 2- Be sure the plugin is loaded
runtime plugin/foobar.vim

" 3- And finally run (defensively) the command
if !exists(':FooBar')
   echo "Sorry some initializations will be ignored as foobar is nowhere to be found"
else
   FooBar abc
   FooBar 135468
endif

Nota: ao contrário da solução de carregamento automático, essa abordagem não trava a fonte .vimrc. Se um plug-in de carregamento automático não puder ser encontrado (através da execução de uma função), o vim lançará um erro. :runtimepermanece silencioso se nenhum plug-in puder ser carregado.

Uma lista seria a IMO a solução mais fácil:

let g:pluginname_my_operators = [
    ['cd', '/* ' . v:val . ' */'],
    ['cm', '<em>' . v:val . '</em>']
]

Verifique g:pluginname_my_operatorsquando você inicializa seu plug-in e executa :MapExpressem cada item, se aplicável, enquanto ainda permite que seus usuários usem o comando para definição on-the-fly.