Emacs: Como você armazenar o último parâmetro fornecido pelo usuário como padrão?

Question

Eu estou escrevendo uma função interativa que eu gostaria de ter me lembro o último argumento do utilizador fornecido e usá-lo como padrão.

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

A primeira vez que a função é chamada quero que lembrar o argumento de que o usuário fornecido para que na próxima vez que chamar a função eles podem simplesmente pressione enter e ele usará o valor que eles fornecido o tempo anterior.

Eu não consigo encontrar isso na documentação - como você faz isso em elisp

Answer 1

Você pode ver como o comando compile faz isso. Traga-se o texto de ajuda para o comando de compilação com C-h f compile, mova o cursor sobre o nome do arquivo que contém a função, em seguida, bateu RETURN. Isso fará com que o arquivo de origem para compile.

Basicamente, há a / compile-command variável global dinâmica que mantém o último comando de compilação. Emacs é um único usuário, o sistema single-threaded, então não há realmente nenhuma necessidade para muito mais. Também tenha em mente que Elisp é uma escola muito antiga Lisp e variáveis ??têm dinâmica (pilha de chamadas), não lexical, escopo. Neste tipo de sistema é natural:

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

Falando do comando compile, você já tentou usá-lo em vez de sua própria função run-rake?

Answer 2

read-from-minibuffer

é o que você deseja usar. Ele tem um ponto para uma variável história.

Aqui está um código de exemplo:

(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)))

Obviamente personalizar a suas necessidades. O '-ancinho-histórico de execução é simplesmente uma variável que é usado para armazenar o histórico para esta chamada de' minibuffer ler-from-. Outra opção seria usar 'completando-ler -. Mas isso pressupõe que você tem uma lista de opções que você quer restringir o usuário a usar (o que geralmente não é o caso para o shell-like comandos)

Answer 3

Eu descobri como fazer isso manualmente usando um defvar (global), mas isto parece o tipo de coisa que já deve ser fornecido pela biblioteca central (tipo como make-parâmetro do esquema). Isso só parece mais código e mais manual do que deveria 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)))