Re: patch for locate.el when called with prefix arg

[Luc Teirlinck]

I saw that the _new_ behavior of locate-with-filter (after my previous
suggested patch) was not really consistent with its docstring, e.g.:

    This function is similar to the function `locate', which see.
    The difference is that, when invoked interactively, the present function
    prompts for both SEARCH-STRING and FILTER.

and:

    When called from Lisp, this function is identical with `locate',
    except that FILTER is not optional.

Al this was no longer really true after my previously proposed patch,
but it is after the following revised version, which also eliminates
misfeatures that remained after my previous patch.  The new patch is
not really as extensive as it looks: it copies the biggest part of the
interactive declaration of locate into a separate function, so that it
can be reused without code duplication in locate-with-filter, which
_should_ use exactly the same prompt for SEARCH-STRING.  The new
function guarantees this.  The new patch also keeps the old Emacs-21
de facto behavior of locate-with-filter, that is, it still respects an
interactive arg.  Unlike what I thought before, the old docstring
actually _did_ suggest that it did, which is why it is better to keep
that feature.

===File ~/locate-diff-6=====================================
*** locate.el   21 Apr 2007 00:00:52 -0500      1.42
--- locate.el   22 Apr 2007 21:59:55 -0500      
***************
*** 117,122 ****
--- 117,123 ----
  (defvar locate-current-filter nil)
  (defvar locate-local-filter nil)
  (defvar locate-local-search nil)
+ (defvar locate-local-prompt nil)
  
  (defgroup locate nil
    "Interface to the locate command."
***************
*** 221,227 ****
  
  (defcustom locate-prompt-for-command nil
    "If non-nil, the `locate' command prompts for a command to run.
! Otherwise, that behavior is invoked via a prefix argument."
    :group 'locate
    :type 'boolean)
  
--- 222,231 ----
  
  (defcustom locate-prompt-for-command nil
    "If non-nil, the `locate' command prompts for a command to run.
! Otherwise, that behavior is invoked via a prefix argument.
! 
! Setting this option non-nil actually inverts the meaning of a prefix arg;
! that is, with a prefix arg, you get the default behavior."
    :group 'locate
    :type 'boolean)
  
***************
*** 241,248 ****
         (skip-chars-backward "." pt)
         (point)))))
  
  ;;;###autoload
! (defun locate (search-string &optional filter)
    "Run the program `locate', putting results in `*Locate*' buffer.
  Pass it SEARCH-STRING as argument.  Interactively, prompt for SEARCH-STRING.
  With prefix arg, prompt for the exact shell command to run instead.
--- 245,275 ----
         (skip-chars-backward "." pt)
         (point)))))
  
