Emacs: ¿Cómo se almacena el último parámetro proporcionado por el usuario como predeterminado?

Question

Estoy escribiendo una función interactiva que me gustaría recordar el último argumento proporcionado por el usuario y usarlo como predeterminado.

(defun run-rake (param) 
    (interactive "sTask: ") 
    (shell-command (format "rake %s" task))) 

La primera vez que se invoca la función que yo quiero que recuerda el argumento de que el usuario suministra de manera que la próxima vez que invocan la función que sólo puede presionar enter y se utilizará el valor que suministran la vez anterior.

Parece que no puedo encontrar esto en la documentación, ¿cómo se hace esto en elisp?

Answer 1

Se puede ver cómo el comando compile hace esto. Abra el texto de ayuda para el comando de compilación con C-h f compile, mueva el cursor sobre el nombre del archivo que contiene la función, luego presione RETURN. Esto abrirá el archivo fuente para compile.

Básicamente, hay una variable dinámica/global compile-command que contiene el último comando de compilación. Emacs es un sistema de un único usuario y un único subproceso, por lo que no es necesario mucho más. También tenga en cuenta que Elisp es un Lisp muy antiguo, y las variables tienen alcance dinámico (llamado a la pila), no léxico. En este tipo de sistema es natural:

(let ((compile-command "gcc -o foo foo.c frobnicate.c")) 
    ... 
    (compile) 
    ...) 

Hablando del comando compile, ¿ha intentado usarlo en lugar de su propia función run-rake?

Answer 2

Me di cuenta de cómo hacerlo manualmente usando un defvar (global), pero esto se siente como el tipo de cosa que ya debería proporcionar la biblioteca central (algo así como el parámetro make del esquema). Esto sólo parece más código, y más manual de lo que debería ser:

(defvar *editconf-ruby-run-rake-last-rake-task* nil) 

(defun editconf-ruby-run-rake-last-rake-task (&optional new-val) 
    (when new-val 
    (setf *editconf-ruby-run-rake-last-rake-task* new-val)) 
    *editconf-ruby-run-rake-last-rake-task*) 

(defun editconf-ruby-run-rake (task-name) 
    "Execute rake `task-name'. See                        
`krb-ruby-get-rakefile-path-for-current-buffer' for how the                 
Rakefile is located.." 
    (interactive 
    (let* ((rakefile (krb-ruby-get-rakefile-path-for-current-buffer)) 
      (rake-tasks (krb-ruby-get-rake-tasks rakefile)) 
      (default-task (or (editconf-ruby-run-rake-last-rake-task) 
          (editconf-ruby-run-rake-last-rake-task (car rake-tasks))))) 
    (list 
     (read-string (format "Task [%s|%s]: " 
          rake-tasks 
          default-task) 
        nil nil default-task)))) 
    (editconf-ruby-run-rake-last-rake-task task-name) 
    (let ((cmd (format "cd %s; rake %s" 
        (krb-lisp-strip-path-suffix rakefile 1) 
        task-name))) 
    (message "editconf-ruby-run-rake: cmd='%s'" cmd) 
    (shell-command cmd))) 

Answer 3

read-from-minibuffer 

es lo que desea utilizar. Tiene un lugar para una variable de historial.

Aquí hay un código de ejemplo:

(defvar run-rake-history nil "History for run-rake") 
(defun run-rake (cmd) 
(interactive (list (read-from-minibuffer "Task: " (car run-rake-history) nil nil 'run-rake-history))) 
    (shell-command (format "rake %s " cmd))) 

personalizar Obviamente a sus necesidades. El 'run-rake-history' es simplemente una variable que se usa para almacenar el historial de esta invocación de 'read-from-minibuffer'. Otra opción sería utilizar 'completing-read', pero eso supone que tiene una lista de opciones que desea restringir al usuario (lo que normalmente no es el caso para los comandos tipo shell).