Comment puis-je faire en sorte que Vim se comporte comme "queue-f"?

J'aimerais savoir s'il existe un moyen de faire en sorte que Vim se comporte comme tel tail -f.
Même le meilleur plugin Vim que j'ai trouvé jusqu'à présent ne fait pas ce que j'attendais.

Je veux vraiment voir le fichier mettre à jour en temps réel . Même si je suis loin du clavier, je veux que Vim recharge constamment le tampon et passe à la dernière ligne.

Comment faire ça?
(Je ne veux pas recharger tout le fichier car certains fichiers journaux sont très volumineux. Le mieux est de ne charger que les dernières lignes, comme le tail -ffait le cas.)

Vous ne pouvez pas faire vim se comporter comme tail -f. Vous pouvez faire lessse comporter comme une combinaison de vimet tail -fbien.

En avant pour toujours (suivre) le mode

lessa un mode de transmission avant éternel que vous pouvez entrer en appuyant sur Fou en lui passant +Fcomme argument.

$ less +F

Dans ce mode, il lessse comporte comme tail -fs'il n'arrêtait pas de lire lorsqu'il atteint la fin d'un fichier. Il actualise en permanence avec les nouvelles données du fichier. Pour quitter ce mode, appuyez sur Ctrlc.

Mise en évidence de la syntaxe

lessprend en charge le filtrage automatique des données lues. Il existe un programme appelé source-highlight qui peut effectuer une surbrillance de base du code source. Il vient avec un script qui fonctionne bien avec less. Pour l'utiliser, il suffit de définir la LESSOPENvariable d'environnement de manière appropriée.

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

Vous devez également dire lessde transmettre les séquences d'échappement brutes du terminal (celles-ci indiquent à votre terminal comment colorer le texte) en lui passant le -Rdrapeau. Vous pouvez dire lessde prétendre que le -Rdrapeau est toujours passé en définissant la LESSvariable d'environnement.

 export LESS=' -R '

Quand less n'est pas assez

Bien que less que ses raccourcis clavier soient similaires à ceux de vi, ce n'est tout simplement pas la même chose que Vim. Parfois, cela semble étranger et il manque des fonctionnalités importantes telles que l'intégration des ctags et la possibilité de modifier du texte.

Vous pouvez lessappeler Vim (en supposant EDITOR=vim) sur le fichier en cours de visualisation en appuyant sur v. lessmettra même votre curseur au bon endroit dans Vim. Lorsque vous quitterez Vim, vous vous retrouverez à less. Si vous avez apporté des modifications au fichier alors que vous étiez dans Vim, elles seront reflétées dans less.

vim --servername TAIL_VIM /tmp/somefile

Maintenant, dans un autre shell (comme bash), vous pouvez faire:

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

Où <C -> <CN> oblige vim à passer en mode normal, "edit!" indique à vim de recharger le fichier actuel (le CR simule une pression sur Entrée), et G va au bas du fichier. Le retrait de (G) facilite l’insertion du fichier pendant l’entrée des données.

J'ai trouvé la réponse grâce au commentaire de Evan Teitelman . Ma solution est inspirée de /usr/share/vim/vimcurrent/macros/less.vim .

J'ai créé ma propre fonction, mais cela pourrait être beaucoup amélioré.

function! Tailf()
    e
    normal G
    redraw

    sleep 1
    call Tailf()
endfunction

Et appuyez simplement sur CTRL + C pour quitter Tailf.

Pour ouvrir un fichier journal en mode Tailf: view -M "+call Tailf()" /path/to/logfile.log

Ce que je n’aime pas, c’est l’ sleepappel, qui ne permet de rien faire dans vim pendant l’actualisation automatique. Le mieux serait que le tampon soit autonome et qu'il mette à jour même si je suis dans une autre fenêtre partagée. Quoi qu'il en soit, c'est un bon début. :)

Une méthode non récursive pour la même chose:

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

