Organize o conteúdo de ~ / .emacs.d / init.el e ~ / emacs.d?

1. Quando adicionamos mais e mais linhas a ~/.emacs.d/init.elvários propósitos (no modo python, no emacs-eclim, no ...), o arquivo se torna longo e menos legível. Existe uma maneira de ajudar a organizar seu conteúdo?

2. Meu atual ~/.emacs.dé assim

   $ 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.3foi instalado manualmente, enquanto emacs-eclim-20140809.207foi instalado por elpae não tenho 100% de certeza de que as outras coisas elpa/foram por elpa. Como posso organizar o conteúdo de ~/.emacs.d/?

As pessoas que usam editores menores gostam de dividir seu código em vários arquivos. Se você estiver usando o Emacs, não há razão para fazer isso: basta usar um único arquivo grande, que você divide em seções.

Cada seção deve começar com

^L
;;; title of the section

onde você insere o ^Lcaractere digitando C-q C-l. Você pode usar comandos como C-x ]( forward-page) ou C-x n p( narrow-to-page) para navegar pelo arquivo. Consulte a Seção 25.4 (páginas) do manual do Emacs para obter mais informações.

Uma maneira clássica de fazer isso é dividi-lo .emacsem arquivos separados. Por exemplo, você pode mover todos os seus itens da Web para dentro ~/.emacs.d/web-config.ele carregá-los dentro init.el:

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

Se você deseja manter ~/.emacs.dum pouco mais organizado, também pode mudar esses arquivos de configuração em seu próprio diretório:

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

Agora você pode simplesmente pular para o arquivo apropriado ao fazer alterações na sua configuração.

Uma coisa que está faltando nisso são as variáveis ​​definidas pelo sistema de personalização. Estes ainda estarão todos no seu init.el principal. Aparentemente, existe um pequeno utilitário chamado init split, que permite que você faça regras sobre qual configuração de personalização vai para onde, mas eu nunca a usei. Como alternativa, o sistema "personalizar" pode ser configurado para usar um arquivo separado para suas modificações nas suas configurações. Defina a custom-filevariável para especificar onde as configurações de “personalização” devem ser lidas e gravadas .

No que diz respeito ao diretório em si, sempre fui feliz com o layout padrão. A principal alteração que fiz foi criar um diretório para todos os meus próprios pacotes e bibliotecas personalizados que não são gerenciados por package.el. Isso fornece um único lar ao meu elisp personalizado que não está relacionado à configuração.

Se você gosta do modo Org, pode usá-lo para organizar o seu .emacssem dividi-lo. Sob minha configuração atual, meu .emacsarquivo apenas inicializa um arquivo init.org que eu tenho em~/.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")))

Ao usar arquivos diferentes, é necessário, em grepvez de simples, C-sprocurar algo e assim por diante. Além disso, é mais fácil adicionar vários níveis à sua organização.

Apenas mova pedaços de código de init.elpara separar arquivos (bibliotecas), que você então require. (Use providenas bibliotecas para ser required.) Coloque esses arquivos onde quiser e atualize de load-pathacordo.

Eu uso a sugestão de targzeta encontrada no diretório Emacs Wiki: Load .

Basicamente, eu tenho um ~ / .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)))))))

Depois, basta colocar arquivos separados no meu ~ / .emacs.d / config:

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

E finalmente eu tenho isso no meu ~ / .emacs.d / init.el:

;; Load all ".el" files under ~/.emacs.d/config directory.
(load "~/.emacs.d/load-directory")
(load-directory "~/.emacs.d/config")

Obviamente, há mais de uma maneira de esfolar esse gato em particular. Meu favorito atual é usar outline-minor-modecom ofusca . Excerto:

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

Observe que você precisará se destacar do seu repositório de pacotes favorito.

Eu uso a seguinte estrutura para acompanhar pacotes e arquivos

~/.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

Em seguida, uso use-packagepara gerenciar quais pacotes são carregados e quais personalizações são definidas para cada pacote. Na maioria das vezes, apenas hacke elpaexigem atualização, as outras pastas geralmente são para pacotes únicos que eu quero testar ou usar brevemente, mas não precisam carregar (mesmo que ociosamente).

custom.el é para Personalizar configurações, que eu prefiro não usar (e não versão mesmo que eu use).

defaults.elé para configuração geral (barra de menus, fonte, codificação etc.) que pode ser substituída em qualquer arquivo .el user-config/para permitir um sistema que funcione conforme o esperado, mas que pode ser ajustado ao ambiente.