+ (defun locate-prompt-for-search-string ()
+   (if (or (and current-prefix-arg
+              (not locate-prompt-for-command))
+         (and (not current-prefix-arg) locate-prompt-for-command))
+       (let ((locate-cmd (funcall locate-make-command-line "")))
+       (read-from-minibuffer
+        "Run locate (like this): "
+        (cons
+         (concat (car locate-cmd) "  "
+                 (mapconcat 'identity (cdr locate-cmd) " "))
+         (+ 2 (length (car locate-cmd))))
+        nil nil 'locate-history-list))
+     (let* ((default (locate-word-at-point))
+          (input
+           (read-from-minibuffer
+            (if  (> (length default) 0)
+                (format "Locate (default %s): " default)
+              (format "Locate: "))
+            nil nil nil 'locate-history-list default t)))
+       (and (equal input "") default
+          (setq input default))
+       input)))
+ 
  ;;;###autoload
! (defun locate (search-string &optional filter arg)
    "Run the program `locate', putting results in `*Locate*' buffer.
  Pass it SEARCH-STRING as argument.  Interactively, prompt for SEARCH-STRING.
  With prefix arg, prompt for the exact shell command to run instead.
***************
*** 259,296 ****
  the variables `locate-command' or `locate-make-command-line'.
  
  The main use of FILTER is to implement `locate-with-filter'.  See
! the docstring of that function for its meaning."
    (interactive
!       (list
!        (if (or (and current-prefix-arg
!                   (not locate-prompt-for-command))
!              (and (not current-prefix-arg) locate-prompt-for-command))
!          (let ((locate-cmd (funcall locate-make-command-line "")))
!            (read-from-minibuffer
!             "Run locate (like this): "
!             (cons
!              (concat (car locate-cmd) "  "
!                      (mapconcat 'identity (cdr locate-cmd) " "))
!                      (+ 2 (length (car locate-cmd))))
!             nil nil 'locate-history-list))
!        (let* ((default (locate-word-at-point))
!              (input
!               (read-from-minibuffer
!                (if  (> (length default) 0)
!                    (format "Locate (default %s): " default)
!                  (format "Locate: "))
!                nil nil nil 'locate-history-list default t)))
!              (and (equal input "") default
!                   (setq input default))
!              input))))
    (if (equal search-string "")
        (error "Please specify a filename to search for"))
    (let* ((locate-cmd-list (funcall locate-make-command-line search-string))
         (locate-cmd (car locate-cmd-list))
         (locate-cmd-args (cdr locate-cmd-list))
         (run-locate-command
!         (or (and current-prefix-arg (not locate-prompt-for-command))
!             (and (not current-prefix-arg) locate-prompt-for-command)))
         )
  
      ;; Find the Locate buffer
--- 286,308 ----
  the variables `locate-command' or `locate-make-command-line'.
  
  The main use of FILTER is to implement `locate-with-filter'.  See
! the docstring of that function for its meaning.
! 
! ARG is the interactive prefix arg."
    (interactive
!    (list
!     (locate-prompt-for-search-string)
!     nil
!     current-prefix-arg))
! 
    (if (equal search-string "")
        (error "Please specify a filename to search for"))
    (let* ((locate-cmd-list (funcall locate-make-command-line search-string))
         (locate-cmd (car locate-cmd-list))
         (locate-cmd-args (cdr locate-cmd-list))
         (run-locate-command
!         (or (and arg (not locate-prompt-for-command))
!             (and (not arg) locate-prompt-for-command)))
         )
  
      ;; Find the Locate buffer
***************
*** 304,309 ****
--- 316,322 ----
        (setq locate-current-filter filter)
        (set (make-local-variable 'locate-local-search) search-string)
        (set (make-local-variable 'locate-local-filter) filter)
+       (set (make-local-variable 'locate-local-prompt) run-locate-command)
  
        (if run-locate-command
            (shell-command search-string locate-buffer-name)
***************
*** 324,330 ****
    )
  
  ;;;###autoload
! (defun locate-with-filter (search-string filter)
    "Run the executable program `locate' with a filter.
  This function is similar to the function `locate', which see.
  The difference is that, when invoked interactively, the present function
--- 337,343 ----
    )
  
  ;;;###autoload
! (defun locate-with-filter (search-string filter &optional arg)
    "Run the executable program `locate' with a filter.
  This function is similar to the function `locate', which see.
  The difference is that, when invoked interactively, the present function
***************
*** 334,347 ****
  contain a match for the regular expression FILTER; this is often useful
  to constrain a big search.
  
  When called from Lisp, this function is identical with `locate',
  except that FILTER is not optional."
    (interactive
!    (list (read-from-minibuffer "Locate: " nil nil
!                              nil 'locate-history-list)
!        (read-from-minibuffer "Filter: " nil nil
!                              nil 'locate-grep-history-list)))
!   (locate search-string filter))
  
  (defun locate-filter-output (filter)
    "Filter output from the locate command."
--- 347,363 ----
  contain a match for the regular expression FILTER; this is often useful
  to constrain a big search.
  
+ ARG is the interactive prefix arg.
+ 
  When called from Lisp, this function is identical with `locate',
  except that FILTER is not optional."
    (interactive
!    (list
!     (locate-prompt-for-search-string)
!     (read-from-minibuffer "Filter: " nil nil
!                         nil 'locate-grep-history-list)
!     current-prefix-arg))
!   (locate search-string filter arg))
  
  (defun locate-filter-output (filter)
    "Filter output from the locate command."
***************
*** 356,362 ****
     (require 'dired)
  
     (setq locate-mode-map (copy-keymap dired-mode-map))
- 
     ;; Undefine Useless Dired Menu bars
     (define-key locate-mode-map [menu-bar Dired]   'undefined)
     (define-key locate-mode-map [menu-bar subdir]  'undefined)
--- 372,377 ----
***************
*** 584,590 ****
    "Revert the *Locate* buffer.
  If `locate-update-when-revert' is non-nil, offer to update the
  locate database using the shell command in `locate-update-command'."
!   (let ((locate-buffer-name (buffer-name)))
      (and locate-update-when-revert
         (yes-or-no-p "Update locate database (may take a few seconds)? ")
         ;; `expand-file-name' is used in order to autoload Tramp if
--- 599,606 ----
    "Revert the *Locate* buffer.
  If `locate-update-when-revert' is non-nil, offer to update the
  locate database using the shell command in `locate-update-command'."
!   (let ((locate-buffer-name (buffer-name))
!       (locate-prompt-for-command locate-local-prompt))
      (and locate-update-when-revert
         (yes-or-no-p "Update locate database (may take a few seconds)? ")
         ;; `expand-file-name' is used in order to autoload Tramp if
============================================================