Como faço para que o Vim se comporte como “tail -f”?

Question

Eu gostaria de saber se existe uma maneira de fazer o Vim se comportar como tail -f .
Mesmo o melhor plug-in Vim que encontrei até agora não faz o que eu espero.

Eu realmente quero ver a atualização do arquivo em em tempo real . Mesmo que eu esteja longe do teclado, eu quero que o Vim recarregue constantemente o buffer e pule para a última linha.

Como fazer isso?
(Eu não quero recarregar o arquivo inteiro, já que alguns arquivos de log são muito grandes. O melhor é carregar apenas as últimas linhas, como tail -f ).

    

Answer 1

Você não pode fazer com que vim se comporte como tail -f . Você pode fazer o less se comportar como uma combinação de vim e tail -f .

Modo para a frente (seguir) para sempre

less tem um modo para frente sempre que você pode entrar pressionando F ou passando +F para ele como um argumento.

$ less +F

Nesse modo, less se comporta como tail -f , pois não pára de ler quando atinge o final de um arquivo. Ele atualiza constantemente com novos dados do arquivo. Para sair deste modo, pressione Ctrl c .

Destaque da sintaxe

less suporta a filtragem automática dos dados que lê. Existe um programa chamado source-highlight que pode realizar o realce básico do código-fonte. Ele vem com um script que funciona bem com less . Para usá-lo, basta definir a variável ambiental LESSOPEN apropriadamente.

 export LESSOPEN="| /path/to/src-hilite-lesspipe.sh %s"

Você também tem que dizer less para passar as seqüências de escape do terminal raw (estas dizem ao seu terminal como colorir texto) passando o -R flag. Você pode dizer a less para fingir que está sempre sendo passado o sinal -R definindo a variável ambiental LESS .

 export LESS=' -R '

Quando less não é suficiente

Embora less tenha combinações de teclas semelhantes a vi, não é o mesmo que Vim. Às vezes parece estranho e carece de recursos importantes, como integração de ctags e a capacidade de editar texto.

Você pode fazer less chamar Vim (assumindo EDITOR=vim ) no arquivo que está visualizando no momento pressionando v . less até colocará seu cursor no local correto dentro do Vim. Quando você sair do Vim, você se encontrará de volta em less . Se você fez alguma alteração no arquivo enquanto estava no Vim, ele será refletido em less .

    

Answer 2

vim --servername TAIL_VIM /tmp/somefile

Agora, em outro shell (como o bash), você pode fazer:

while true
do
    inotifywait --event modify /tmp/somefile \
    && vim --servername TAIL_VIM --remote-send '<C-\><C-N>:edit!<CR>G';
done

Onde         o < C- > < C-N > força o vim a ir para o modo normal, "edit!" diz ao vim para recarregar o arquivo atual (o CR simula pressionando enter), e G vai para o final do arquivo. Remover o (G) torna mais fácil inseparar o arquivo enquanto a entrada está chegando.

    

Answer 3

Encontrei a resposta graças ao comentário de Evan Teitelman . Minha solução é inspirada em /usr/share/vim/vimcurrent/macros/less.vim .

Eu fiz minha própria função, mas poderia ser muito melhorada.

function! Tailf()
    e
    normal G
    redraw

    sleep 1
    call Tailf()
endfunction

E basta pressionar CTRL + C para sair do Tailf.

Para abrir um arquivo de log no modo Tailf: view -M "+call Tailf()" /path/to/logfile.log

O que eu não gosto, é a chamada sleep , que não permite fazer nada no vim durante a atualização automática. O melhor seria se o buffer fosse autônomo e fosse atualizado mesmo se eu estivesse em outra janela dividida. De qualquer forma, é um bom começo. :)

    

Answer 4

Um método não recursivo para o mesmo:

cmap tailf<CR> call Tailf()<CR>
         function! Tailf()
    "Press C-c to stop tailing
        while 1
            e                                  
            normal G
            redraw
            sleep 1
        endwhile
    endfunction

    

Answer 5

Edit: peço desculpas, completamente ignorado que você já tentou isso.

Você pode tentar usar o plug-in Tail , acho que ele deve fazer o que você é procurando por.

Para instalar, abra o tail-3.0.vba com o vim e execute:

:so %

Reinicie e você deve ser capaz de seguir um arquivo de dentro do vim da seguinte forma:

:Tail /path/to/file

    

Answer 6

De dentro do Vim, execute:

!tail -f 

Isso suspenderá o Vim enquanto o filho bifurcado executa tail -f no buffer atual. Acertar Ctrl-C retorna você ao buffer no Vim.

    

Answer 7

Eu gosto curto e sem muito hacking. Você pode rodar este oneliner de ex (dentro do vim) quando necessário (ou colocar cada comando no vimrc, para quando os arquivos de log forem abertos).

:set autoread | au CursorHold * checktime | call feedkeys("lh")

(se você quiser pular (quase) para o final do arquivo, basta usar "G" em vez de "lh" com feedkeys)

Explicação:

• autoread : lê o arquivo quando alterado do lado de fora (mas ele não funciona sozinho, não há temporizador interno ou algo parecido. Ele só lerá o arquivo quando o vim fizer uma ação, como um comando em ex :!
• CursorHold * checktime : quando o cursor não é movido pelo usuário pelo tempo especificado em updatetime (que é 4000 milissegundos por padrão) checktime é executado, o que verifica se há alterações fora do arquivo
• call feedkeys("lh") : o cursor é movido uma vez, para a direita e vice-versa. e então nada acontece (... o que significa que CursorHold é acionado, o que significa que temos um loop )

Para parar a rolagem ao usar call feedkeys("G") , execute :set noautoread - agora o vim dirá, que o arquivo foi alterado e perguntará se alguém deseja ler as alterações ou não)

Eu gosto da idéia de ver arquivos de log no vim (em vez de na cauda -f), por exemplo quando você está trabalhando em uma sessão ssh sem screen / tmux. Além disso, você pode copiar diretamente do arquivo de registro, se necessário, ou salvar a saída diretamente ou ... o que você pode fazer com o vim :)

* desta resposta (consulte uma resposta de PhanHaiQuang e um comentário de flukus )