¿Qué hay en tu .emacs?

https://stackoverflow.com/questions/154097

03-07-2019
|

Pregunta

Cambié de computadora varias veces recientemente y en algún momento perdí mi .emacs.Estoy tratando de reconstruirlo nuevamente, pero mientras lo hago, pensé en elegir otras configuraciones buenas que usan otras personas.

Entonces, si usas Emacs, ¿qué hay en su .emacs?

El mío es bastante vacío en este momento y solo contiene:

¡Modo de bloqueo de fuente global! (global-font-lock-mode 1)
Mis preferencias personales con respecto a sangría, tabulaciones y espacios.
Utilice el modo cperl en lugar del modo perl.
Un atajo para la compilación.

¿Qué crees que es útil?

Solución

Utilice el sitio definitivo de archivos de puntos . Agregue sus '.emacs' aquí. Lea los '.emacs' de los demás.

Otros consejos

Mi fragmento favorito. Lo último en Emacs eye candy:

;; real lisp hackers use the lambda character
;; courtesy of stefan monnier on c.l.l
(defun sm-lambda-mode-hook ()
  (font-lock-add-keywords
   nil `(("\\<lambda\\>"
   (0 (progn (compose-region (match-beginning 0) (match-end 0)
        ,(make-char 'greek-iso8859-7 107))
      nil))))))
(add-hook 'emacs-lisp-mode-hook 'sm-lambda-mode-hook)
(add-hook 'lisp-interactive-mode-hook 'sm-lamba-mode-hook)
(add-hook 'scheme-mode-hook 'sm-lambda-mode-hook)

Entonces ves, es decir, lo siguiente al editar lisp / esquema:

(global-set-key "^Cr" '(λ () (interactive) (revert-buffer t t nil)))

Tengo esto para cambiar las indicaciones yes o no a y o n indicaciones:

(fset 'yes-or-no-p 'y-or-n-p)

Tengo estos para iniciar Emacs sin tanto " fanfarria " que obtuve de esta pregunta .

(setq inhibit-startup-echo-area-message t)
(setq inhibit-startup-message t)

Y Función Steve Yegge para cambiar el nombre de un archivo que usted ' re editar junto con su búfer correspondiente:

(defun rename-file-and-buffer (new-name)
  "Renames both current buffer and file it's visiting to NEW-NAME."
  (interactive "sNew name: ")
  (let ((name (buffer-name))
 (filename (buffer-file-name)))
    (if (not filename)
 (message "Buffer '%s' is not visiting a file!" name)
      (if (get-buffer new-name)
   (message "A buffer named '%s' already exists!" new-name)
 (progn
   (rename-file name new-name 1)
   (rename-buffer new-name)
   (set-visited-file-name new-name)
   (set-buffer-modified-p nil))))))

Una cosa que puede resultar muy útil: antes de que sea demasiado grande, intente dividirlo en varios archivos para diversas tareas: Mis .emacs solo establecen mi ruta de carga y cargan un montón de archivos: tengo todo mi configuración específica de modo en mode-configs.el, combinaciones de teclas en keys.el, etc.

Mi .emacs tiene solo 127 líneas, estos son los pequeños fragmentos más útiles:

;; keep backup files neatly out of the way in .~/
(setq backup-directory-alist '(("." . ".~")))

Esto hace que los archivos * ~ que encuentro desordenados en el directorio vayan a un directorio especial, en este caso. ~

;; uniquify changes conflicting buffer names from file<2> etc
(require 'uniquify)
(setq uniquify-buffer-name-style 'reverse)
(setq uniquify-separator "/")
(setq uniquify-after-kill-buffer-p t) ; rename after killing uniquified
(setq uniquify-ignore-buffers-re "^\\*") ; don't muck with special buffers

Esto configura uniquify que cambia esos archivos feos < 2 > etc. nombres de búfer que se obtienen cuando varios archivos tienen el mismo nombre en un nombre mucho más claro e inequívoco utilizando la mayor parte de la ruta completa del archivo como es necesario.

Eso es todo ... el resto es algo bastante estándar que estoy seguro de que todos conocen.

Este no es todo el kit y el kaboodle, pero son algunos de los fragmentos más útiles que he reunido:

(defadvice show-paren-function (after show-matching-paren-offscreen
                                      activate)
  "If the matching paren is offscreen, show the matching line in the                               
echo area. Has no effect if the character before point is not of                                   
the syntax class ')'."
  (interactive)
  (let ((matching-text nil))
    ;; Only call `blink-matching-open' if the character before point                               
    ;; is a close parentheses type character. Otherwise, there's not                               
    ;; really any point, and `blink-matching-open' would just echo                                 
    ;; "Mismatched parentheses", which gets really annoying.                                       
    (if (char-equal (char-syntax (char-before (point))) ?\))
        (setq matching-text (blink-matching-open)))
    (if (not (null matching-text))
        (message matching-text))))

;;;;;;;;;;;;;;;
;; UTF-8
;;;;;;;;;;;;;;;;;;;;
;; set up unicode
(prefer-coding-system       'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
;; This from a japanese individual.  I hope it works.
(setq default-buffer-file-coding-system 'utf-8)
;; From Emacs wiki
(setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING))
;; Wwindows clipboard is UTF-16LE 
(set-clipboard-coding-system 'utf-16le-dos)


(defun jonnay-timestamp ()
  "Spit out the current time"
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

(defun jonnay-sign ()
  "spit out my name, email and the current time"
  (interactive)
  (insert "-- Jonathan Arkell (jonathana@criticalmass.com)")
  (jonnay-timestamp))


;; Cygwin requires some seriosu setting up to work the way i likes it
(message "Setting up Cygwin...")
(let* ((cygwin-root "c:")
       (cygwin-bin (concat cygwin-root "/bin"))
       (gambit-bin "/usr/local/Gambit-C/4.0b22/bin/")
       (snow-bin "/usr/local/snow/current/bin")
       (mysql-bin "/wamp/bin/mysql/mysql5.0.51a/bin/"))
   (setenv "PATH" (concat cygwin-bin ";" ;
                          snow-bin ";" 
                          gambit-bin ";"
                          mysql-bin ";"
                          ".;")  
           (getenv "PATH"))
   (setq exec-path (cons cygwin-bin exec-path)))

(setq shell-file-name "bash")
(setq explicit-shell-file-name "bash")

(require 'cygwin-mount)
(cygwin-mount-activate)
(message "Setting up Cygwin...Done")


; Completion isn't perfect, but close
(defun my-shell-setup ()
   "For Cygwin bash under Emacs 20+"
   (setq comint-scroll-show-maximum-output 'this)
   (setq comint-completion-addsuffix t)
   (setq comint-eol-on-send t)
   (setq w32-quote-process-args ?\")
   (make-variable-buffer-local 'comint-completion-addsuffix))

(setq shell-mode-hook 'my-shell-setup)
(add-hook 'emacs-startup-hook 'cygwin-shell)


; Change how home key works
(global-set-key [home] 'beginning-or-indentation)
(substitute-key-definition 'beginning-of-line 'beginning-or-indentation global-map)


(defun yank-and-down ()
  "Yank the text and go down a line."
  (interactive)
  (yank)
  (exchange-point-and-mark)
  (next-line))

(defun kill-syntax (&optional arg)
  "Kill ARG sets of syntax characters after point."
  (interactive "p")
  (let ((arg (or arg 1))
    (inc (if (and arg (< arg 0)) 1 -1))
    (opoint (point)))
    (while (not (= arg 0))
      (if (> arg 0)
      (skip-syntax-forward (string (char-syntax (char-after))))
    (skip-syntax-backward (string (char-syntax (char-before)))))
      (setq arg (+ arg inc)))
    (kill-region opoint (point))))

(defun kill-syntax-backward (&optional arg)
  "Kill ARG sets of syntax characters preceding point."
  (interactive "p")
  (kill-syntax (- 0 (or arg 1))))

(global-set-key [(control shift y)] 'yank-and-down)
(global-set-key [(shift backspace)] 'kill-syntax-backward)
(global-set-key [(shift delete)] 'kill-syntax)


(defun insert-file-name (arg filename)
  "Insert name of file FILENAME into buffer after point.
  Set mark after the inserted text.

  Prefixed with \\[universal-argument], expand the file name to
  its fully canocalized path.

  See `expand-file-name'."
  ;; Based on insert-file in Emacs -- ashawley 2008-09-26
  (interactive "*P\nfInsert file name: ")
  (if arg
      (insert (expand-file-name filename))
      (insert filename)))

(defun kill-ring-save-filename ()
  "Copy the current filename to the kill ring"
  (interactive)
  (kill-new (buffer-file-name)))

(defun insert-file-name ()
  "Insert the name of the current file."
  (interactive)
  (insert (buffer-file-name)))

(defun insert-directory-name ()
  "Insert the name of the current directory"
  (interactive)
  (insert (file-name-directory (buffer-file-name))))

(defun jonnay-toggle-debug ()
  "Toggle debugging by toggling icicles, and debug on error"
  (interactive)
  (toggle-debug-on-error)
  (icicle-mode))


(defvar programming-modes
  '(emacs-lisp-mode scheme-mode lisp-mode c-mode c++-mode 
    objc-mode latex-mode plain-tex-mode java-mode
    php-mode css-mode js2-mode nxml-mode nxhtml-mode)
  "List of modes related to programming")

