Como pesquisar recursivamente o conteúdo do arquivo grep em um diretório / subdiretórios no Emacs?

Estou usando o Emacs há algum tempo e ainda assim, de alguma forma, não consigo entender qual é a melhor maneira de (recursivamente) grep para uma string em um diretório (project) e obter os resultados apresentados como um buffer direcionado ou em alguns outros maneira útil. Por favor me esclareça.

Bem, como a pergunta original não menciona rgrep, vou adiante e aponto aqui. Esta é a opção mais simples já incorporada ao Emacs, e eu achei que era mais do que suficiente para a maioria das coisas.

A partir da documentação,

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

A pesquisa é limitada a nomes de arquivos que correspondem ao padrão de shell FILES.

Assim, por exemplo, para pesquisar todos os arquivos python sob o meu diretório home para usos de some_function, gostaria de chamá-lo com some_function, *.py, ~/como os argumentos. Os resultados são exibidos em um novo buffer.

Eu felizmente uso M-x find-grep-diredpor anos. Ele retorna os resultados como um buffer direcionado, que você pode usar.

Solução 1 (melhor solução):

Conselho de instalação ( https://github.com/abo-abo/swiper/blob/master/counsel.el )

Então M-x counsel-git-grep.

Nenhuma configuração é necessária (o git conhece a raiz e os arquivos do projeto a serem excluídos). Ambos git grepe counselé eficiente.

O projeto precisa ser gerenciado pelo git.

conselho exige o modo de hera.

Solução 2:

Esta solução usa grep e funciona em qualquer projeto. É inferior à Solução 1 porque é mais lenta e precisa de configuração manual. Também é baseado no modo ivy.

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

Você precisa criar .dir-locals.el para configurar simple-project-root, consulte https://www.gnu.org/software/emacs/manual/html_node/emacs/Directory-Variables.html para obter detalhes técnicos

O código na solução 2 é apenas um protótipo. Minha implementação real é muito mais complexa. Veja counsel-etags-grepem https://github.com/redguardtoo/counsel-etags/blob/master/counsel-etags.el

Resumo:

Essas são as duas melhores soluções que conheço.

Se existirem outras soluções melhores, elas precisam pelo menos resolver os problemas abaixo para estarem prontas para a produção,

• como obter a palavra-chave grep (por exemplo, obter palavra-chave da região selecionada)

• escapar da palavra-chave

• se existir um programa grep mais eficiente, devemos usá-lo (ripgrep, the_silver_searcher / ag, ... etc), ou então usar o grep padrão

• a janela do candidato deve usar a largura total da tela e os usuários podem filtrar os candidatos interativamente (é por isso que as pessoas usam a hera ou o leme)

• devemos mostrar o caminho relativo na janela do candidato

• capaz de reutilizar o resultado grepped anterior. Portanto, o resultado anterior deve ser salvo. Você pode usar ivy-resumede ivyou helm-resumedehelm

• Quando você salva o resultado anterior recebido, o contexto do resultado anterior também deve ser salvo. Por exemplo, no código da Solução 2. default-directoryé o contexto. Consulte https://github.com/abo-abo/swiper/issues/591 para obter mais detalhes.

• Expressão regular estendida deve ser usada porque é mais simples e já é usada por counsel-git-grepthe_silver_searcher / ag.

Gostaria de adicionar outra solução à solução do @chen bin, que também usa counsel(mas você não precisa ter um projeto mantido gitpara isso).

Você precisa instalar o ag (o pesquisador prateado) e counselfornece o comando counsel-agque pesquisa o diretório atual pela string inserida.

Se você deseja pesquisar em um projeto (não apenas no diretório de trabalho atual), adicione-o ao seu .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)))

Esta função será usada agpara pesquisar recursivamente o diretório raiz do projeto.

Editar : a função acima é padronizada com o símbolo no ponto de pesquisa. Se você não gostar desse comportamento, substitua (thing-at-point 'symbol)por nil. E se você quiser que os resultados da pesquisa sejam impressos em bufferC-c C-o

Edit2 : se você ripgrepinstalou, você pode substituí counsel-ag-lo counsel-rgpela função acima e ela também ficará boa :)

Aqui está um exemplo de uma função grep personalizada que recebe recursivamente o conteúdo do arquivo (usando uma regexp para o termo de pesquisa) em um diretório e seus subdiretórios e exibe os resultados com linhas de contexto antes e depois. As bibliotecas internas compile.ele grep.elfornecem vários métodos para ir para o local no arquivo que contém os resultados da pesquisa. Não é necessário instalar mais nada para este exemplo funcionar - tudo o que é necessário é uma versão completa do Emacs e um computador com o greputilitário instalado. A variável grep-programpode ser ajustada para apontar para um local específico do greputilitário, se o padrão não for suficiente.

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