Eu já tinha tentado manter functions, macros, adviceem pacotes separados para permitir a delimitação entre conteúdo, mas correu para definição / exigem questões tão ter colocado os de volta em init.el. Eles podem eventualmente ser colocados de volta ~/.emacs.d/lisp/.

Tento me manter init.elorganizado, classificar o conteúdo por função e finalidade, para que seja fácil encontrá-lo novamente. Eu tinha o init.elarquivo monolítico e continuava adicionando novo conteúdo no final (ou onde eu achava que poderia caber) e depois acabava sem saber o que eu adicionei ou onde o adicionei quando fui procurá-lo (e às vezes, pesquisar usando isearchnão ajudou, pois não conseguia me lembrar de como nomeei as coisas na época).

Todas as respostas existentes abordam as práticas recomendadas para organizar arquivos criados manualmente , como init.elamigos e amigos. Igualmente importante é a organização de todos os arquivos criados automaticamente de vários pacotes e, para isso, o pacote no-litteringé excelente.

Eu adicionei

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

para o emacs-lisp-mode-hook. Em seguida, adicione às seções de arquivo "yasnippet", "empacotamento", "modo java" etc. Isso funciona bem para minhas 1000 linhas de código (comentários incluídos).

EDIT: Finalmente eu alterno entre as seções com helm-imenu. Na verdade, o leme se conecta automaticamente à função imenu normal, de modo que tudo que eu preciso é

       (local-set-key (kbd "C-*") 'imenu)

Dividi meu .emacsarquivo relativamente pequeno em três partes:

• emacs-custom.el para personalizações, extraindo muitos dados volumosos e inúteis; o arquivo é reescrito automaticamente sem tocar no arquivo .emacs principal , evitando alterações espúrias.

  (setq custom-file "~/.emacs-custom.el")
  (load custom-file)
  

• lg-lib.el para código em vez de configuração: carregando minhas próprias bibliotecas a partir de locais de origem fora do padrão em vez do diretório packages e definindo várias funções (principalmente copiadas e hackeadas na ausência de um pacote apropriado); é outra grande redução na contagem de linhas .emacs .

  (load "~/lg-lib")
  

• O arquivo .emacs principal : sem código volumoso e variáveis ​​de personalização volumosas, ele contém requiresolicitações de pacotes, variáveis ​​que não fazem parte do sistema Customize e diversas chamadas de função para carregar e inicializar pacotes. Eu o "organizo", mantendo cuidadosamente todas as linhas pertencentes ao mesmo pacote ou recurso, e separando ainda mais o carregamento e as configurações relacionadas ao pacote da funcionalidade "principal". Um trecho bastante representativo:

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

  Essas seções são pequenas, mas permaneceriam gerenciáveis ​​com muito mais linhas de configuração para cada pacote.

Siga a configuração de um mestre do Emacs, por exemplo, https://github.com/purcell/emacs.d

Por exemplo, sobre como organizar pacotes instalados manualmente e pacotes instalados no ELPA, a instalação de Steven Purcell

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

Por que seguir um mestre? Um ponto importante do meu "Master emacs in one year" é que os novatos podem evitar com eficiência as despesas gerais e os "truques" da instalação.

Entendo que muitas pessoas não concordam comigo, mas eis o meu caso (detalhado em meu artigo ):

Comecei a usar o Emacs usando a respeitada ( 1403 estrelas do GitHub de Purcell a partir de novembro de 2014!), Configuração estável (5 anos em desenvolvimento). Apesar de começar disso, eu ainda tinha muitos problemas . Steve Purcell me ajudou a resolver todos esses problemas. (Na verdade, eu me tornei o Padawan dele por mais de um ano.) Ao usar sua configuração e usar os problemas de seu repositório para relatar problemas e tirar proveito de sua experiência, evitei perder muito tempo. Ainda hoje, ainda observo muitas pessoas usando git submodulepara gerenciar plug-ins de terceiros. Steve e eu desistimos de usar git submoduleisso porque pode ser uma PITA .

Mas se você tem muita confiança em suas habilidades ou prefere aprender sozinho, esse não é o caminho para você.

Uma maneira inovadora e simples de limpar sua .emacs.dpasta é usar org-modee descrever tudo usando blocos de origem. Em seu .emacsarquivo, aponte para seu config.org.

Um recurso maravilhoso sobre isso é Harry Schwartz. Ele tem um vídeo do youtube que toca e uma postagem no blog que explica os detalhes . Eu era capaz de segui-lo como um emacs noob e obter toda a configuração. Funciona como um encanto. 1 arquivo para todo o meu init.