; Text-mate style indenting
(defadvice yank (after indent-region activate)
  (if (member major-mode programming-modes)
      (indent-region (region-beginning) (region-end) nil)))

Tengo muchos otros que ya se han mencionado, pero estos son absolutamente necesarios en mi opinión:

(transient-mark-mode 1) ; makes the region visible
(line-number-mode 1)    ; makes the line number show up
(column-number-mode 1)  ; makes the column number show up

Puede mirar aquí: http://www.dotemacs.de/

Y mi .emacs es bastante largo para ponerlo aquí también, por lo que hará que la respuesta no sea muy legible. De todos modos, si lo desea, puedo enviárselo.

También le recomendaría que lea esto: http: // steve. yegge.googlepages.com/my-dot-emacs-file

Aquí hay algunas asignaciones clave de las que me he vuelto dependiente:

(global-set-key [(control \,)] 'goto-line)
(global-set-key [(control \.)] 'call-last-kbd-macro)
(global-set-key [(control tab)] 'indent-region)
(global-set-key [(control j)] 'join-line)
(global-set-key [f1] 'man)
(global-set-key [f2] 'igrep-find)
(global-set-key [f3] 'isearch-forward)
(global-set-key [f4] 'next-error)
(global-set-key [f5] 'gdb)
(global-set-key [f6] 'compile)
(global-set-key [f7] 'recompile)
(global-set-key [f8] 'shell)
(global-set-key [f9] 'find-next-matching-tag)
(global-set-key [f11] 'list-buffers)
(global-set-key [f12] 'shell)

Algunas otras cosas diversas, principalmente para el desarrollo de C ++:

;; Use C++ mode for .h files (instead of plain-old C mode)
(setq auto-mode-alist (cons '("\\.h$" . c++-mode) auto-mode-alist))

;; Use python-mode for SCons files
(setq auto-mode-alist (cons '("SConstruct" . python-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("SConscript" . python-mode) auto-mode-alist))

;; Parse CppUnit failure reports in compilation-mode
(require 'compile)
(setq compilation-error-regexp-alist
      (cons '("\\(!!!FAILURES!!!\nTest Results:\nRun:[^\n]*\n\n\n\\)?\\([0-9]+\\)) test: \\([^(]+\\)(F) line: \\([0-9]+\\) \\([^ \n]+\\)" 5 4)
            compilation-error-regexp-alist))

;; Enable cmake-mode from http://www.cmake.org/Wiki/CMake_Emacs_mode_patch_for_comment_formatting
(require 'cmake-mode)
(setq auto-mode-alist
      (append '(("CMakeLists\\.txt\\'" . cmake-mode)
                ("\\.cmake\\'" . cmake-mode))
              auto-mode-alist))

;; "M-x reload-buffer" will revert-buffer without requiring confirmation
(defun reload-buffer ()
  "revert-buffer without confirmation"
  (interactive)
  (revert-buffer t t))

Para actualizar la página web que está editando desde Emacs

(defun moz-connect()
  (interactive)
  (make-comint "moz-buffer" (cons "127.0.0.1" "4242"))
  (global-set-key "\C-x\C-g" '(lambda () 
                (interactive)
                (save-buffer)
                (comint-send-string "*moz-buffer*" "this.BrowserReload()\n"))))

Utilizado en combinación con http://hyperstruct.net/projects/mozlab

Puede encontrar mi configuración (ambas en html & amp; en el archivo tar'ed) en mi sitio . Contiene muchas configuraciones para diferentes modos

Este bloque es el más importante para mí:

(setq locale-coding-system 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

Sin embargo, nunca he sido claro en la diferencia entre esos. Culto a la carga, supongo ...

Intento mantener mis .emacs organizados. La configuración siempre será un trabajo en progreso, pero estoy empezando a estar satisfecho con la estructura general.

Todas las cosas están bajo ~/.elisp, un directorio que está bajo control de versiones (uso git, si eso es de interés). ~/.emacs simplemente apunta a ~/.elisp/dotemacs que solo carga ~/.elisp/cfg/init. Ese archivo a su vez importa varios archivos de configuración a través de require. Esto significa que los archivos de configuración deben comportarse como modos: importan cosas de las que dependen y provide ellos mismos al final del archivo, p. (provide 'my-ibuffer-cfg). Prefijo todos los identificadores que están definidos en mi configuración con my-.

Organizo la configuración con respecto a los modos / temas / tareas, no por sus implicaciones técnicas, p. no tengo un archivo de configuración separado en el que se definen todos combinaciones de teclas o caras.

Mi init.el define el siguiente enlace para asegurarse de que Emacs recompila archivos de configuración cada vez que se guarda (Elisp compilado se carga mucho más rápido pero no quiero hacer este paso manualmente):

;; byte compile config file if changed
(add-hook 'after-save-hook
          '(lambda ()
                   (when (string-match
                          (concat (expand-file-name "~/.elisp/cfg/") ".*\.el$")
                          buffer-file-name)
           (byte-compile-file buffer-file-name))))

Esta es la estructura de directorios para ~/.elisp/todo.org:

~/.elisp/cfg: archivo de modo Org en el que llevo un registro de las cosas que aún deben hacerse (+ elementos de la lista de deseos).

~/.elisp/modes: Objetivo de enlace simbólico para ~/.elisp/packages, carga ~/.elisp/packages/foobar-0.1.3.

lisp: Mis propios archivos de configuración.

info: Modos que consisten solo en un único archivo.

~/.elisp/packages/foobar: modos sofisticados con lisp, documentación y probablemente archivos de recursos.

Uso GNU Emacs, esa versión no tiene soporte real para paquetes. Por lo tanto, los organizo manualmente, generalmente así: ~/.elisp/packages/foobar.installation es el directorio raíz del paquete. El subdirectorio <=> contiene todos los archivos lisp y <=> es donde va la documentación. <=> es un enlace simbólico que apunta a la versión actualmente utilizada del paquete, de modo que no necesito cambiar mis archivos de configuración cuando actualizo algo. Para algunos paquetes guardo un archivo <=> en el que guardo notas sobre el proceso de instalación. Por razones de rendimiento, compilo todos los archivos elisp en paquetes recién instalados, si este no fuera el caso por defecto.

Aquí hay un par de mis propias cosas:

Inserta la fecha en formato ISO 8601:

(defun insertdate ()
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

(global-set-key [(f5)] 'insertdate)

Para los programadores de C ++, crea un esqueleto de clase (el nombre de la clase será el mismo que el nombre del archivo sin extensión):

(defun createclass ()
  (interactive)
  (setq classname (file-name-sans-extension (file-name-nondirectory   buffer-file-name)))
  (insert 
"/**
  * " classname".h 
  *
  * Author: Your Mom
  * Modified: " (format-time-string "%Y-%m-%d") "
  * Licence: GNU GPL
  */
#ifndef "(upcase classname)"
#define "(upcase classname)"

class " classname "
{
  public:
    "classname"();
    ~"classname"();

  private:

};
#endif
"))

Crea automáticamente paréntesis de cierre:

(setq skeleton-pair t)
(setq skeleton-pair-on-word t)
(global-set-key (kbd "[") 'skeleton-pair-insert-maybe)
(global-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(global-set-key (kbd "{") 'skeleton-pair-insert-maybe) 
(global-set-key (kbd "<") 'skeleton-pair-insert-maybe)

uso paredit para un fácil manejo de (e) lisp y terminaciones de minibúfer en modo ido.

Es difícil responder a esta pregunta, porque todos usan Emacs para propósitos muy diferentes.

Además, una mejor práctica puede ser BESAR tus dotemacs. Desde Interfaz de personalización sencilla es ampliamente compatible entre los modos de Emacs, debe almacenar toda su personalización en su custom-file (que puede ser un lugar separado en sus dotemacs), y para dotemacs , coloque solo la configuración de la ruta de carga, el paquete requiere, los ganchos y las asociaciones de teclas. Una vez que comience a usar Emacs Starter Kit , todo es útil un montón de configuraciones también pueden eliminarse de sus dotemacs.

Vea la categoría DotEmacs de EmacsWiki. Proporciona muchos enlaces a páginas que abordan esta pregunta.

(put 'erase-buffer 'disabled nil)
(put 'downcase-region 'disabled nil)
(set-variable 'visible-bell t)
(set-variable 'tool-bar-mode nil)
(set-variable 'menu-bar-mode nil)

(setq load-path (cons (expand-file-name "/usr/share/doc/git-core/contrib/emacs") load-path))
 (require 'vc-git)
 (when (featurep 'vc-git) (add-to-list 'vc-handled-backends 'git))
 (require 'git)
 (autoload 'git-blame-mode "git-blame"
           "Minor mode for incremental blame for Git." t)

Configuré algunos atajos útiles para páginas web y búsquedas usando webjump

(require 'webjump)
(global-set-key [f2] 'webjump)
(setq webjump-sites
      (append '(
        ("Reddit Search" .
         [simple-query "www.reddit.com" "http://www.reddit.com/search?q=" ""])
        ("Google Image Search" .
         [simple-query "images.google.com" "images.google.com/images?hl=en&q=" ""])
        ("Flickr Search" .
         [simple-query "www.flickr.com" "flickr.com/search/?q=" ""])
        ("Astar algorithm" . 
         "http://www.heyes-jones.com/astar")
        )
          webjump-sample-sites))

Publicación de blog sobre cómo funciona esto aquí

http: //justinsboringpage.blogspot .com / 2009/02 / search-reddit-flickr-and-google-from.html

También recomiendo estos:

(setq visible-bell t) ; no beeping

(setq transient-mark-mode t) ; visually show region

(setq line-number-mode t) ; show line numbers

(setq global-font-lock-mode 1) ; everything should use fonts

(setq font-lock-maximum-decoration t)

También me deshago de algunas de las cosas superfluas de la interfaz gráfica de usuario

  (if (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
  (if (fboundp 'tool-bar-mode) (tool-bar-mode -1))
  (if (fboundp 'menu-bar-mode) (menu-bar-mode -1)))

Una línea para modificar la ruta de carga Una línea para cargar mi biblioteca de inicio Una línea para cargar mis archivos de inicio de emacs

Por supuesto, el " archivos de inicio de emacs " son bastante numerosos, uno por cosa específica, cargados en un orden determinista.

kit de inicio-emacs como base, luego le he añadido.. vimpulse.el, whitespace.el, yasnippet, textmate.el y newsticker.el.

En mi archivo ~/.emacs.d/$USERNAME.el (dbr.el):

(add-to-list 'load-path (concat dotfiles-dir "/vendor/"))

;; Snippets
(add-to-list 'load-path "~/.emacs.d/vendor/yasnippet/")
(require 'yasnippet)

(yas/initialize)
(yas/load-directory "~/.emacs.d/vendor/yasnippet/snippets")

;; TextMate module
(require 'textmate)
(textmate-mode 'on)

;; Whitespace module
(require 'whitespace)
(add-hook 'ruby-mode-hook 'whitespace-mode)
(add-hook 'python-mode-hook 'whitespace-mode)

;; Misc
(flyspell-mode 'on)
(setq viper-mode t)
(require 'viper)
(require 'vimpulse)

;; IM
(eval-after-load 'rcirc '(require 'rcirc-color))
(setq rcirc-default-nick "_dbr")
(setq rcirc-default-user-name "_dbr")
(setq rcirc-default-user-full-name "_dbr")

(require 'jabber)

;;; Google Talk account
(custom-set-variables
 '(jabber-connection-type (quote ssl))
 '(jabber-network-server "talk.google.com")
 '(jabber-port 5223)
 '(jabber-server "mysite.tld")
 '(jabber-username "myusername"))

;; Theme
(color-theme-zenburn)

;; Key bindings
(global-set-key (kbd "M-z") 'undo)
(global-set-key (kbd "M-s") 'save-buffer)
(global-set-key (kbd "M-S-z") 'redo)

Guardar siempre mi configuración en svn http: // my-trac .assembla.com / ez-conf / browser / emacs.d

Después de leer esto, pensé que sería bueno tener un sitio simple solo para las mejores modificaciones de .emacs. Siéntase libre de publicarlos y votarlos aquí:

http://dotemacs.slinkset.com/

https://b7j0c.org/stuff/dotemacs.html

Soy nuevo en emacs, en mi archivo .emacs hay

configuración de sangría
tema de color
modo php, modo café y modo js2
modo ido

FWIW, mi .emacs está aquí:

http://svn.red-bean.com/repos/kfogel /trunk/.emacs

muchas cosas: https://github.com/tavisrudd/emacs.d

el-get ha facilitado mucho la administración y las dependencias: https://github.com/tavisrudd/emacs.d/blob/ master / dss-init-el-get.el

Para Scala codificadores

;; Load the ensime lisp code... http://github.com/aemoncannon/ensime
(add-to-list 'load-path "ENSIME_ROOT/elisp/")
(require 'ensime)
;; This step causes the ensime-mode to be started whenever ;; scala-mode is started for a buffer. You may have to customize this step ;; if you're not using the standard scala mode.
(add-hook 'scala-mode-hook 'ensime-scala-mode-hook)
;; MINI HOWTO:  ;; Open .scala file. M-x ensime (once per project)

Mi configuración de emacs ha crecido bastante a lo largo de los años y tengo muchas cosas útiles para mí, pero si tengo dos funciones, probablemente habrían sido esas.

Defina C-x ARRIBA y C-x ABAJO para mover la línea actual o hacia abajo manteniendo el cursor en el lugar correcto:

;Down/UP the current line
(global-set-key '[(control x) (up)] 'my-up-line)
(global-set-key '[(control x) (down)] 'my-down-line)
(defun my-down-line()
  (interactive)
  (let ((col (current-column)))
    (forward-line 1)
    (transpose-lines 1)
    (forward-line -1)
    (forward-char col)
    )
  )

(defun my-up-line()
  (interactive)
  (let ((col (current-column)))
    (transpose-lines 1)
    (forward-line -2)
    (forward-char col)
    )
  )

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow