Co jest w Twoim.emacs?

Mój ulubiony fragment. The ultimate in 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)

Tak więc podczas edycji lisp / scheme widzisz następujące rzeczy:

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

Mam to do zmiany yes lub no podpowiedź do y lub n podpowiedź:

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

Mam je do uruchomienia Emacsa bez tak dużej "fanfary" , którą dostałem od tego pytania.

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

I funkcja Steve 'a Yegge' a do zmiany nazwy edytowanego pliku wraz z odpowiadającym mu buforem:

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

Jedna rzecz, która może okazać się bardzo przydatna: zanim zrobi się za duży, spróbuj podzielić go na wiele plików dla różnych zadań: My. emacs ustawia moją ścieżkę ładowania i ładuje kilka plików - mam wszystkie ustawienia specyficzne dla trybu w mode-configs.el, skróty klawiszowe w keys.el, itd

Mój .emacs jest tylko 127 linii, oto najbardziej przydatne małe fragmenty:

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

Powoduje to, że pliki*~, które znajduję w katalogu, trafiają do specjalnego katalogu, w tym przypadku .~

;; 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

To ustawia uniquify, który zmienia te brzydkie Pliki itd. nazwy buforów można uzyskać, gdy wiele plików ma tę samą nazwę w znacznie bardziej jednoznaczną nazwę, używając tyle całej ścieżki pliku, ile musi.

To nie jest cały zestaw i kaboodle, ale to niektóre z bardziej przydatnych fragmentów, które zebrałem:

(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 ([email protected])")
  (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)))

Mam wiele innych, które już zostały wymienione, ale są one absolutnie niezbędne w mojej opinii:

(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

Możesz zajrzeć tutaj: http://www.dotemacs.de/

I moje .emacs jest dość długi, aby umieścić go tutaj, jak również, więc to sprawi, że odpowiedź nie zbyt czytelne. W każdym razie, jeśli chcesz, mogę ci go wysłać.

Również polecam Ci przeczytać to: http://steve.yegge.googlepages.com/my-dot-emacs-file

Oto kilka kluczowych mapowań, od których jestem zależny:

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

Kilka innych rzeczy, głównie dla rozwoju 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))

Aby odświeżyć edytowaną stronę z poziomu Emacsa

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

Stosowany w połączeniu z http://hyperstruct.net/projects/mozlab

