Posso usare la modalità org per strutturare il mio .emacs o altri file di configurazione .el?

Il mio .emacsfile di configurazione diventa sempre più grande e mi piacerebbe avere una panoramica e una strutturazione migliori aggiungendo titoli, sottotitoli e potendoli nascondere o mostrarli come posso fare con Emacs org-mode.

Ho notato che posso attivare org-modeanche nel .emacsbuffer e che è possibile aggiungere intestazioni e comprimerle. Ma Emacs / Aquamacs sarà ancora in grado di caricare il codice Elisp dal documento se aggiungo org-modeintestazioni (ovvero, le linee che iniziano con uno o più asterischi)?

Posso avere tutto ciò in un file o dovrei avere un .*orgfile e quindi esportare regolarmente il codice Elisp in un altro file?

Sì, certamente puoi, puoi usare org-babel-load-fileper farlo.

Nel tuo init.el, inserisci quanto segue:

(require 'org)
(org-babel-load-file
 (expand-file-name "settings.org"
                   user-emacs-directory))

(Sto usando ~ / .emacs.d / settings.org ma questa è una preferenza personale). Nel settings.orgfile puoi sistemarlo come desideri, avvolgendo elisp in:

* Turn off menu bar
#+BEGIN_SRC emacs-lisp
(menu-bar-mode -1)
#+END_SRC

Quando avvii Emacs, determinerà automaticamente se il file settings.org è cambiato e, se necessario, lo aggroviglierà per produrre un settings.elfile che verrà caricato.

Se tutto ciò che desideri è la visualizzazione selettiva delle sezioni e la navigazione tra le intestazioni, non hai bisogno della modalità Org. Tutto ciò che serve è la modalità struttura . La modalità struttura è fondamentalmente il livello di intestazione e la gestione della visibilità della sezione della modalità Org. In effetti, la modalità Org era originariamente l'estensione dell'autore alla modalità Struttura, e cresceva e cresceva e cresceva ... Anche oggi org-modederiva outline-mode.

La modalità Contorno esiste sia come modalità principale che come modalità secondaria. La modalità secondaria può essere utilizzata in qualsiasi modalità principale. È possibile configurarlo per utilizzare un formato di intestazione compatibile con la sintassi del programma e molte modalità principali lo fanno, impostando la outline-regexpvariabile su una regexp che corrisponde all'inizio di un'intestazione. Ad esempio, questo è il valore predefinito nella modalità Lisp di Emacs:

";;;\\(;* [^ \t\n]\\|###autoload\\)\\|("

cioè le intestazioni di sezione iniziano con tre o più punti e virgola e un singolo spazio, o una parentesi aperta sul margine sinistro. La variabile outline-levelcontiene il nome di una funzione per determinare la profondità di un'intestazione; il valore predefinito è la lunghezza della stringa corrispondente outline-regexp, e la modalità Emacs Lisp lo sovrascrive per assegnare una profondità maggiore a (e ;;;###autoload.

Se non ti piace il formato di intestazione predefinito, imposta la variabile outline-regexpin una dichiarazione di variabile locale del file . Questo è quello che uso - le mie intestazioni di sezione sono tutte ;;;seguite dalla classica sequenza di stelle:

;;; Local Variables:
;;; outline-regexp: ";;;\\*+\\|\\`"
;;; End:

Se vuoi che la modalità Contorno secondario venga attivata automaticamente quando carichi il file, aggiungi la seguente riga nella sezione Variabili locali: tieni presente che ciò ti avviserà del codice non sicuro in Emacs ≤23.x.

;;; eval: (outline-minor-mode 1)

I comandi per la modalità secondaria struttura utilizzano il C-c @prefisso piuttosto scomodo per impostazione predefinita. Lo sposto su M-o(non uso mai i collegamenti facemenu), potresti preferire un'altra chiave o replicare i collegamenti della modalità Org (che si sono discostati un po 'dalla modalità Struttura).

La programmazione alfabetica ti porta il più possibile lì, la modalità org la supporta tramite org-babel . Due possibili soluzioni sono spiegate sul blog di @malabarba :

Il modo più semplice è caricare la modalità org, quindi utilizzare la sua funzione districante per caricare una configurazione Emacs alfabetizzata:

(require 'org)
(org-babel-load-file
 (expand-file-name "emacs-init.org"
                   user-emacs-directory))

In alternativa (per evitare di caricare completamente l'organizzazione), è possibile districare con le primitive Emacs Lisp:

(defvar endless/init.org-message-depth 3
  "What depth of init.org headers to message at startup.")

(with-temp-buffer
  (insert-file "~/.emacs.d/init.org")
  (goto-char (point-min))
  (search-forward "\n* init.el")
  (while (not (eobp))
    (forward-line 1)
    (cond
     ;; Report Headers
     ((looking-at
       (format "\\*\\{2,%s\\} +.*$"
               endless/init.org-message-depth))
      (message "%s" (match-string 0)))
     ;; Evaluate Code Blocks
     ((looking-at "^#\\+BEGIN_SRC +emacs-lisp.*$")
      (let ((l (match-end 0)))
        (search-forward "\n#+END_SRC")
        (eval-region l (match-beginning 0))))
     ;; Finish on the next level-1 header
     ((looking-at "^\\* ")
      (goto-char (point-max))))))

Un altro voto per la modalità struttura. Ad esempio per l'organizzazione, .emacsutilizzo la sintassi seguente:

;;; HEADING:

le parti importanti sono ;;;e:\n

(add-hook 'emacs-lisp-mode-hook 
          (lambda ()
            (make-local-variable 'outline-regexp)
            (setq outline-regexp "^;;; ")
            (make-local-variable 'outline-heading-end-regexp)
            (setq outline-heading-end-regexp ":\n")
            (outline-minor-mode 1)
            ))

Ecco un esempio .emacs:

;;; preliminaries:
;; load-path:
;; This little monster adds all non-dot dirs to Your load path recursively
(let* ((my-lisp-dir "~/.emacs.d/site-lisp/")
       (default-directory my-lisp-dir)
       (orig-load-path load-path))
  (setq load-path (cons my-lisp-dir nil))
  (normal-top-level-add-subdirs-to-load-path)
  (nconc load-path orig-load-path))

;; ...

;;; modes:

;; python-mode:
(setq py-install-directory "~/.emacs.d/site-lisp/python-mode")
(add-to-list 'load-path py-install-directory)
(require 'python-mode)

;; ...

;;; customizations:
(custom-set-variables
 '(blink-cursor-mode nil)
)

;; ...

Si dovrebbe abilitare outline-minor-modee quindi i due tasti necessari sono:

• C-c @ C-t - mostra la struttura di livello superiore

  quanto sopra diventa

  ;;; preliminaries:
  ;;; modes:
  ;;; customizations:
  

• C-c @ C-a - mostra di nuovo tutto

Un uso tipico è quello di mostrare la struttura di livello superiore, passare alla voce di interesse e mostrare di nuovo tutto.

Nella seguente risposta SO vedrai come farlo, esempi di progetti che utilizzano uno o più file org, quali sono i vantaggi dell'utilizzo di Cask e dei collegamenti alla documentazione.

https://stackoverflow.com/questions/25430029/whats-the-best-way-to-package-my-emacs-installation-packages-and-config-so-tha/25430745#25430745

Ho trasformato la mia configurazione in org alcuni mesi fa e non ne sono completamente soddisfatto. Richiede un po 'di configurazione e lettura del manuale dell'organizzazione per avere un utile file organizzativo che semplifichi la modifica del codice elisp. Bisogna abilitare il blocco sorgente risorse (disattivato per impostazione predefinita -> usa una variabile per file), verificare che altre modalità non siano in conflitto per la modifica dei blocchi src (modalità di riempimento automatico), ecc. Non si vuole usare Cc (backtick) (org-edit-src-block`) per modificare un blocco src. E si mette un po 'di mezzo per il debug.

Il mio consiglio sarebbe: iniziare suddividendo il file init in piccoli pezzi elisp, provare qualche pacchetto di restringimento là fuori, utilizzare helm-swoopper una navigazione rapida e quindi considerare l'utilizzo org-mode.

Di recente ho investito del tempo per fare esattamente questo. Ho finito con una configurazione che - viene mantenuta con la modalità org - usa 'use-package' per installare automaticamente i pacchetti mancanti - è un repository github che tipo di autoinstallazioni (plug spudorato: https://github.com / pascalfleury / emacs-config )

Ho "avviato" alcune macchine (Linux e Mac) clonando il repository e aggiungendo una sola riga in ~ / .emacs et voila. Sono installato come mi piace.