Zorganizować zawartość ~ / .emacs.d / init.el i ~ / emacs.d?

28
  1. Kiedy dodajemy coraz więcej wierszy do ~/.emacs.d/init.elróżnych celów (dla trybu python, dla emacs-eclim, dla ...), plik staje się długi i mniej czytelny. Czy istnieje sposób na uporządkowanie jego zawartości?
  2. Mój obecny ~/.emacs.dwygląda tak

    $ ls *
    init.el
    
    auto-save-list:
    
    elisp:
    python-mode.el-6.1.3
    
    elpa:
    archives        auctex-readme.txt         s-20140910.334
    auctex-11.87.7  emacs-eclim-20140809.207
    
    eshell:
    history
    

    python-mode.el-6.1.3został zainstalowany ręcznie, podczas gdy emacs-eclim-20140809.207został zainstalowany przez elpa, i nie jestem w 100% pewien, że pozostałe rzeczy elpa/zostały wykonane przez elpa. Jak mogę uporządkować treść ~/.emacs.d/?

Tim
źródło

Odpowiedzi:

32

Ludzie używający mniejszych edytorów lubią dzielić swój kod na wiele plików. Jeśli używasz Emacsa, nie ma żadnego powodu: po prostu użyj jednego dużego pliku, który podzielisz na sekcje.

Każda sekcja powinna zaczynać się od

^L
;;; title of the section

gdzie wstawiasz ^Lznak, wpisując C-q C-l. Następnie możesz używać poleceń, takich jak C-x ]( forward-page) lub C-x n p( narrow-to-page), aby poruszać się po pliku. Aby uzyskać więcej informacji, zobacz Sekcja 25.4 (Strony) instrukcji Emacsa.

jch
źródło
16
Nie ma również specjalnego powodu, aby nie dzielić kodu na wiele plików. To zależy od tego, co chcesz oznaczać grupowanie rzeczy razem - jak chcesz, żeby się zachowywał. I może zależeć od tego, jak duży jest DUŻY. Może to zależeć od tego, czy fragmenty kodu są udostępniane innym osobom, na przykład bibliotekom.
Drew
2
Korzystając z komentarzy @ Drew, użytkownik może chcieć mieć różne konfiguracje dla różnych wersji i środowisk emacsa i odpowiednio załadować odpowiedni elisp. To powiedziawszy, podoba mi się wskazówka do paginacji.
Harvey
3
@Harvey: Podział na strony i używanie oddzielnych plików to niezależne sposoby porządkowania tekstu. Oczywiście możesz użyć obu. Używam paginacji we wszystkich moich bibliotekach, aby oddzielić sekcje. Ale mam też osobne biblioteki (pliki).
Drew
1
@ jch Jeśli używasz tego stylu, możesz również chcieć włączyć tryb Zarys mniejszy lub podobną funkcję, aby umożliwić składanie sekcji i funkcji. Złożenie wszystkich nagłówków najwyższego poziomu daje ładny przegląd wszystkich sekcji w konfiguracji Emacsa.
lunaryorn
@lunaryorn, próbowałem, ale zauważyłem, że jest to rozpraszające - przez większość czasu polecenia ruchu strony są wystarczające, tylko czasami muszę zawęzić. Być może moje .emacsi .wlnie są wystarczająco długie.
jch
20

Klasycznym sposobem jest podzielenie .emacsplików na osobne. Na przykład możesz przenieść wszystkie swoje treści internetowe, ~/.emacs.d/web-config.ela następnie załadować je do wewnątrz init.el:

(load "~/.emacs.d/web-config.el")

Jeśli chcesz zachować ~/.emacs.dnieco większą organizację, możesz również przenieść te pliki konfiguracyjne do ich własnego katalogu:

(load "~/.emacs.d/config/web.el")

Teraz możesz po prostu przejść do odpowiedniego pliku podczas wprowadzania zmian w konfiguracji.

Brakuje w tym zmiennych ustawianych za pomocą systemu dostosowywania. Wszystko to nadal będzie w głównym init.el. Najwyraźniej istnieje małe narzędzie zwane init split, które pozwala ci ustalać reguły, które ustawienia dostosowują, dokąd, ale nigdy nie korzystałem z niego osobiście. Alternatywnie system „dostosowywania” można skonfigurować tak, aby używał osobnego pliku do modyfikacji ustawień. Ustaw custom-filezmienną, aby określić, gdzie należy odczytać i zapisać ustawienia „dostosowywania” .

