Usando Emacs como una IDE

Tengo que recomendar Emacs Code Browser como un entorno más "tradicional" IDE para emacs.

EDITAR: También ahora recomiendo Magit muy por encima de la interfaz VCS estándar en emacs.

En lugar de ejecutar un comando make en la ventana de Shell, ¿has probado la compilación M-x? Ejecutará su comando make, mostrará los errores y, en muchos casos, hará que sea muy fácil saltar a la línea de código que causó el error si la salida incluye nombres de archivo y números de línea.

Si eres un fanático de los IDE, es posible que también desees ver el paquete de la barra de velocidad de emacs (barra de velocidad M-x). Y, si aún no lo ha hecho, aprenda cómo usar las tablas de etiquetas para navegar por su código.

Hay esquinas de emacs que una vez descubiertas te hacen más productivo de una manera que nunca pensaste. Como han mencionado otros, el uso de etiquetas es una forma fantástica y rápida de hacer zoom alrededor de su código fuente y usar M-/(dabbrev-expand) a menudo hace exactamente lo que espera al completar un nombre de variable.

El uso de ocurrir es útil para obtener un búfer con todas las apariciones de una expresión regular en un búfer. Eso es realmente útil cuando refactoriza el código y busca fragmentos de código o usos de variables, o si usa marcadores TODO en sus archivos de origen y desea visitarlos todos.

las funciones de líneas de alineación, campos numéricos, reemplazar-regexp y rectángulo pueden ser realmente útiles para tomar un volcado de alguna herramienta y convertirlo en datos útiles como un programa elisp o una hoja de cálculo delimitada por comas.

Escribí una página sobre IDE como cosas que puedes hacer con emacs

http://justinsboringpage.blogspot.com/2007/09/11-visual-studio-tricks-in-emacs.html

Aprender elisp es otra excelente manera de responder por sí mismo qué más puede hacer emacs más allá de lo que un IDE típico puede hacer.

Por ejemplo, he escrito en el blog acerca de cómo escribir funciones de ayuda de Perforce como la culpa (escribir tus propios medios para que puedas hacer que se comporte exactamente como quieras) ...

http://justinsboringpage.blogspot.com/2009/01/who-changed-line-your-working-on-last.html

También escribí un código que crea comentarios dinámicamente para una función en un punto, que coincide con los estándares de codificación con los que estoy trabajando.

Ninguno de mi código elisp es particularmente bueno, y la mayoría ya existe en las bibliotecas, pero es realmente útil poder hacer que Emacs haga cosas personalizadas que solo surgen durante un día de trabajo.

Puede encontrar una descripción detallada de la integración de emacs y control de versiones en mi sitio . También estoy trabajando en un artículo sobre el uso de Emacs como entorno de desarrollo para muchos idiomas: C/C++, Java, Perl, LISP/Scheme, Erlang, etc.

Bien, todos aquí están dando sugerencias perfectas para hacer de Emacs un gran IDE.

Pero cualquier persona debe tener en cuenta que, cuando personalice sus emacs con una gran cantidad de extensiones (especialmente con las de verificación de tipos sobre la marcha, búsquedas de definición de funciones, etc.) emacs se cargará muy, muy lentamente para un editor.

Para solucionar esto, recomendaría encarecidamente usar emacs en server mode.

Es bastante simple de usar, no es necesario personalizar el archivo de inicio. Solo necesitas iniciar emacs en modo daemon;

emacs --daemon

Esto creará un servidor emacs, luego puede conectarlo desde la terminal o desde la interfaz gráfica de usuario. También recomendaría crear algunos alias para que sea más fácil llamar.

alias ec="emacsclient -t"
alias ecc="emacsclient -c &"
# some people also prefer this but no need to fight here;
alias vi="emacsclient -t"

De esta manera, los emacs se activarán incluso más rápido de lo que promete Gedit.

El único problema posible aquí, si está ejecutando el demonio emacs de su usuario ocasional, probablemente no pueda conectar el servidor emacs como root.

Por lo tanto, si necesita abrir un archivo que tenga acceso de root; use tramp en su lugar. Simplemente ejecute su cliente emacs con su usuario normal y abra archivos como este;

