Como executar o arquivo que estou editando em Vi (m)

Como executar o arquivo que estou editando no Vi (m) e obter a saída na janela dividida (como no SciTE)?

Claro que eu poderia executá-lo assim:

:!scriptname

Mas é possível evitar escrever o nome do script e como obter a saída na janela dividida em vez de apenas na parte inferior da tela?

Aí está o makecomando. Ele executa o comando definido na makeprgopção. Use %como um espaço reservado para o nome do arquivo atual. Por exemplo, se você estava editando um script Python:

:set makeprg=python\ %

Sim, você precisa escapar do espaço. Depois disso, você pode simplesmente executar:

:make

Se desejar, você pode definir a autowriteopção e ela será salva automaticamente antes de executar makeprg:

:set autowrite

Isso resolve a parte de execução. Não conheço nenhuma maneira de obter essa saída em uma janela dividida que não envolva o redirecionamento para o arquivo.

Para acessar o nome do arquivo do buffer atual, use %. Para colocá-lo em uma variável, você pode usar a expand()função. Para abrir uma nova janela com um novo buffer, use :newou :vnew. Para canalizar a saída de um comando para o buffer atual, use :.!. Juntando tudo:

:let f=expand("%")|vnew|execute '.!ruby "' . f . '"'

obviamente substituindo rubycom qualquer comando que você deseja. Usei executepara colocar o nome do arquivo entre aspas, então funcionará se o nome do arquivo contiver espaços.

O Vim tem um !comando ("bang") que executa o comando shell diretamente da janela do VIM. Além disso, permite lançar uma sequência de comandos que estão conectados com o pipe e lêem stdout.

Por exemplo:

! node %

equivale a abrir a janela do prompt de comando e iniciar comandos:

cd my_current_directory 
node my_current_file

Consulte "Dicas do Vim: Trabalhando com comandos externos" para obter detalhes.

Tenho um atalho para isso no meu vimrc:

nmap <F6> :w<CR>:silent !chmod 755 %<CR>:silent !./% > .tmp.xyz<CR>
     \ :tabnew<CR>:r .tmp.xyz<CR>:silent !rm .tmp.xyz<CR>:redraw!<CR>

Isso grava o buffer atual, torna o arquivo atual executável (somente unix), executa-o (somente unix) e redireciona a saída para .tmp.xyz, em seguida, cria uma nova guia, lê o arquivo e o exclui.

Dividindo:

:w<CR>                             write current buffer
:silent !chmod 755 %<CR>           make file executable
:silent !./% > .tmp.xyz<CR>        execute file, redirect output
:tabnew<CR>                        new tab
:r .tmp.xyz<CR>                    read file in new tab
:silent !rm .tmp.xyz<CR>           remove file
:redraw!<CR>                       in terminal mode, vim get scrambled
                                   this fixes it

Para o script Shell que usei

:set makeprg=%

:make

O Vim 8 tem um terminal interativo integrado. Para executar o script bash atual em um painel dividido:

:terminal bash %

ou para breve

:ter bash %

% expande para o nome do arquivo atual.

De :help terminal:

The terminal feature is optional, use this to check if your Vim has it:
    echo has('terminal')
If the result is "1" you have it.

Eu uso um mecanismo um pouco mais intrusivo por meio de mapas:

map ;e :w<CR>:exe ":!python " . getreg("%") . "" <CR>

Apenas faz com que eu não precise salvar e depois vá. Apenas vá.

Você pode usar o plugin bexec do vim . Pelo que sei, a última versão é 0,5.

Então:

$ mkdir -p ~/.vim/plugin
$ mv bexec-0.5.vba ~/.vim/plugin
$ vim ~/.vim/plugin/bexec-0.5.vba

Dentro do próprio vim, ao editar o arquivo .vba, faça:

:so %

Alguma saída aparecerá informando que bexec.vim foi escrito, bem como a documentação, etc.

Agora, você pode testá-lo abrindo seu (qualquer script de idioma que tenha um #! Intérprete funcionando corretamente) no vim e execute

:Bexec 

Observação: eu queria que a divisão fosse vertical em vez de horizontal, então fiz:

$ grep -i -n split ~/.vim/plugin/bexec.vim | grep -i hor
102:    let bexec_splitdir = "hor" " hor|ver
261:        exec {"ver":"vsp", "hor":"sp"}[g:bexec_splitdir]

e alterei o valor de "hor" para "ver" ..

Eu sei que é uma pergunta antiga, mas espero que isso possa ajudar alguém aí. Tenho enfrentado o mesmo problema durante o curso de Engenharia de Inicialização do Coursera, onde o professor Palaji usa o Emacs e eu não gosto do Emacs.

Com base nas respostas de @SethKriticos e @Cyril, agora uso o seguinte:

function! Setup_ExecNDisplay()
  execute "w"
  execute "silent !chmod +x %:p"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I prefer vsplit
  "execute "split ~/.vim/output_".n
  execute "vsplit ~/.vim/output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I use set autoread
  "execute "1 . 'wincmd e'"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

Use F9 para configurar a nova janela e F2 para executar seu script e iniciar seu arquivo de saída.

Também adicionei o nome do script ao nome do arquivo de saída, para que você possa usá-lo para vários scripts ao mesmo tempo.

No seu .vimrcvocê pode colar esta função

function! s:ExecuteInShell(command)
  let command = join(map(split(a:command), 'expand(v:val)'))
  let winnr = bufwinnr('^' . command . '$')
  silent! execute ':w'
  silent! execute  winnr < 0 ? 'vnew ' . fnameescape(command) : winnr . 'wincmd w'
  setlocal buftype=nowrite bufhidden=wipe nobuflisted noswapfile nowrap number
  silent! execute 'silent %!'. command
  silent! redraw
  silent! execute 'au BufUnload <buffer> execute bufwinnr(' . bufnr('#') . ') . ''wincmd w'''
  silent! execute 'nnoremap <silent> <buffer> <LocalLeader>r :call <SID>ExecuteInShell(''' . command . ''')<CR>'
  silent! execute 'wincmd w'
  " echo 'Shell command ' . command . ' executed.'
endfunction
command! -complete=shellcmd -nargs=+ Shell call s:ExecuteInShell(<q-args>)
cabbrev shell Shell

Depois disso, em vimrun command :shell python ~/p.pycomo exemplo. E você obterá a saída em janela dividida. + Após as alterações no p.pyexemplo você executará o mesmo comando novamente, esta função não criará uma nova janela novamente, ela exibirá o resultado na janela dividida anterior (mesma).

@xorpaul

Eu estava procurando por este script (python / Windows) há algum tempo. Como não há "tee" no Windows, mudei para:

function! Setup_ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n ." 2>&1"
  execute "vsplit d:\\temp\\output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n . " 2>&1"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

Basta usar dois pontos e ponto de exclamação como mostrado abaixo

:! <script_name>

Eu recomendo o Quickrun do plugin . É rápido e simples de configurar. Aqui está uma pequena demonstração: