“Goto Anything” de Sublime Text 2(o búsqueda instantánea) para Emacs?

sublimetext emacs24

Question

Probé Sublime Text 2 recientemente, y encontré Goto Anything extremadamente útil para navegar por el código fuente (el símbolo Ctrl-P @ parece funcionar muy bien). ¿Hay algo similar para Emacs? Preferiblemente algo que simplemente funciona, sin una tonelada de elisp personalizado.

Lo que he probado hasta ahora:

1. He visto Helm and Anything , pero por lo que entiendo, ninguno de ellos es capaz de realizar una búsqueda "instantánea" real (ver edición abajo).

2. He usado multi-occur-in-matching-buffers , pero parece que no puede satisfacer el criterio "instantáneo".

3. imenu / idomenu funciona bien para archivos individuales, pero no funciona en todos los archivos.

Actualmente utilizo el # 2 y el # 3 juntos, como un pobre sustituto de Goto Anything.

Si no es un clon exacto de Goto Anything, entonces podría arreglármelas con una solución de búsqueda instantánea ingenua (una que busca una cadena determinada en todos los búferes abiertos y muestra los resultados de forma dinámica). Así que eso es aceptable también.

Uso Emacs 24.2, por lo que cualquier elisp solo para v24 también está bien.

EDITAR : Le di a Helm otra oportunidad, a sugerencia de event_jr , y encontré que sí admite búsquedas instantáneas en todos los buffers abiertos. helm-multi-occur + helm-follow-mode acerca sorprendentemente a la satisfacción de mis necesidades, los únicos problemas menores son (a riesgo de sonar delicados):

• No he encontrado una manera de activar el helm-follow-mode automáticamente cuando ejecuto helm-multi-occur . Tengo que invocarlo manualmente con Cc Cf ¿Alguien quiere tomar una oportunidad con un fragmento de elisp? (ver edición # 2 abajo)

• no es "inteligente" como Goto Anything de ST2 (es decir, no entiende los "símbolos" en el código fuente, como hace Goto Anything).

EDITAR # 2 : Ahora tengo la mayoría de Goto Anything, gracias a la respuesta de event_jr a continuación (y, por supuesto, gracias al creador de Helm, Thierry Volpiatto ). Lo recomiendo de todo corazón a cualquiera que busque una característica similar. A continuación se muestra el elisp que estoy usando actualmente:

;; instant recursive grep on a directory with helm
(defun instant-rgrep-using-helm ()
  "Recursive grep in a directory."
  (interactive)
  (let ((helm-after-initialize-hook #''helm-follow-mode))
    (helm-do-grep)))


;; instant search across all buffers with helm
(defun instant-search-using-helm ()
  "Multi-occur in all buffers backed by files."
  (interactive)
  (let ((helm-after-initialize-hook #''helm-follow-mode))
    (helm-multi-occur
     (delq nil
           (mapcar (lambda (b)
                     (when (buffer-file-name b) (buffer-name b)))
                   (buffer-list))))))

;; set keybindings
(global-set-key (kbd "C-M-s") ''instant-search-using-helm)
(global-set-key (kbd "C-M-S-s") ''helm-resume)
(global-set-key (kbd "C-M-g") ''instant-rgrep-using-helm)

Answer 1

Sólo usa el timón.

Tal vez sea más configuración de la que pediste, pero una vez que la configures a tu gusto, debería ser bastante cómoda. Muy parecido a Emacs;).

Y deberías presentar un error con Thierry para obtener más valores predeterminados amigables para principiantes. Él es muy sensible con los problemas.

timón-multi-ocurrir

Principalmente, el "suceso" interactivo de múltiples búferes se proporciona a través de helm-multi-occur . Si ejecuta el comando, notará que primero debe seleccionar algunos búferes (use C-SPC para seleccionar de la lista, M-SPC para seleccionar todos). Luego, puede ingresar su consulta en el siguiente aviso. Es fácil hacer su propia versión que omita la selección del búfer de esta manera:

(eval-after-load "helm-regexp"
    ''(setq helm-source-moccur
           (helm-make-source "Moccur"
               ''helm-source-multi-occur :follow 1)))

(defun my-helm-multi-all ()
  "multi-occur in all buffers backed by files."
  (interactive)
  (helm-multi-occur
   (delq nil
         (mapcar (lambda (b)
                   (when (buffer-file-name b) (buffer-name b)))
                 (buffer-list)))))

lista de buffers del timón

A menudo, no le importan las apariciones exactas de la cadena de consulta, pero desea una lista de todos los buffers que la contienen.

helm-buffers-list tiene algunos trucos bajo la manga. El primer símbolo que especifique es el filtrado por modo mayor, y puede usar el prefijo "@" para limitar la lista a los búferes que contienen una cadena.

A saber, "ruby @prompt" le mostrará una lista de búferes cuyo modo mayor contiene "ruby" y cuyo contenido contiene "prompt". O simplemente puede usar "@prompt" para mostrar todos los buffers que contienen "prompt".

Potente y cómodo una vez que te acostumbras.

EDITAR modificó my-helm-multi-all para habilitar helm-follow-mode.

EDIT 2 actualiza el código de helm-follow-mode timón para reflejar los cambios del timón.

EDIT 3 actualizado nuevamente para reflejar los cambios del timón

Answer 2

1. Heml está lejos de la búsqueda borrosa de ST3.

2. Fiplr parece prometedor pero no funciona en mi computadora portátil (vea el primer número en el github)

3. Simp.el parece a Fiplr pero tampoco funciona en mi final.

4. Projectile funciona para mí! ¡Aquí está tu solución!

También utilicé ido-mode y flx-ido para la búsqueda difusa,

y para la forma vertical de mostrar resultados, uso esto en mis .emacs:

;; Display ido results vertically, rather than horizontally
(setq ido-decorations (quote ("/n-> " "" "/n   " "/n   ..." "[" "]" " [No match]" " [Matched]" " [Not readable]" " [Too big]" " [Confirm]")))
(defun ido-disable-line-truncation () (set (make-local-variable ''truncate-lines) nil))
(add-hook ''ido-minibuffer-setup-hook ''ido-disable-line-truncation)
(defun ido-define-keys () ;; C-n/p is more intuitive in vertical layout
  (define-key ido-completion-map (kbd "C-n") ''ido-next-match)
  (define-key ido-completion-map (kbd "C-p") ''ido-prev-match))
(add-hook ''ido-setup-hook ''ido-define-keys)

Answer 3

Emacs tiene Projectile satisfacer su necesidad:

• saltar a un archivo en proyecto
• multi-ocurrir en buffers de proyectos

Answer 4

Para emacs personalizo y modifico esta solución (para usar el timón de instalación):

(defun helm-occur-from-point (initial-value)
  "Invoke `helm-occur'' from point."
  (interactive)
  (let ((input initial-value)
        (bufs (list (buffer-name (current-buffer)))))
    ;; (isearch-exit)
    (helm-occur-init-source)
    (helm-attrset ''moccur-buffers bufs helm-source-occur)
    (helm-set-local-variable ''helm-multi-occur-buffer-list bufs)
    (helm-set-local-variable
     ''helm-multi-occur-buffer-tick
     (cl-loop for b in bufs
              collect (buffer-chars-modified-tick (get-buffer b))))
    (helm :sources ''helm-source-occur
          :buffer "*helm occur*"
          :history ''helm-grep-history
          :input input
          :truncate-lines t)))

(defun get-point-text ()
    "Get ''interesting'' text at point; either word, or region"
    (if mark-active
        (buffer-substring (mark) (point))
      (thing-at-point ''symbol)))
  (defun helm-occur-1 (initial-value)
    "Preconfigured helm for Occur with initial input."
    (helm-occur-from-point initial-value))
  (defun bk-helm-occur ()
    "Invoke helm-occur with initial input configured from text at point"
    (interactive)
    (helm-occur-1 (get-point-text)))
  (global-set-key (kbd "M-s-o") ''bk-helm-occur)

primario basado en @ver https://news.ycombinator.com/item?id=6872508 pero en las últimas versiones del timón no funciona pero se corrigió con mis cambios (solo copie / pegue desde algunos módulos internos del timón)

Answer 5

Icicles ofrece algunas características que son similares a lo que parece que estás buscando.

1. Cx b y Cx Cf , para elegir búferes o archivos, permite la finalización múltiple: puede escribir un patrón para que coincida con el búfer / nombre de archivo y / o un patrón para que coincida con el contenido en el buffer / file . Los candidatos se filtran incrementally medida que escribe (lo que llama "instantáneo" es lo que Emacs llama "incremental"). Puede refinar uno o ambos patrones de búsqueda progressively , reduciendo las opciones de diferentes maneras. Puede visitar cualquier número de buffers / archivos que coincidan, al mismo tiempo. También puede usar el mismo método para buscar los archivos marcados en Dired: CF

2. Cc ` ( icicle-search ) busca incrementalmente en múltiples buffers o archivos. De nuevo, refinamiento progresivo, etc.

La principal diferencia entre # 1 y # 2 es esta:

• Para el # 1, solo desea encontrar buffers o archivos coincidentes. No te importa de inmediato encontrar incidencias particulares, cualquier coincidencia es suficiente.

• Para el # 2, proporciona los buffers o archivos para buscar, y desea navegar entre los resultados de búsqueda.

También puede usar el # 1 para ubicar los buffers y archivos que desea, luego buscar su contenido: el patrón de coincidencia de contenido que utilizó por última vez está disponible como el patrón de búsqueda de Isearch ( Cs ).