Comment exécuter une commande à chaque fois qu'un fichier est modifié ?

Solution utilisant Vim :

:au BufWritePost myfile.py :silent !./myfile.py

Mais je ne veux pas de cette solution parce que c'est un peu ennuyeux à taper, c'est un peu difficile de se souvenir de ce qu'il faut taper, exactement, et c'est un peu difficile d'annuler ses effets (il faut lancer la fonction :au! BufWritePost myfile.py ). En outre, cette solution bloque Vim jusqu'à ce que la commande ait fini de s'exécuter.

J'ai ajouté cette solution ici juste pour être complet, car elle pourrait aider d'autres personnes.

Pour afficher la sortie du programme (et perturber complètement votre flux d'édition, car la sortie s'écrira par-dessus votre éditeur pendant quelques secondes, jusqu'à ce que vous appuyiez sur Entrée), supprimez l'option :silent commandement.

Si vous avez npm installé, nodemon est probablement le moyen le plus simple de commencer, surtout sous OS X, qui ne dispose apparemment pas d'outils inotify. Il prend en charge l'exécution d'une commande lorsqu'un dossier change.

rerun2 ( sur github ) est un Bash script de 10 lignes de la forme :

#!/usr/bin/env bash

function execute() {
    clear
    echo "$@"
    eval "$@"
}

execute "$@"

inotifywait --quiet --recursive --monitor --event modify --format "%w%f" . \
| while read change; do
    execute "$@"
done

Enregistrez la version de github en tant que 'rerun' dans votre PATH, et invoquez-la en utilisant :

rerun COMMAND

Il exécute COMMAND chaque fois qu'il y a un événement de modification du système de fichiers dans votre répertoire actuel (récursif).

Les choses que l'on pourrait aimer à ce sujet :

• Il utilise inotify, et est donc plus réactif que les sondages. Fabuleux pour exécuter des tests unitaires de l'ordre de la milliseconde, ou pour rendre les fichiers dot de Graphviz, à chaque fois que vous appuyez sur 'save'.
• Comme il est très rapide, vous n'avez pas besoin de lui dire d'ignorer les grands sous-répertoires (comme node_modules) pour des raisons de performances.
• Elle est super réactive, car elle n'appelle inotifywait qu'une seule fois, au démarrage, au lieu de l'exécuter, et de subir le coût élevé de l'établissement des montres, à chaque itération.
• C'est juste 12 lignes de Bash
• Parce que c'est Bash, il interprète les commandes que vous lui passez exactement comme si vous les aviez tapées à une invite Bash. (Vraisemblablement, c'est moins cool si vous utilisez un autre Shell).
• Elle ne perd pas les événements qui se produisent pendant l'exécution de COMMAND, contrairement à la plupart des autres solutions inotify de cette page.
• Au premier événement, il entre dans une "période morte" de 0,15 seconde, pendant laquelle les autres événements sont ignorés, avant que COMMAND ne soit exécutée exactement une fois. Cela permet d'éviter que la rafale d'événements provoquée par la danse création-écriture-déplacement que Vi ou Emacs effectue lors de la sauvegarde d'un tampon ne provoque de multiples exécutions laborieuses d'une suite de tests qui pourrait être lente. Tous les événements qui se produisent alors que COMMAND est en cours d'exécution ne sont pas ignorés - ils provoquent une deuxième période morte et une nouvelle exécution.

Les choses que l'on pourrait détester à son sujet :

• Il utilise inotify, donc ne fonctionnera pas en dehors de Linuxland.
• Parce qu'il utilise inotify, il se dégonflera en essayant de surveiller des répertoires contenant plus de fichiers que le nombre maximum d'utilisateurs que inotify surveille. Par défaut, ce nombre semble être fixé à environ 5.000 à 8.000 sur les différentes machines que j'utilise, mais il est facile de l'augmenter. Voir https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Il ne parvient pas à exécuter les commandes contenant des alias Bash. Je pourrais jurer que cela fonctionnait auparavant. En principe, comme il s'agit de Bash et non de l'exécution de COMMAND dans un sous-shell, je m'attendrais à ce que cela fonctionne. J'aimerais savoir si quelqu'un sait pourquoi cela ne fonctionne pas. La plupart des autres solutions de cette page ne peuvent pas non plus exécuter de telles commandes.
• Personnellement, j'aimerais pouvoir appuyer sur une touche du terminal dans lequel il est exécuté pour provoquer manuellement une exécution supplémentaire de COMMAND. Pourrais-je ajouter cela d'une manière ou d'une autre, simplement ? Une boucle 'while read -n1' qui s'exécute simultanément et qui appelle aussi execute ?
• Pour l'instant, je l'ai codé pour vider le terminal et imprimer la COMMANDE exécutée à chaque itération. Certaines personnes pourraient souhaiter ajouter des drapeaux en ligne de commande pour désactiver ce genre de choses, etc. Mais cela multiplierait la taille et la complexité de l'application.

Il s'agit d'un raffinement de la réponse de @cychoi.

Si vous avez nodemon installé, alors vous pouvez le faire :

nodemon -w <watch directory> -x "<shell command>" -e ".html"

Dans mon cas, je modifie le html localement et je l'envoie à mon serveur distant lorsqu'un fichier est modifié.

nodemon -w <watch directory> -x "scp filename jaym@jay-remote.com:/var/www" -e ".html"

Voici un simple Shell Bourne Shell Shell qui :

1. Prend deux arguments : le fichier à surveiller et une commande (avec des arguments, si nécessaire)
2. Copie le fichier que vous surveillez dans le répertoire /tmp.
3. Vérifie toutes les deux secondes que le fichier que vous surveillez est plus récent que la copie
4. S'il est plus récent, il écrase la copie avec l'original plus récent et exécute la commande

5. Nettoie après lui-même lorsque vous appuyez sur Ctr-C

   #!/bin/sh  
   f=$1  
   shift  
   cmd=$*  
   tmpf="`mktemp /tmp/onchange.XXXXX`"  
   cp "$f" "$tmpf"  
   trap "rm $tmpf; exit 1" 2  
   while : ; do  
       if [ "$f" -nt "$tmpf" ]; then  
           cp "$f" "$tmpf"  
           $cmd  
       fi  
       sleep 2  
   done  

Cela fonctionne sous FreeBSD. Le seul problème de portabilité auquel je peux penser est si un autre Unix n'a pas la commande mktemp(1), mais dans ce cas vous pouvez juste coder en dur le nom du fichier temporaire.