Come cercare ricorsivamente / contenuti di file grep in una directory / sottodirectory in Emacs?

Sto usando Emacs da un po 'di tempo e ancora in qualche modo non riesco a capire quale sia il modo migliore per eseguire (in modo ricorsivo) grep per una stringa all'interno di una directory (di progetto) e ottenere i risultati presentati come un buffer diretto o in alcuni ancora di più modo utile. Per favore, illuminami.

Bene, poiché la domanda originale non menziona rgrep, andrò avanti e lo indicherò qui. Questa è l'opzione più semplice già integrata in Emacs e l'ho trovata più che sufficiente per la maggior parte delle cose.

Dalla documentazione,

Recursively grep for REGEXP in FILES in directory tree rooted at DIR.

La ricerca è limitata ai nomi di file corrispondenti a FILES della shell.

Così, per esempio, per cercare tutti i file python sotto la mia home directory per usi some_function, lo chiamerei con some_function, *.py, ~/come gli argomenti. I risultati vengono visualizzati in un nuovo buffer.

Uso felicemente M-x find-grep-diredda anni. Restituisce i risultati come buffer diretto, che è possibile utilizzare.

Soluzione 1 (migliore soluzione):

Consigli per l'installazione ( https://github.com/abo-abo/swiper/blob/master/counsel.el )

Poi M-x counsel-git-grep.

Nessuna installazione necessaria (git conosce la radice del progetto e i file da escludere). Entrambi git greped counselè efficiente.

Il progetto deve essere gestito da git.

il consiglio richiede la modalità edera.

Soluzione 2:

Questa soluzione utilizza grep e funziona su qualsiasi progetto. È inferiore alla Soluzione 1 perché è più lento e necessita di installazione manuale. Si basa anche sulla modalità edera.

(defvar simple-project-root "~/.emacs.d")
(defun simple-grep ()
  (interactive)
  (unless (featurep 'ivy)
    (require 'ivy))
  (let* ((default-directory (file-name-as-directory simple-project-root))
         (keyword (read-string "Keyword:")))
    (ivy-read (format "Grep at %s:" simple-project-root)
              (split-string (shell-command-to-string (format "grep -rsnI %s ." keyword)) "\n" t)
              :action (lambda (val)
                        (let* ((lst (split-string val ":"))
                               (linenum (string-to-number (cadr lst))))
                          ;; open file
                          (find-file (car lst))
                          ;; goto line if line number exists
                          (when (and linenum (> linenum 0))
                            (goto-char (point-min))
                            (forward-line (1- linenum))))))))

È necessario creare .dir-locals.el per l'installazione simple-project-root, consultare https://www.gnu.org/software/emacs/manual/html_node/emacs/Directory-Variables.html per i dettagli tecnici

Il codice nella soluzione 2 è solo un prototipo. La mia vera implementazione è molto più complessa. Vedi counsel-etags-grepin https://github.com/redguardtoo/counsel-etags/blob/master/counsel-etags.el

Sommario:

Quelle sono le due migliori soluzioni che conosco.

Se esistono altre soluzioni migliori, devono almeno risolvere i problemi sottostanti per essere pronti per la produzione,

• come ottenere la parola chiave in grep (ad esempio, ottenere la parola chiave dalla regione selezionata)

• sfuggire alla parola chiave

• se esiste un programma grep più efficiente, dovremmo usarlo (ripgrep, the_silver_searcher / ag, ... ecc), oppure fallback del grep predefinito

• la finestra del candidato deve utilizzare l'intera larghezza dello schermo e gli utenti possono filtrare i candidati in modo interattivo (ecco perché le persone usano l'edera o il timone)

• dovremmo mostrare il percorso relativo nella finestra candidata

• in grado di riutilizzare il precedente risultato grepped. Quindi il risultato precedente dovrebbe essere salvato. Puoi usare ivy-resumeda ivyo helm-resumedahelm

• Quando si salva il risultato precedente grepped, è necessario salvare anche il contesto del risultato precedente. Ad esempio, nel codice della soluzione 2. default-directoryè il contesto. Vedi https://github.com/abo-abo/swiper/issues/591 per maggiori dettagli.

• L'espressione regolare estesa deve essere utilizzata perché è più semplice ed è già utilizzata da counsel-git-grepe the_silver_searcher / ag.

Vorrei aggiungere un'altra soluzione alla soluzione di @chen bin che utilizza anche counsel(ma per questo non è necessario avere un progetto gestito git).

Devi installare ag (il cercatore d'argento) e counselfornisce il comando counsel-agche cerca nella directory corrente la stringa inserita.

Se vuoi cercare all'interno di un progetto (non solo la directory di lavoro corrente), aggiungi questo al tuo .emacs: -

  (defun rag/counsel-ag-project-at-point ()
    "use counsel ag to search for the word at point in the project"
    (interactive)
    (counsel-ag (thing-at-point 'symbol) (projectile-project-root)))

Questa funzione utilizzerà agper cercare ricorsivamente nella directory principale del progetto.

Modifica : la funzione di cui sopra si imposta automaticamente sul simbolo nel punto di ricerca. Se non ti piace quel comportamento, sostituiscilo (thing-at-point 'symbol)con nil. E se vuoi i risultati della ricerca nel suo buffer premiC-c C-o

Edit2 : se hai ripgrepinstallato, puoi sostituirlo counsel-agcon counsel-rgnella funzione sopra e andrà altrettanto bene :)

Ecco un esempio di una funzione grep personalizzata che greps ricorsivamente il contenuto del file (usando una regexp per il termine di ricerca) in una directory e nelle sue sottodirectory e visualizza i risultati con linee di contesto prima e dopo. Il built-in compile.ele le grep.ellibrerie prevedono diversi metodi per passare alla posizione nel file contenente i risultati della ricerca. Non è necessario installare nient'altro per far funzionare questo esempio: tutto ciò che serve è una versione completa di Emacs e un computer su cui sia grepinstallata l' utilità. La variabile grep-programpuò essere regolata per puntare a una posizione particolare grepdell'utilità se il valore predefinito non è sufficiente.

(defun recursive-grep ()
"Recursively grep file contents.  `i` case insensitive; `n` print line number;
`I` ignore binary files; `E` extended regular expressions; `r` recursive"
(interactive)
  (let* ((search-term (read-string "regex:  "))
         (search-path
           (directory-file-name (expand-file-name (read-directory-name "directory:  "))))
         (default-directory (file-name-as-directory search-path))
         (grep-command
           (concat
             grep-program
             " "
             "-inIEr --color=always -C2"
             " "
             search-term
             " "
             search-path)))
    (compilation-start grep-command 'grep-mode (lambda (mode) "*grep*") nil)))