C-x C-f
/Sudo:[email protected]/some/file/that/has/root/access/permissions
# on some linux distro it might be `/su:[email protected]` 

Esto me hizo la vida más fácil, puedo abrir mi pesada pitón personalizada IDE en milisegundos de esta manera. También es posible que desee agregar emacs --daemon al inicio de su sistema, o crear un archivo de escritorio para emacsclient. Eso depende de usted.

Más información sobre el demonio emacs y el cliente emacs se pueden encontrar en wiki;

http://www.emacswiki.org/emacs/EmacsAsDaemon

http://www.emacswiki.org/emacs/EmacsClient

Para el control de versiones, hay varias cosas que puede usar, dependiendo del sistema de control de versiones que use. Pero algunas de las funcionalidades son comunes a todas ellas.

vc.el es la forma integrada de manejar el control de versiones a nivel de archivo. Tiene backends para la mayoría de los sistemas de control de versiones. Por ejemplo, el backend de Subversion viene con Emacs, y hay backends git y otros disponibles de otras fuentes.

El comando más útil es C-x v v (vc-next-action) que realiza la siguiente acción apropiada para el archivo que está visitando. Esto podría significar actualizar desde el repositorio o aceptar sus cambios, vc.el también vuelve a enlazar C-x C-q para registrar y retirar archivos si está utilizando un sistema que lo necesita (como RCS).

Otros comandos muy útiles son C-x v l y C-x v = que le muestra el registro y la diferencia actual del archivo que está utilizando.

Pero para obtener una productividad real, debe evitar usar los comandos vc.el de un solo archivo que no sean simples. Hay varios paquetes que pueden ofrecerle una descripción general del estado de todo su árbol, y darle más poder, sin mencionar la capacidad de crear compromisos coherentes que abarcan varios archivos.

La mayoría de estos están muy influenciados o basados ​​en el original pcl-cvs/pcvs para CVS. Incluso hay dos de ellos que vienen con Subversion, psvn.el y dsvn.el. Hay paquetes para git etc.

Estoy de acuerdo en que deberías aprender sobre la compilación de M-x (vincular eso y el siguiente error de M-x a una secuencia de teclas corta).

Obtenga información sobre los enlaces para el control de versiones (por ejemplo, vc-diff, vc-next-action, etc.)

Busque en los registros. No solo puede recordar ubicaciones en búferes, sino configuraciones de ventanas completas (C-x r w - window-configuration-to-register).

Un punto de partida (que puede no ser obvio) para explorar las _ VC características de Emacs es M-x vc-next-action .

Realiza la "siguiente operación de control de versión lógica" en el archivo actual, dependiendo del estado del archivo y el VC backend. Entonces, si el archivo no está bajo el control de versiones, lo registra, si el archivo ha sido cambiado, los cambios se envían, etc.

Se necesita un poco de tiempo para acostumbrarme, pero me parece muy útil.

La combinación de teclas predeterminada es C-x v v

Hay un TFS.el para la integración de emacs en Microsoft TFS . Funciona con cualquier TFS, incluido el TFS que ejecuta Codeplex.com.

Pasos básicos para la configuración:

1. Coloque tfs.el en su ruta de carga.