Jeśli chodzi o sam katalog, zawsze byłem zadowolony z domyślnego układu. Główną zmianą, którą wprowadziłem, było utworzenie katalogu dla wszystkich własnych niestandardowych pakietów i bibliotek, którymi nie zarządza package.el. Daje to jeden dom dla mojego niestandardowego elipsa, który nie jest związany z konfiguracją.

Tikhon Jelvis
źródło
Dzięki. (1) jaki jest katalog pakietów i bibliotek zarządzanych przez package.el? (2) Czy zawartość katalogu jest elpazarządzana przez elpa? Czy mogę przenieść je gdzie indziej?
Tim
2
Możesz określić osobny plik dla Dostosuj zmienne poprzez ustawienie custom-filezmiennej. Źródło
Kaushal Modi
@Tim: Katalog zarządzany przez package.el to elpa. Elpa nie jest pakietem lisp, to repozytorium pakietów. Package.el nadal doda wszystkie pakiety, które instaluje (czy to z elpa, czy z innego repozytorium - na przykład w twoim przypadku, nie sądzę, że eclim is s z elpa) w katalogu elpa. I tak, nie powinieneś martwić się o zawartość tego katalogu.
T. Verron
(Nie można już edytować) To, co napisałem powyżej, nie jest ściśle prawdą: elpa jest formatem archiwów pakietów, package.el jest menedżerem pakietów. Dla użytkownika nie ma prawdziwej różnicy między nimi. Mój komentarz powyżej pomylił elpa z GNU elpa, który jest jednym z dostępnych pakietów elpa (i jedynym oficjalnym).
T. Verron
16

Jeśli podoba Ci się tryb Org, możesz go użyć do uporządkowania .emacsbez dzielenia go. W mojej obecnej konfiguracji mój .emacsplik po prostu ładuje plik init.org, pod którym mam~/.emacs.d/init/init.org

(require 'org)

;; Load the actual configuration file
(org-babel-load-file
  (expand-file-name (concat user-emacs-directory "init/init.org")))

Używając różnych plików, grepzamiast prostego C-swyszukiwania czegoś, i tak dalej. Ponadto łatwiej jest dodać kilka poziomów do organizacji.

rlazo
źródło
1
Obecnie jestem w trakcie robienia tego, chociaż nie pomyślałem, aby użyć org-babel-load-file. Słodkie! (Przykłady: github.com/vermiculus/dotfiles/blob/… , github.com/larstvei/dot-emacs )
Sean Allred
Więcej informacji na temat używania trybu org dla konfiguracji Emacsa na to pytanie: Czy mogę użyć trybu org do strukturyzowania plików .emacs lub innego pliku konfiguracyjnego .el?
ShreevatsaR
9

Po prostu przenieś fragmenty kodu init.eldo oddzielnych plików (bibliotek), które następnie require. (Użyj providew bibliotekach, aby być require.) Umieść te pliki w dowolnym miejscu i load-pathodpowiednio je zaktualizuj .

Drew
źródło
Thanks. (1) for example? (2) what do you suggest to organize ~/.emacs.d/?
Tim
1
What do you mean by "organize the content of ~/.emacs.d/? You offer no specification of what you want. You are not constrained to having everything in one directory. You can put stuff anywhere you like, and modify load-path accordingly. If some program/tool only puts stuff in ~/.emacs.d/ (i.e., if you cannot tell it where to put stuff), then move it where you want it after that program/tool is done.
Drew
1
What do you mean by "for example"? What is it that you want an example of? (require 'foobar) is an example of using require. (add-to-list 'load-path "/my/lisp/dir") is an example of modifying load-path. (provide 'foobar) is an example of using provide.
Drew
by "organize the content of ~/.emacs.d/, I, as a human, can understand it better, not for emacs to understand. It is a habit, just like organizing your cabinet, drawers, bookshelves. For example, python-mode.el-6.1.3 was manually installed, while emacs-eclim-20140809.207 was installed by elpa. Are they both packages? If they are, is it a good idea to put them under one subdirectory of ~/.emacs.d/?
Tim
You are the human who can answer what organization might help you understand it better. (Emacs doesn't understand anything.) Use whatever folder structure you like. Call them cabinets, drawers, bookshelves, or just folders. And again, your init.el can load libraries located anywhere, not just within ~/.emacs.d/.
Drew
7

I use the suggestion by targzeta found on the Emacs Wiki: Load directory.

Basically I have a ~/.emacs.d/load-directory.el:

;;;; ~/.emacs.d/load-directory.el

;; Handy function to load recursively all '.el' files in a given directory
(defun load-directory (directory)
  "Load recursively all '.el' files in DIRECTORY."
  (dolist (element (directory-files-and-attributes directory nil nil nil))
    (let* ((path (car element))
           (fullpath (concat directory "/" path))
           (isdir (car (cdr element)))
           (ignore-dir (or (string= path ".") (string= path ".."))))
      (cond
       ((and (eq isdir t) (not ignore-dir))
        (load-directory fullpath))
       ((and (eq isdir nil) (string= (substring path -3) ".el"))
        (load (file-name-sans-extension fullpath)))))))

Then I just put separate files in my ~/.emacs.d/config:

~/.emacs.d/config ls
01-packages.el  02-style.el  03-modes.el  04-keybindings.el  05-functions.el

And finally I have this in my ~/.emacs.d/init.el:

;; Load all ".el" files under ~/.emacs.d/config directory.
(load "~/.emacs.d/load-directory")
(load-directory "~/.emacs.d/config")
Boccaperta-IT
źródło
The want us to provide more info than just a link - e.g., a summary description of what is at that link.
Drew
You're right, I edited my answer.
Boccaperta-IT
Hm. As a courtesy, at least, you should probably say that the code you swiped verbatim was written by targzeta. Summarizing a cross-referenced page does not mean plagiarizing its content. (Of course, if you are targzeta, then there is presumably no problem.)
Drew
You're right again, edited. Thanks.
Boccaperta-IT
Thanks. (I know it takes a little time to do it right, but it helps everyone a little more.)
Drew
5

There is obviously more than one way to skin this particular cat. My current favourite is to use outline-minor-mode with outshine. Excerpt:

;; * This here is my emacs init file
;; ** Many subsections with headlines like this one omitted
;; ** Customising modes
;; […] more lines omitted
;; *** Org and outline modes
(autoload 'outshine-hook-function "outshine")
(add-hook 'outline-minor-mode-hook 'outshine-hook-function)
;; […] and more
;; * Emacs Magic
;;; Local Variables:
;;; mode: emacs-lisp
;;; coding: utf-8
;;; mode: outline-minor
;;; fill-column: 79
;;; End:

Note that you will need to get outshine from your favourite package repository.

Harald Hanche-Olsen
źródło
1
I started out with outline-minor-mode, but found the keybindings too painful, and never quite found the time to do anything about it myself. So I moved to orgstruct-mode after discovering org-mode, but then I found out about outshine. Bliss! I currently use outline+outshine for all my structuring of elisp, latex and other files with their own major mode, and org-mode for all kinds of notes.
Harald Hanche-Olsen
2

I use the following structure to keep track of packages and files

~/.emacs.d
|-- elpa            ;; Package.el packages
|-- hack            ;; Development versions of packages (e.g. org, personal packages)
|-- single-lisp     ;; Individual lisp files from outside sources (e.g. EmacsWiki)
|-- site-lisp       ;; Lisp packages not managed by package.el (directories)
|-- user-config     ;; Machine/situation specific customization (work vs home)
|   `-- custom.el   ;; Customization settings
|-- lisp            ;; Individual .el files to keep init.el clean
|   `-- defaults.el ;; Default configuration settings
`-- init.el

I then use use-package to manage which packages are loaded and which customizations are set for each package. Most of the time only hack and elpa require updating, the other folders are often for one-off packages that I want to test or use briefly but do not need to load (even idly).

custom.el is for Customize settings, which I prefer not to use (and do not version even if I do use).

defaults.el is for general configuration (menu-bar, font, encoding, etc) that can then be overwritten in any .el file in user-config/ to allow for a system that will work as I expect, but can be adjusted to fit the environment.

I had previously tried to keep functions, macros, advice in separate packages to allow for delineation between content, but ran into definition/require issues so have put those back into init.el. They may eventually be put back into ~/.emacs.d/lisp/.

I try to keep init.el tidy, sort content by function and purpose so that finding it again will be straightforward. I've had the monolithic init.el file and kept adding new content at the end (or where I thought it might fit) and then would end up not knowing what I had added or where I had added it when I went to look for it (and sometimes searching using isearch did not help since I could not remember how I named things at the time).

Jonathan Leech-Pepin
źródło
2

All of the existing answers address best practices for organizing manually created files, like init.el and friends. Equally important is the organization of all the automatically created files from various packages, and for this the package no-littering is excellent.

Radon Rosborough
źródło
1

I added

  (when (string= (buffer-name) "init.el")
    (setq imenu-generic-expression
      '((nil "^;; \\[ \\(.*\\)" 1))))

to emacs-lisp-mode-hook. Then add to the file sections "yasnippet", "packaging", "java mode", etc. This Works nice for my 1000 lines of code (comments included).

EDIT: Finally i switch between sections with helm-imenu. Actually helm hooks into normal imenu function automagically so all i need is

       (local-set-key (kbd "C-*") 'imenu)
Matthias
źródło
You could be using a file local variable instead of a hook.
YoungFrog
1

I split my relatively small .emacs file into three parts:

  • emacs-custom.el for customizations, ripping out lots of bulky and useless data; the file is automatically rewritten without touching the main .emacs file, preventing spurious changes.

    (setq custom-file "~/.emacs-custom.el")
    (load custom-file)
    
  • lg-lib.el for code rather than configuration: loading my own libraries from nonstandard source locations rather than from the packages directory and defining various functions (mostly copied and hacked in the absence of a proper package); it is another large reduction of .emacs line count.

    (load "~/lg-lib")
    
  • The main .emacs file: without bulky code and bulky customization variables, it contains require calls for packages, variables that aren't part of the Customize system, and assorted function calls to load and initialize packages. I "organize" it by carefully keeping all lines pertaining to the same package or feature together, and further separating package loading and package-related settings from "core" functionality. A fairly representative excerpt:

    (require 'ido)
    (ido-mode t)
    
    (require 'auto-complete)
    (add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
    
    (require 'auto-complete-config)
    (ac-config-default)
    (global-auto-complete-mode t)
    

    These sections are tiny, but they would remain manageable with many more lines of configuration for each package.

Lorenzo Gatti
źródło
1

Follow the setup of an Emacs master, e.g., https://github.com/purcell/emacs.d

For example, regarding how to organize manually installed packages and packages installed from ELPA, Steven Purcell's setup has

a place for 3rd party code which isn't available in MELPA or other
package repositories. This directory and its immediate
subdirectories will be added to load-path at start-up time.

Notably, in Emacs 23.x, a backported package.el is automatically
downloaded and installed here

Why follow a master? A major point of my "Master emacs in one year" is that newbies can thus efficiently avoid setup overhead and "gotchas."

I understand that many people don't agree with me, but here's my case (detailed in my article):

I started using Emacs by using Purcell's well-respected (1403 GitHub stars as of Nov 2014!), stable (5 years in development) configuration. Despite starting from that, I still had many problems. Steve Purcell helped me solve all those problems. (I actually became his Padawan for over a year.) By using his setup, and using his repo's issues to report problems, and taking advantage of his experience, I avoided wasting much time. Even today, I still observe many people using git submodule to manage the third-party plugins. Both Steve and I gave up using git submodule for this because it can be such a PITA.

But if you are very confident of your skills or much prefer self-learning, this is not the path for you.

chen bin
źródło
2
"Cloning the setup from master": Without specific regard to the references you cite, which might provide wonderful features or advice (I haven't checked), I disagree in general that people should start by cloning init files or other setups from others. That has even been an explicitly discouraged policy, IIRC, as it can lead to problems. Better to start from scratch and be aware of (and even understand!), whatever you use as basic setup. Of course there is nothing wrong with studying and learning from what others have done. But blindly copying init files is not advisable. (Just one opinion.)
Drew
1
actually, I write my article because there are still many people believes that they should start from the scratch on the setup. it's not the best way for most people, as I observed, and unnecessarily hard way for newbies. just search
chen bin
1
It is "the best way for most people". Just search for discussions and advice against starting out by using someone else's init file. Search [email protected], and www.emacswiki.org, and [email protected], and even debbugs.gnu.org. That said, there is nothing wrong with sharing one's init file, to serve others as food for thought. The advice is for newbies not to start out that way; the advice is not for people not to share their own startup approaches and tips.
Drew
1
It's because of "survivorship bias". Many people give up before they know emacswiki or mailing list.
chen bin
0

An innovative and simple way to cleanup your .emacs.d folder is to use org-mode and outline everything using source blocks. Then, in your .emacs file, point to your config.org.

A wonderful resource on this is Harry Schwartz. He has a youtube video that touches and a blog post that explains the details. I was able to follow it as an emacs noob and get all setup. Works like a charm. 1 file for my entire init.

SeaDude
źródło