J'aime ça court et sans beaucoup de piratage. Vous pouvez exécuter cet oneliner à partir de ex (dans vim) en cas de besoin (ou mettre chaque commande dans vimrc, lorsque les fichiers journaux sont ouverts.)

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

(si vous voulez sauter (presque) à la fin du fichier, utilisez simplement "G" au lieu de "lh" avec feedkeys)

Explication:

• autoread: lit le fichier lorsqu'il est modifié de l'extérieur (mais cela ne fonctionne pas tout seul, il n'y a pas de timer interne ou quelque chose comme ça. Il ne lira le fichier que lorsque vim fera une action, comme une commande dans ex :!
• CursorHold * checktime: lorsque le curseur n'est pas déplacé par l'utilisateur pendant le temps spécifié dans updatetime(ce qui correspond à 4000 millisecondes par défaut) checktimeest exécuté, ce qui permet de rechercher les modifications extérieures au fichier.
• call feedkeys("lh"): le curseur est déplacé une fois, à droite et à gauche. et puis rien ne se passe (... ce qui signifie, cela CursorHoldse déclenche, ce qui signifie que nous avons une boucle )

Pour arrêter le défilement lors de l’utilisation call feedkeys("G"), exécutez :set noautoread- maintenant, vim dira que le fichier a été modifié et demandez si l’on veut lire les modifications ou non)

J'aime l'idée de regarder les fichiers journaux dans vim (au lieu de tail -f), par exemple lorsque vous travaillez dans une session ssh sans screen / tmux. De plus, vous pouvez copier directement à partir du fichier journal, si nécessaire, ou enregistrer la sortie directement ou ... tout ce que vous pouvez faire avec vim :)

* de cette réponse (faisant référence à une réponse de PhanHaiQuang et à un commentaire de flukus )

Edit: Je m'excuse, complètement passé outre que vous avez déjà essayé cela.

Vous pouvez essayer d'utiliser le paquet de queue plugin , je pense qu’il devrait faire ce que vous cherchez.

Pour installer, ouvrez tail-3.0.vba avec vim et exécutez:

:so %

Redémarrez et vous devriez être capable de mettre un fichier dans vim comme suit:

:Tail /path/to/file

SEULEMENT Pour VIM 8.0+, ils ont introduit des minuteries. Vous pouvez donc utiliser une minuterie pour simuler la fonction de queue, ce qui fonctionne assez bien selon mon expérience.

J'ai mappé la touche F6 pour activer la queue et la touche F7 pour la désactiver, vous pouvez personnaliser celles-ci dans les commandes ci-dessous, voir aussi la section ci-dessous pour les mots de prudence.

Exécutez le suivant

exe ":function! Tail(timer) \n :exe 'normal :e!\<ENTER>G' \n endfunction"
map <F6> :exe timer_start(2000, 'Tail', {'repeat':-1})<CR> 
map <F7> :exe timer_stopall()<CR>

Vous pouvez également intégrer les commandes ci-dessus à vimrc afin de les conserver à tout moment.

Quelques mots de prudence:

• Je suppose que vous n'avez pas d'autres minuteries, donc timer_stopall () arrêtera effectivement toutes les minuteries. Vous pouvez modifier cela un peu plus loin pour obtenir l'ID pendant timer_start, puis le conserver, etc.
• alors qu'il est en mode queue, je vous suggère fortement de ne pas essayer d'exécuter de commande, il bloque généralement les instances de vim, alors VEUILLEZ ÉTEINDRE LE QUEUE (F7) avant de décider de revenir en mode d'édition, c'est STRICTLY ONLY. POUR VISUALISER LES JOURNAUX.

Depuis Vim, exécutez:

!tail -f 

Cela suspendra Vim pendant que l’enfant renvoyé s’exécutera tail -fsur le tampon courant. Frapper Ctrl-Cvous ramène à la mémoire tampon dans Vim.