Moją konfigurację (zarówno w html, jak i w archiwum tar ' ed) znajdziesz na Moja Strona. Zawiera wiele ustawień dla różnych trybów

Ten blok jest dla mnie najważniejszy:

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

Staram się zachować swoje .Emacs zorganizowany. Konfiguracja zawsze będzie w toku, ale zaczynam być zadowolony z ogólnej struktury.

Wszystko jest pod ~/.elisp, katalogiem, który jest pod kontrolą wersji (używam git, jeśli to jest interesujące). ~/.emacs po prostu wskazuje na ~/.elisp/dotemacs, która sama się ładuje ~/.elisp/cfg/init. Ten plik z kolei importuje Różne pliki konfiguracyjne za pomocą require. Oznacza to, że pliki konfiguracyjne muszą zachowywać się jak tryby: importują rzeczy, które zależą od i provide same na końcu pliku, np. (provide 'my-ibuffer-cfg). Przedrostek wszystkich identyfikatorów zdefiniowanych w mojej konfiguracji to my-.

Organizuję konfigurację w odniesieniu do trybów/tematów/zadań, a nie według ich implikacji technicznych, np. ja nie mam oddzielnego pliku konfiguracyjnego, w którym wszystkie są zdefiniowane.

My init.el definiuje następujący hook, aby upewnić się, że Emacs rekompiluje pliki konfiguracyjne po zapisaniu (skompilowany Elisp ładuje się dużo szybciej, ale nie chcę robić tego kroku ręcznie):

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

To jest struktura katalogów dla ~/.elisp:

~/.elisp/todo.org: plik w trybie Org, w którym śledzę rzeczy, które nadal muszą być zrobione (+elementy listy życzeń).

~/.elisp/dotemacs: Cel dowiązania symbolicznego dla ~/.emacs, loads ~/.elisp/cfg/init.

~/.elisp/cfg: moje własne pliki konfiguracyjne.

~/.elisp/modes: tryby, które składają się tylko z jednego pliku.

~/.elisp/packages: wyrafinowane tryby z lispem, dokumentacją i prawdopodobnie pliki zasobów.

Używam GNU Emacs, ta wersja nie ma realnego wsparcia dla pakietów. Dlatego organizuję je ręcznie, zwykle w ten sposób: ~/.elisp/packages/foobar-0.1.3 jest katalogiem głównym pakietu. Podkatalog lisp zawiera wszystkie pliki Lispu i {[20] } jest miejscem, do którego trafia dokumentacja. ~/.elisp/packages/foobar jest dowiązaniem symbolicznym, które wskazuje na aktualnie używaną wersję pakietu, dzięki czemu nie muszę zmieniać plików konfiguracyjnych, gdy coś aktualizuję. Dla niektórych pakietów przechowuję plik ~/.elisp/packages/foobar.installation wokół, w którym trzymam notatki o procesie instalacji. Ze względów wydajnościowych kompiluję wszystkie pliki elisp w nowo zainstalowanych pakietach, jeśli domyślnie tak nie jest.

Oto kilka moich rzeczy:

Wstawia datę w formacie ISO 8601:

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

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

Dla programistów C++ tworzy szkielet klasy (nazwa klasy będzie taka sama jak nazwa pliku bez rozszerzenia):

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

Automatycznie tworzy nawiasy zamykające:

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

Używam paredita do łatwej (e)obsługi Lispu i minibuffera ido-mode.

Trudno odpowiedzieć na to pytanie, ponieważ każdy używa Emacsa do bardzo różnych celów.

Zobacz kategorię EmacsWiki ' s DotEmacs. Zawiera wiele linków do stron zajmujących się tym pytaniem.

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

Ustawiłem kilka przydatnych skrótów do stron internetowych i wyszukiwań za pomocą 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))

Blog o tym, jak to działa tutaj

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

Również polecam te:

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

Również pozbywam się zbędnych rzeczy z gui

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

Jedna linia do zmiany ścieżki ładowania Jedna linia do załadowania biblioteki init Jedna linia do ładowania plików init Emacsa

Oczywiście "pliki init Emacsa" są dość liczne, po jednym na konkretną rzecz, ładowane w deterministycznej kolejności.

Emacs-starter-kit jako baza, to dodałem.. vimpulse.el, whitespace.el, yasnippet, textmate.el i newsticker.el.

W moim ~/.emacs.D / $USERNAME.el (dbr.plik:

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

Zawsze Zapisz mój config w svn http://my-trac.assembla.com/ez-conf/browser/emacs.d

Po przeczytaniu tego, pomyślałem, że dobrze byłoby mieć prostą stronę tylko dla najlepszych .modyfikacje Emacsa. Zapraszam do zamieszczania i głosowania na nie tutaj:

Http://dotemacs.slinkset.com/

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

Jestem nowy w Emacsie, w moimplik emacs jest

• Konfiguracja wcięcia
• color theme
• PHP mode, coffee mode i JS2 mode
• ido mode

FWIWemacs jest tutaj:

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

Dużo rzeczy: https://github.com/tavisrudd/emacs.d

El-get znacznie ułatwiło zarządzanie it i zależnościami: https://github.com/tavisrudd/emacs.d/blob/master/dss-init-el-get.el

Dla Scala kodery

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

Moja konfiguracja Emacsa rozrosła się na przestrzeni lat i mam tam wiele przydatnych rzeczy, ale jeśli mam dwie funkcje, to prawdopodobnie byłyby to te.

Zdefiniuj C-X w górę i C-x W DÓŁ, aby przesunąć bieżącą linię lub w dół, utrzymując kursor we właściwym miejscu:

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