2. En su archivo .emacs:

   (require 'tfs)
   (setq tfs/tf-exe  "c:\\vs2008\\common7\\ide\\tf.exe")
   (setq tfs/login "/login:domain\\userid,password")
         -or-
   (setq tfs/login (getenv "TFSLOGIN"))  ;; if you have this set
   

3. también en su archivo .emacs, establezca enlaces de teclas locales o globales para los comandos tfs. al igual que:

   (global-set-key  "\C-xvo" 'tfs/checkout)
   (global-set-key  "\C-xvi" 'tfs/checkin)
   (global-set-key  "\C-xvp" 'tfs/properties)
   (global-set-key  "\C-xvr" 'tfs/rename)
   (global-set-key  "\C-xvg" 'tfs/get)
   (global-set-key  "\C-xvh" 'tfs/history)
   (global-set-key  "\C-xvu" 'tfs/undo)
   (global-set-key  "\C-xvd" 'tfs/diff)
   (global-set-key  "\C-xv-" 'tfs/delete)
   (global-set-key  "\C-xv+" 'tfs/add)
   (global-set-key  "\C-xvs" 'tfs/status)
   (global-set-key  "\C-xva" 'tfs/annotate)
   (global-set-key  "\C-xvw" 'tfs/workitem)
   

la compilación, el siguiente error y el error anterior son todos comandos bastante importantes para el desarrollo de C++ en Emacs (también funciona bien en la salida de grep). Etags, visit-tags-table, y find-tag también son importantes. completed.el es uno de los grandes hacks anónimos del siglo 20 y puede acelerar su piratería de C++ en un orden de magnitud. Ah, y no olvidemos a Ediff.

Todavía tengo que aprender a usar el control de versiones sin visitar un Shell, pero ahora que estoy ejecutando me comprometo con mucha más frecuencia (con git) probablemente tenga que hacerlo.

Yo uso emacs en Windows. El módulo de compilación es agradable, pero quería que la compilación fuera más inteligente con respecto a la línea de comandos de compilación que sugiere. Es posible usar "Variables de archivo" para especificar compile-command , pero quería algo un poco más inteligente que eso. Así que escribí una pequeña función para ayudar. Adivina el comando de compilación a usar, para pedirle al usuario que, cuando ejecute compile.

La función de búsqueda busca un archivo vbproj o csproj o sln, y si se encuentra, sugiere msbuild. Luego mira el nombre del archivo del búfer y, según eso, sugiere cosas diferentes. Un archivo .wxs significa que es un proyecto WIX, y es probable que desee crear un MSI, por lo que la lógica de conjetura sugiere un comando nake para el MSI. Si se trata de un módulo de Javascript, la sugerencia es ejecutar jslint-for-wsh.js para quitar el archivo .js. Como una alternativa, sugiere nmake.

El código que uso se ve así:

(defun cheeso-guess-compile-command ()
  "set `compile-command' intelligently depending on the
current buffer, or the contents of the current directory."
  (interactive)
  (set (make-local-variable 'compile-command)
       (cond
        ((or (file-expand-wildcards "*.csproj" t)
             (file-expand-wildcards "*.vcproj" t)
             (file-expand-wildcards "*.vbproj" t)
             (file-expand-wildcards "*.shfbproj" t)
             (file-expand-wildcards "*.sln" t))
         "msbuild ")

        ;; sometimes, not sure why, the buffer-file-name is
        ;; not set.  Can use it only if set.
        (buffer-file-name
         (let ((filename (file-name-nondirectory buffer-file-name)))
           (cond

            ;; editing a .wxs (WIX Soluition) file
            ((string-equal (substring buffer-file-name -4) ".wxs")
             (concat "nmake "
                     ;; (substring buffer-file-name 0 -4) ;; includes full path
                     (file-name-sans-extension filename)
                     ".msi" ))

            ;; a javascript file - run jslint
            ((string-equal (substring buffer-file-name -3) ".js")
             (concat (getenv "windir")
                     "\\system32\\cscript.exe c:\\users\\cheeso\\bin\\jslint-for-wsh.js "
                     filename))

            ;; something else - do a typical .exe build
            (t
             (concat "nmake "
                     (file-name-sans-extension filename)
                     ".exe")))))
        (t
         "nmake "))))


(defun cheeso-invoke-compile-interactively ()
  "fn to wrap the `compile' function.  This simply
checks to see if `compile-command' has been previously set, and
if not, invokes `cheeso-guess-compile-command' to set the value.
Then it invokes the `compile' function, interactively."
  (interactive)
  (cond
   ((not (boundp 'cheeso-local-compile-command-has-been-set))
    (cheeso-guess-compile-command)
    (set (make-local-variable 'cheeso-local-compile-command-has-been-set) t)))
  ;; local compile command has now been set
  (call-interactively 'compile))

;; in lieu of binding to `compile', bind to my monkeypatched function
(global-set-key "\C-x\C-e"  'cheeso-invoke-compile-interactively)

Intenté hacer esto como "consejo previo" para la función de compilación, pero no pude hacer que funcionara satisfactoriamente. Así que definí una nueva función y la vinculé a la misma combinación de teclas que he estado usando para compile.

EDITARahora hay " smarter-compile.el " que lleva esta idea un paso más allá.

También puede encontrar tabbar útil. Emula el único comportamiento que me perdí al pasar de Eclipse a Emacs. Limitado a "," y "." para moverse a la barra de pestañas anterior y siguiente, le permite cambiar el búfer con Ctrl-x b todo el tiempo.

Desafortunadamente, la página web mencionada no proporciona la versión correcta para descargar. La mayoría de las versiones de Ubuntu, sin embargo, lo entregan en sus paquetes emacs-goodies.

Sé que este es un post muy antiguo. Pero esta pregunta es válida para los principiantes de emacs.

En mi opinión, la mejor manera de usar emacs como un ide es usar un protocolo de servidor de idioma con emacs. Puede encontrar toda la información sobre servidores de idiomas en el sitio web vinculado.

Para una configuración rápida, le insto a ir a esta página eglot . IMO eglot hace su trabajo bastante bien. Se integra bien con paquetes de auto completaciones como empresa. Proporciona encontrar referencia, y más.

También para un depurador, es posible que necesite depuradores específicos para idiomas específicos. Puedes usar gdb desde emacs. Sólo escribe M-x gdb.

Para compilar su código, es mejor usar comandos de Shell. Estoy trabajando en este proyecto eproj . Te llevará un tiempo completarlo. Pero todo lo que hace es asignar el comando de Shell al tipo de proyecto. Y construye tu proyecto a través de Shell. Hace lo mismo para ejecutar el comando. Puede que necesite ayuda para completar este proyecto. No está listo para su uso, pero si conoce un poco de elispio, puede revisar el código.

Aparte de eso, siempre es mejor usar el comando de compilación de emacs.

Para el control de versiones, todavía no he visto ningún otro paquete que pueda igualar el poder de magit . Es específico para git. También para git hay otro paquete git-timemachine, que me parece muy útil.

El protocolo del servidor de idioma proporciona la búsqueda de objetos y de clase.

Se puede usar un árbol de proyecto para la interfaz ide con treemacs .

También hay una biblioteca de interacción del proyecto llamada proyectil .

Para la finalización automática, encuentro modo empresa muy útil.

Realmente se puede hacer emacs para hacer cualquier cosa.

En la búsqueda de documentación: eso depende de su (s) lenguaje (s) de programación.

Las bibliotecas de C y las llamadas al sistema normalmente se documentan en las páginas man. Para eso puedes usar M-x man. Algunas cosas pueden documentarse mejor en las páginas de información; utilizar M-x info.

Para elisp en sí, use C-h f. Para python, use >>> help(<function, class, module>) en el intérprete.

Me parece que la mayoría de los otros idiomas ofrecen documentación en formato html. Para eso, intente un navegador integrado (yo uso w3m). Establezca su variable de entorno BROWSER en un script de envoltura alrededor de emacsclient -e "(w3m-goto-url-new-session \"[email protected]\")" (en * nix), en caso de que algo pueda abrir un navegador y desee que se abra dentro de emacs.

En los últimos años, Clang se convirtió en una parte importante del soporte de Emacs C++. Atila Neves tuvo una charla sobre CppCon 2015: "Emacs como IDE en C++"

Es una charla de 16 minutos, donde muestra soluciones para los siguientes temas:

• Saltar a la definición
• Autocompletar
• Resaltado de sintaxis sobre la marcha
• Encontrar archivo en proyecto

Las diapositivas se pueden encontrar aquí .

En el estilo de Windows de Unix o X, no sé si hay un IDE integrado que funciona para todo.

Para interactuar con los depuradores, solo un componente de un IDE, considere realgud . La otra cosa que me parece útil son los analizadores para los mensajes de ubicación, de modo que si tiene un seguimiento de la pila de llamadas y desea editar en un lugar particular en la pila de llamadas, esta interfaz de usuario puede hacer eso.

Con mucho, este programa podría utilizar una mejora. Pero también podría usar a las personas que trabajan en él para mejorarlo.

Descargo de responsabilidad: trabajo en realgud