Re: address@hidden: grep-tree doesn't shell-quote-argument]

[Kim F. Storm]

Richard Stallman <address@hidden> writes:

>     > For now, I would suggest we consider making the new feature
>     > grep-tree more convenient in a way that isn't incompatible for old
>     > features such as grep-find.
>
>     The problem that was being addressed is that we already have to many
>     similar features.  The patch was intended to obliterate "grep-tree" as
>     a separate feature.
>
> Yes, it could be C-u M-x grep-find.

How is that convenient?

Here is a patch which make the improvement for both M-x grep and M-x grep-find.

If people really object to making this the default for 22.x, we could make
set grep-prompt-style to 'shell by default.


*** grep.el     16 Mar 2006 09:41:13 +0100      1.51
--- grep.el     24 Apr 2006 14:06:30 +0200
***************
*** 108,113 ****
--- 108,126 ----
                 (const :tag "Not Set" nil))
    :group 'grep)

+ (defcustom grep-command-template nil
+   "The default find command for \\[grep-find].
+ The default value of this variable is set up by `grep-compute-defaults';
+ call that function before using this variable in your program.
+ The following place holders should be present in the string:
+  <C> - place to put -i if case insensitive grep.
+  <F> - file names and wildcards to search.
+  <R> - the regular expression searched for."
+   :type '(choice string
+                (const :tag "Not Set" nil))
+   :version "22.1"
+   :group 'grep)
+
  (defcustom grep-use-null-device 'auto-detect
    "If t, append the value of `null-device' to `grep' commands.
  This is done to ensure that the output of grep includes the filename of
***************
*** 130,137 ****
                 (const :tag "Not Set" nil))
    :group 'grep)

