SGCG

Volver arriba

Emacs Lisp en casos prácticos (7): ejecutar un programa externo periódicamente (1)

2015-07-23

GNU Emacs es un editor de textos potentísimo. Por debajo, es un intérprete de Emacs Lisp, un lenguaje de programación de la familia de Lisp. En esta serie de artículos vamos a mostrar algunas formas de adaptar Emacs a nuestras necesidades con algunos casos prácticos.

En el artículo de hoy, crearemos una función para ejecutar un programa externo periódicamente y mostrar su salida en un búfer: una réplica de las herramientas watch de GNU/Linux, cmdwatch de FreeBSD y gnuwatch de OpenBSD. Vamos a usar temporizadores, así que el gestor de temporizadores del último artículo puede ayudarnos durante el desarrollo.

El código de este artículo funciona en GNU Emacs 24.4.

El problema

Las herramientas watch, cmdwatch y gnuwatch sirven para ejecutar periódicamente una orden y mostrar su salida a pantalla completa en una consola. Queremos hacer algo equivalente en Emacs: ejecutar periódicamente un programa externo y mostrar su última salida en un búfer.

Plan a seguir

Vamos a construir una función interactiva que preguntará al usuario qué orden ejecutar y cada cuánto tiempo hacerlo. Después, la función creará un temporizador (con run-with-timer) que se ocupará de ejecutar nuestro programa externo de forma asíncrona con async-shell-command. La salida irá en un búfer con el nombre *Watch: PROGRAMA* (donde PROGRAMA es el programa externo que hemos mandado ejecutar); si eliminamos este búfer, ya no tiene sentido que se ejecute el temporizador, así que lo eliminaremos con una función hook añadida a kill-buffer-hook (para que se ejecute al matar el búfer).

Implementación

La función, que acepta la orden a ejecutar (command) y los segundos entre ejecuciones (interval), es así:

(defun watch (command interval) "Run shell COMMAND every INTERVAL seconds showing the results in a dedicated buffer." (interactive (list (read-shell-command "Shell command: " nil nil) (read-number "Update interval (seconds): "))) (let* ((buffer-name (format "*Watch: %s*" command)) (buffer (generate-new-buffer buffer-name))) (switch-to-buffer buffer) (lexical-let ((timer (run-with-timer 0 interval 'watch--callback buffer command))) (add-hook 'kill-buffer-hook (lambda () (cancel-timer timer)) nil t))))

Analicémosla punto por punto:

• La declaración de función interactiva es algo complicada porque construye la lista de argumentos explícitamente con read-shell-command (para el argumento command) y read-number (para el argumento interval). La motivación frente a algo como
  (interactive "sShell command: \nnUpdate interval (seconds): ")
  es que read-shell-command es muy conveniente, ya que permite autocompleción de la orden que queremos ejecutar.
• Creamos un nuevo búfer cuyo nombre sigue el esquema que dijimos. Lo hacemos con generate-new-buffer, que puede usar un nombre ligeramente modificado frente al que pedimos (buffer-name) si este nombre ya está usado.
• Mostramos el búfer nuevo y lo dejamos seleccionado con switch-to-buffer.
• Creamos un temporizador con run-with-timer. Este temporizador se encarga de llamar a la función watch--callback (que definiremos unas líneas más abajo) pasándole el búfer y la orden, ya que nuestra función necesitará estos datos. Hay que señalar que usamos lexical-let para asignar el temporizador a la variable timer; con lexical-let tenemos alcance léxico en vez del dinámico que tiene Emacs Lisp normalmente (¡es más antiguo que Scheme!), lo que nos permite encerrar el temporizador en una clausura.
• Añadimos una función hook a kill-buffer-hook que se encargará de cancelar el temporizador. De no haber usado lexical-let, habríamos tenido alcance dinámico y el temporizador no habría sido visible en el momento de ejecutar la función hook. Otro detalle importante es que la asignación de la función hook que hemos hecho es local, así que solamente se ejecutará al cerrar el búfer que acabamos de crear y no cualquier otro; esto va en contra de las advertencias que aparecen en la documentación de kill-buffer-hook.

La función watch--callback, que es la que se ejecuta cada vez que salta el temporizador, lo único que hace es llamar a la orden con async-shell-command:

(defun watch--callback (buffer command) (async-shell-command command buffer))ime

Esto tiene el problema de que se muestra el búfer cada vez que salta el temporizador, lo que puede ser molesto. Para evitarlo, hacemos lo que recomienda la documentación de async-shell-command:

(push '("^\*Watch: .*\*" display-buffer-no-window) display-buffer-alist)

Ejecutamos esto solamente una vez. El elemento que hemos añadido a display-buffer-alist es una lista con dos campos: una expresión regular que casa con el esquema de nombres que hemos usado para nuestros búferes y la función display-buffer-no-window, que se encarga de que no se muestre el búfer si ya está oculto.

Problemas pendientes

Cada vez termina la ejecución del programa externo con async-shell-command, aparece un mensaje en el minibúfer. Esto puede ser muy molesto, así que buscaremos una forma de evitarlo.

No estamos permitiendo una forma sencilla de parar el temporizador o cambiar el intervalo entre ejecuciones. Podemos usar nuestro nuevo y flamante gestor de temporizadores, pero es mejor ofrecer esa funcionalidad directamente.

Categorías: Informática

Artículos publicados el mismo mes

Permalink: https://sgcg.es/articulos/2015/07/23/emacs-lisp-en-casos-practicos-7-ejecutar-un-programa-externo-periodicamente-1/

Volver arriba