! (defcustom grep-tree-command nil
!   "The default find command for \\[grep-tree].
  The default value of this variable is set up by `grep-compute-defaults';
  call that function before using this variable in your program.
  The following place holders should be present in the string:
--- 143,150 ----
                 (const :tag "Not Set" nil))
    :group 'grep)

! (defcustom grep-find-command-template nil
!   "The default find command for \\[grep-find].
  The default value of this variable is set up by `grep-compute-defaults';
  call that function before using this variable in your program.
  The following place holders should be present in the string:
***************
*** 145,171 ****
    :version "22.1"
    :group 'grep)

! (defcustom grep-tree-files-aliases '(
        ("ch" . "*.[ch]")
        ("c" .  "*.c")
        ("h" .  "*.h")
-       ("m" .  "[Mm]akefile*")
        ("asm" . "*.[sS]")
!       ("all" . "*")
!       ("el" . "*.el")
        )
!   "*Alist of aliases for the FILES argument to `grep-tree'."
    :type 'alist
    :group 'grep)

! (defcustom grep-tree-ignore-case t
!   "*If non-nil, `grep-tree' ignores case in matches."
    :type 'boolean
    :group 'grep)

! (defcustom grep-tree-ignore-CVS-directories t
!   "*If non-nil, `grep-tree' does no recurse into CVS directories."
!   :type 'boolean
    :group 'grep)

  (defcustom grep-error-screen-columns nil
--- 158,194 ----
    :version "22.1"
    :group 'grep)

! (defcustom grep-prompt-style nil
!   "*Prompt style used by `grep' and `grep-find'.
! Nil means to prompt for regexp, files, and directory.
! Value `shell' means to prompt for shell command instead.
! Value `post' means to post-edit the final shell command."
!   :type '(choice (const :tag "Standard" nil)
!                (const :tag "Shell Command" shell)
!                (const :tag "Post-edit Command" post))
!   :version "22.1"
!   :group 'grep)
!
! (defcustom grep-files-aliases '(
!       ("el" . "*.el")
        ("ch" . "*.[ch]")
        ("c" .  "*.c")
        ("h" .  "*.h")
        ("asm" . "*.[sS]")
!       ("m" .  "[Mm]akefile*")
        )
!   "*Alist of aliases for the FILES argument to `grep' and `grep-find'."
    :type 'alist
    :group 'grep)

! (defcustom grep-ignore-case t
!   "*If non-nil, `grep' and `grep-find' ignores case in matches."
    :type 'boolean
    :group 'grep)

! (defcustom grep-find-ignored-directories '("CVS" ".hg" "{arch}")
!   "*List of names of sub-directories which `grep-find' shall not recurse 
into."
!   :type '(repeat string)
    :group 'grep)

  (defcustom grep-error-screen-columns nil
***************
*** 208,213 ****
--- 231,238 ----
        '("Compile..." . compile))
      (define-key map [menu-bar grep compilation-grep]
        '("Another grep..." . grep))
+     (define-key map [menu-bar grep-find compilation-grep-find]
+       '("Recursive grep..." . grep-find))
      (define-key map [menu-bar grep compilation-recompile]
        '("Repeat grep" . recompile))
      (define-key map [menu-bar grep compilation-separator2]
***************
*** 353,358 ****
--- 378,388 ----
  ;;;###autoload
  (defvar grep-find-history nil)

+ ;; History of grep and grep-find regexp and files args.
+ (defvar grep-regexp-history nil)
+ (defvar grep-files-history '("ch" "el"))
+
+
  ;;;###autoload
  (defun grep-process-setup ()
    "Setup compilation variables and buffer for `grep'.
***************
*** 412,417 ****
--- 442,457 ----
                       1)
                (format "%s %s -e " grep-program required-options)
              (format "%s %s " grep-program required-options)))))
+   (unless grep-command-template
+     (setq grep-command-template
+         (let ((required-options (if grep-use-null-device "-n" "-nH")))
+           (if (equal (condition-case nil ; in case "grep" isn't in exec-path
+                          (call-process grep-program nil nil nil
+                                        "-e" "foo" null-device)
+                        (error nil))
+                      1)
+               (format "%s <C> %s -e <R> <F>" grep-program required-options)
+             (format "%s <C> %s <R> <F>" grep-program required-options)))))
    (unless grep-find-use-xargs
      (setq grep-find-use-xargs
          (if (and
***************
*** 433,440 ****
                (t (cons (format "%s . -type f -exec %s {} %s \\;"
                                 find-program grep-command null-device)
                         (+ 22 (length grep-command)))))))
!   (unless grep-tree-command
!     (setq grep-tree-command
          (let* ((glen (length grep-program))
                 (gcmd (concat grep-program " <C>" (substring grep-command 
glen))))
            (cond ((eq grep-find-use-xargs 'gnu)
--- 473,480 ----
                (t (cons (format "%s . -type f -exec %s {} %s \\;"
                                 find-program grep-command null-device)
                         (+ 22 (length grep-command)))))))
!   (unless grep-find-command-template
!     (setq grep-find-command-template
          (let* ((glen (length grep-program))
                 (gcmd (concat grep-program " <C>" (substring grep-command 
glen))))
            (cond ((eq grep-find-use-xargs 'gnu)
***************
*** 487,528 ****
                                   (file-name-extension buffer-file-name))))
        (replace-match tag-default t t grep-default 1))))

  ;;;###autoload
! (defun grep (command-args &optional highlight-regexp)
!   "Run grep, with user-specified args, and collect output in a buffer.
  While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
  or \\<grep-mode-map>\\[compile-goto-error] in the grep \
  output buffer, to go to the lines
  where grep found matches.

! This command uses a special history list for its COMMAND-ARGS, so you can
! easily repeat a grep command.
!
! A prefix argument says to default the argument based upon the current
! tag the cursor is over, substituting it into the last grep command
! in the grep command history (or into `grep-command'
! if that history list is empty).
!
! If specified, optional second arg HIGHLIGHT-REGEXP is the regexp to
! temporarily highlight in visited source lines."
    (interactive
     (progn
!      (unless (and grep-command
                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
         (grep-compute-defaults))
!      (let ((default (grep-default-command)))
!        (list (read-from-minibuffer "Run grep (like this): "
!                                  (if current-prefix-arg
!                                      default grep-command)
!                                  nil nil 'grep-history
!                                  (if current-prefix-arg nil default))))))
!
!   ;; Setting process-setup-function makes exit-message-function work
!   ;; even when async processes aren't supported.
!   (compilation-start (if (and grep-use-null-device null-device)
!                        (concat command-args " " null-device)
!                      command-args)
!                    'grep-mode nil highlight-regexp))

  ;;;###autoload
  (define-compilation-mode grep-mode "Grep"
--- 527,656 ----
                                   (file-name-extension buffer-file-name))))
        (replace-match tag-default t t grep-default 1))))

+ (defun grep-expand-template (template &optional regexp case-fold files dir 
excl)
+   "Patch grep COMMAND string replacing <C>, <D>, <F>, <R>, and <X>."
+   (let ((command template))
+     (setq command
+         (replace-regexp-in-string "<F>"
+                                   (or files "") command t t))
+     (setq command
+         (replace-regexp-in-string "<C>"
+                                   (if case-fold "-i" "") command t t))
+     (setq command
+         (replace-regexp-in-string "<R>"
+                                   (shell-quote-argument (or regexp ""))
+                                   command t t))
+     (setq command
+         (replace-regexp-in-string "<D>"
+                                   (or dir ".") command t t))
+     (setq command
+         (replace-regexp-in-string "<X>"
+                                   (or excl "") command t t))
+     command))
+
+
  ;;;###autoload
! (defun grep (regexp &optional files api)
!   "Run grep, searching for REGEXP in FILES in current directory.
! Collect output in a buffer.
! Interactively, prompt separately for each search parameter.
! The search is limited to file names matching shell pattern FILES.
! FILES may use abbreviations defined in `grep-files-aliases', e.g.
! entering `ch' is equivalent to `*.[ch]'.
!
! With \\[universal-argument] prefix, prompt for shell command instead.
! With two \\[universal-argument] prefixes, prompt for search parameters,
! and allow user to edit the final shell command before it is submitted.
! Note that setting `grep-prompt-style' overrides any prefix arg.
!
  While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
  or \\<grep-mode-map>\\[compile-goto-error] in the grep \
  output buffer, to go to the lines
  where grep found matches.

! This command uses a special history list for its COMMAND, so you can
! easily repeat a grep command."
    (interactive
     (progn
!      (unless (and grep-command grep-command-template
                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
         (grep-compute-defaults))
!      (cond
!       ((or (eq grep-prompt-style 'shell)
!          (equal current-prefix-arg '(4)))
!        (if grep-command
!          (list (read-from-minibuffer "Run grep (like this): "
!                                      grep-command nil nil
!                                      'grep-history)
!                nil current-prefix-arg)
!
!        ;; No default was set
!        (read-string
!         "grep.el: No `grep-command' available. Press RET.")
!        (list nil nil nil)))
!       ((not grep-command-template)
!        (read-string
!       "grep.el: No `grep-command-template' available. Press RET.")
!        (list nil nil nil))
!       (t
!        (let* ((default-regexp
!               (or (funcall (or find-tag-default-function
!                                (get major-mode 'find-tag-default-function)
!                                'find-tag-default))
!                   ""))
!             (regexp (read-string
!                      (concat "Search for"
!                              (if (and default-regexp
!                                       (> (length default-regexp) 0))
!                                  (format " (default %s): " default-regexp) ": 
"))
!                      nil 'grep-regexp-history default-regexp))
!             (default-files
!               (or (and (stringp (buffer-file-name))
!                        (let ((fn (file-name-nondirectory (buffer-file-name)))
!                              (aliases grep-files-aliases)
!                              alias)
!                          (while aliases
!                            (setq alias (car aliases)
!                                  aliases (cdr aliases))
!                            (if (string-match (wildcard-to-regexp (cdr alias)) 
fn)
!                                (setq aliases nil)
!                              (setq alias nil)))
!                          (cdr alias)))
!                   (car grep-files-history)))
!             (files (read-string
!                     (concat "Search for \"" regexp
!                             "\" in files (default " default-files
!                             "): ")
!                     nil 'grep-files-history default-files)))
!        (list regexp files current-prefix-arg))))))
!   (when regexp
!     (let (command)
!       (if (or (null files)  ;; backwards compatible non-interactive call
!             (eq grep-prompt-style 'shell)
!             (equal current-prefix-arg '(4)))
!         (setq command regexp)
!       (when files
!         (let ((mf (assoc files grep-files-aliases)))
!           (if mf
!               (setq files (cdr mf)))))
!       (setq command (grep-expand-template
!                      grep-command-template
!                      regexp
!                      grep-ignore-case
!                      files))
!       (when command
!         (if (or (eq grep-prompt-style 'post)
!                 (equal current-prefix-arg '(16)))
!             (setq command
!                   (read-from-minibuffer "Confirm: "
!                                         command nil nil 'grep-find-history))
!           (push command grep-history))))
!       (when command
!       ;; Setting process-setup-function makes exit-message-function work
!       ;; even when async processes aren't supported.
!       (compilation-start (if (and grep-use-null-device null-device)
!                              (concat command " " null-device)
!                            command) 'grep-mode)))))

  ;;;###autoload
  (define-compilation-mode grep-mode "Grep"
***************
*** 537,650 ****
    (set (make-local-variable 'compilation-disable-input) t))

  ;;;###autoload
! (defun grep-find (command-args)
!   "Run grep via find, with user-specified args COMMAND-ARGS.
  Collect output in a buffer.
  While find runs asynchronously, you can use the \\[next-error] command
  to find the text that grep hits refer to.

  This command uses a special history list for its arguments, so you can
! easily repeat a find command."
    (interactive
     (progn
!      (unless (and grep-command
                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
         (grep-compute-defaults))
!      (if grep-find-command
!        (list (read-from-minibuffer "Run find (like this): "
!                                    grep-find-command nil nil
!                                      'grep-find-history))
!        ;; No default was set
         (read-string
!         "compile.el: No `grep-find-command' command available. Press RET.")
!        (list nil))))
!   (when (and grep-find-command command-args)
!     (let ((null-device nil))          ; see grep
!       (grep command-args))))

  ;;;###autoload
  (defalias 'find-grep 'grep-find)

- (defun grep-expand-command-macros (command &optional regexp files dir excl 
case-fold)
-   "Patch grep COMMAND replacing <D>, etc."
-   (setq command
-       (replace-regexp-in-string "<D>"
-                                 (or dir ".") command t t))
-   (setq command
-       (replace-regexp-in-string "<X>"
-                                 (or excl "") command t t))
-   (setq command
-       (replace-regexp-in-string "<F>"
-                                 (or files "") command t t))
-   (setq command
-       (replace-regexp-in-string "<C>"
-                                 (if case-fold "-i" "") command t t))
-   (setq command
-       (replace-regexp-in-string "<R>"
-                                 (or regexp "") command t t))
-   command)
-
- (defvar grep-tree-last-regexp "")
- (defvar grep-tree-last-files (car (car grep-tree-files-aliases)))
-
- ;;;###autoload
- (defun grep-tree (regexp files dir &optional subdirs)
-   "Grep for REGEXP in FILES in directory tree rooted at DIR.
- Collect output in a buffer.
- Interactively, prompt separately for each search parameter.
- With prefix arg, reuse previous REGEXP.
- The search is limited to file names matching shell pattern FILES.
- FILES may use abbreviations defined in `grep-tree-files-aliases', e.g.
- entering `ch' is equivalent to `*.[ch]'.
-
- While find runs asynchronously, you can use the \\[next-error] command
- to find the text that grep hits refer to.
-
- This command uses a special history list for its arguments, so you can
- easily repeat a find command.
-
- When used non-interactively, optional arg SUBDIRS limits the search to
- those sub directories of DIR."
-   (interactive
-    (let* ((regexp
-          (if current-prefix-arg
-              grep-tree-last-regexp
-            (let* ((default (current-word))
-                   (spec (read-string
-                          (concat "Search for"
-                                  (if (and default (> (length default) 0))
-                                      (format " (default %s): " default) ": 
")))))
-              (if (equal spec "") default spec))))
-         (files
-          (read-string (concat "Search for \"" regexp "\" in files (default "  
 grep-tree-last-files  "): ")))
-         (dir
-          (read-directory-name "Base directory: " nil default-directory t)))
-      (list regexp files dir)))
-   (unless grep-tree-command
-     (grep-compute-defaults))
-   (unless (and (stringp files) (> (length files) 0))
-     (setq files grep-tree-last-files))
-   (when files
-     (setq grep-tree-last-files files)
-     (let ((mf (assoc files grep-tree-files-aliases)))
-       (if mf
-         (setq files (cdr mf)))))
-   (let ((command-args (grep-expand-command-macros
-                      grep-tree-command
-                      (setq grep-tree-last-regexp regexp)
-                      (and files (concat "-name '" files "'"))
-                      (if subdirs
-                          (if (stringp subdirs)
-                              subdirs
-                            (mapconcat 'identity subdirs " "))
-                        nil)  ;; we change default-directory to dir
-                      (and grep-tree-ignore-CVS-directories "-path '*/CVS' 
-prune -o ")
-                      grep-tree-ignore-case))
-       (default-directory (file-name-as-directory (expand-file-name dir)))
-       (null-device nil))              ; see grep
-     (grep command-args regexp)))
-
-
  (provide 'grep)

  ;; arch-tag: 5a5b9169-a79d-4f38-9c38-f69615f39c4d
--- 665,780 ----
    (set (make-local-variable 'compilation-disable-input) t))

  ;;;###autoload
! (defun grep-find (regexp &optional files dir api)
!   "Recusively grep for REGEXP in FILES in directory tree rooted at DIR.
  Collect output in a buffer.
+ Interactively, prompt separately for each search parameter.
+ The search is limited to file names matching shell pattern FILES.
+ FILES may use abbreviations defined in `grep-files-aliases', e.g.
+ entering `ch' is equivalent to `*.[ch]'.
+
+ With \\[universal-argument] prefix, prompt for shell command instead.
+ With two \\[universal-argument] prefixes, prompt for search parameters,
+ and allow user to edit the final shell command before it is submitted.
+ Note that setting `grep-prompt-style' overrides any prefix arg.
+
  While find runs asynchronously, you can use the \\[next-error] command
  to find the text that grep hits refer to.

  This command uses a special history list for its arguments, so you can
! easily modify or repeat a find command."
    (interactive
     (progn
!      (unless (and grep-command grep-find-command grep-find-command-template
                  (or (not grep-use-null-device) (eq grep-use-null-device t)))
         (grep-compute-defaults))
!      (cond
!       ((or (eq grep-prompt-style 'shell)
!          (equal current-prefix-arg '(4)))
!        (if grep-find-command
!          (list (read-from-minibuffer "Run find (like this): "
!                                      grep-find-command nil nil
!                                      'grep-find-history)
!                nil nil current-prefix-arg)
!
!        ;; No default was set
!        (read-string
!         "grep.el: No `grep-find-command' available. Press RET.")
!        (list nil nil nil nil)))
!       ((not grep-find-command-template)
         (read-string
!       "grep.el: No `grep-find-command-template' available. Press RET.")
!        (list nil nil nil nil))
!       (t
!        (let* ((default-regexp
!               (or (funcall (or find-tag-default-function
!                                (get major-mode 'find-tag-default-function)
!                                'find-tag-default))
!                   ""))
!             (regexp (read-string
!                      (concat "Search for"
!                              (if (and default-regexp
!                                       (> (length default-regexp) 0))
!                                  (format " (default %s): " default-regexp) ": 
"))
!                      nil 'grep-regexp-history default-regexp))
!             (default-files
!                    (or (and (stringp (buffer-file-name))
!                             (let ((fn (file-name-nondirectory 
(buffer-file-name)))
!                                   (aliases grep-files-aliases)
!                                   alias)
!                               (while aliases
!                                 (setq alias (car aliases)
!                                       aliases (cdr aliases))
!                                 (if (string-match (wildcard-to-regexp (cdr 
alias)) fn)
!                                     (setq aliases nil)
!                                   (setq alias nil)))
!                               (cdr alias)))
!                        (car grep-files-history)))
!                  (files (read-string
!                          (concat "Search for \"" regexp
!                                  "\" in files (default " default-files
!                                  "): ")
!                          nil 'grep-files-history default-files))
!                  (dir
!                   (read-directory-name "Base directory: " nil 
default-directory t)))
!        (list regexp files dir current-prefix-arg))))))
!   (when regexp
!     (if (or (null files)  ;; backwards compatible non-interactive call
!           (eq grep-prompt-style 'shell)
!           (equal current-prefix-arg '(4)))
!       ;; REGEXP is command line
!       (compilation-start regexp 'grep-mode)
!       (when files
!       (let ((mf (assoc files grep-files-aliases)))
!         (if mf
!             (setq files (cdr mf)))))
!       (let ((command (grep-expand-template
!                     grep-find-command-template
!                     regexp
!                     grep-ignore-case
!                     (and files (concat "-name "
!                                        (shell-quote-argument files)))
!                     nil  ;; we change default-directory to dir
!                     (and grep-find-ignored-directories
!                          (concat "\\( -path '*/"
!                                  (mapconcat #'identity
!                                             grep-find-ignored-directories
!                                             "' -o -path '*/")
!                                  "' \\) -prune -o "))))
!           (default-directory (file-name-as-directory (expand-file-name dir)))
!           (null-device nil))          ; see grep
!       (when command
!         (if (or (eq grep-prompt-style 'post)
!                 (equal current-prefix-arg '(16)))
!             (setq command
!                   (read-from-minibuffer "Confirm: "
!                                         command nil nil 'grep-find-history))
!           (push command grep-find-history))
!         (compilation-start command 'grep-mode))))))

  ;;;###autoload
  (defalias 'find-grep 'grep-find)

  (provide 'grep)

  ;; arch-tag: 5a5b9169-a79d-4f38-9c38-f69615f39c4d

--
Kim F. Storm <address@hidden> http://www.cua.dk