doomemacs/core/core.el

;;; core.el --- the heart of the beast -*- lexical-binding: t; -*-

;;; Naming conventions:
;;
;;   doom-...   public variables or non-interactive functions
;;   doom--...  private anything (non-interactive), not safe for direct use
;;   doom/...   an interactive function; safe for M-x or keybinding
;;   doom//...  an interactive function for managing/maintaining Doom itself
;;   doom:...   an evil operator, motion or command
;;   doom|...   hook function
;;   doom*...   advising functions
;;   doom@...   a hydra command
;;   ...!       a macro or function that configures DOOM
;;   =...       an interactive command that starts an app module
;;   %...       functions used for in-snippet logic
;;   +...       Any of the above but part of a module, e.g. `+emacs-lisp|init-hook'
;;
;; Autoloaded functions are in core/autoload/*.el and modules/*/*/autoload.el or
;; modules/*/*/autoload/*.el.

(defvar doom-version "2.0.8"
  "Current version of DOOM emacs.")

(defvar doom-debug-mode (or (getenv "DEBUG") init-file-debug)
  "If non-nil, all doom functions will be verbose. Set DEBUG=1 in the command
line or use --debug-init to enable this.")

(defvar doom-emacs-dir (file-truename user-emacs-directory)
  "The path to this emacs.d directory.")

(defvar doom-core-dir (concat doom-emacs-dir "core/")
  "Where essential files are stored.")

(defvar doom-modules-dir (concat doom-emacs-dir "modules/")
  "Where configuration modules are stored.")

(defvar doom-local-dir (concat doom-emacs-dir ".local/")
  "Root directory for local Emacs files. Use this as permanent storage for files
that are safe to share across systems (if this config is symlinked across
several computers).")

(defvar doom-etc-dir (concat doom-local-dir "etc/")
  "Directory for non-volatile storage. For volatile story, see `doom-cache-dir'.

Use this for dependencies like servers or config files that are stable (i.e. it
should be unlikely that you need to delete them if something goes wrong).")

(defvar doom-cache-dir (concat doom-local-dir "cache/")
  "Directory for volatile storage.

Deleted when `doom/reset' is called. Use this for transient files; on-the-fly
like caches and temporary files. Anything that you don't mind deleting if there
are problems.")

(defvar doom-packages-dir (concat doom-local-dir "packages/")
  "Where package.el and quelpa plugins (and their caches) are stored.")

(defvar doom-autoload-file (concat doom-local-dir "autoloads.el")
  "Where `doom//reload-autoloads' will generate its autoloads file.")

(defgroup doom nil
  "DOOM Emacs, an Emacs configuration for a stubborn, shell-dwelling and
melodramatic ex-vimmer disappointed with the text-editor status quo."
  :group 'emacs)


;;;
;; UTF-8 as the default coding system
(when (fboundp 'set-charset-priority)
  (set-charset-priority 'unicode))     ; pretty
(prefer-coding-system        'utf-8)   ; pretty
(set-terminal-coding-system  'utf-8)   ; pretty
(set-keyboard-coding-system  'utf-8)   ; pretty
(set-selection-coding-system 'utf-8)   ; perdy
(setq locale-coding-system   'utf-8)   ; please
(setq-default buffer-file-coding-system 'utf-8) ; with sugar on top

(setq-default
 ad-redefinition-action 'accept   ; silence advised function warnings
 apropos-do-all t                 ; make `apropos' more useful
 compilation-always-kill t        ; kill compilation process before starting another
 compilation-ask-about-save nil   ; save all buffers on `compile'
 compilation-scroll-output t
 confirm-nonexistent-file-or-buffer t
 enable-recursive-minibuffers nil
 debug-on-error (and (not noninteractive) doom-debug-mode)
 idle-update-delay 2              ; update ui less often
 load-prefer-newer (or noninteractive doom-debug-mode)
 ;; keep the point out of the minibuffer
 minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt)
 ;; History & backup settings (save nothing, that's what git is for)
 auto-save-default nil
 create-lockfiles nil
 history-length 500
 make-backup-files nil
 ;; files
 abbrev-file-name             (concat doom-local-dir "abbrev.el")
 auto-save-list-file-name     (concat doom-cache-dir "autosave")
 backup-directory-alist       (list (cons "." (concat doom-cache-dir "backup/")))
 pcache-directory             (concat doom-cache-dir "pcache/")
 mc/list-file                 (concat doom-etc-dir "mc-lists.el")
 server-auth-dir              (concat doom-cache-dir "server/")
 shared-game-score-directory  (concat doom-etc-dir "shared-game-score/")
 tramp-auto-save-directory    (concat doom-cache-dir "tramp-auto-save/")
 tramp-backup-directory-alist backup-directory-alist
 tramp-persistency-file-name  (concat doom-cache-dir "tramp-persistency.el")
 url-cache-directory          (concat doom-cache-dir "url/")
 url-configuration-directory  (concat doom-etc-dir "url/"))

;; move custom defs out of init.el
(setq custom-file (concat doom-etc-dir "custom.el"))
(load custom-file t t)

;; be quiet at startup; don't load or display anything unnecessary
(unless noninteractive
  (advice-add #'display-startup-echo-area-message :override #'ignore)
  (setq inhibit-startup-message t
        inhibit-startup-echo-area-message user-login-name
        inhibit-default-init t
        initial-major-mode 'fundamental-mode
        initial-scratch-message nil
        mode-line-format nil))

;; Custom init hooks; clearer than `after-init-hook', `emacs-startup-hook', and
;; `window-setup-hook'.
(defvar doom-init-hook nil
  "A list of hooks run when DOOM is initialized, before `doom-post-init-hook'.")

(defvar doom-post-init-hook nil
  "A list of hooks run after DOOM initialization is complete, and after
`doom-init-hook'.")

(defun doom-try-run-hook (fn hook)
  "Runs a hook wrapped in a `condition-case-unless-debug' block; its objective
is to include more information in the error message, without sacrificing your
ability to invoke the debugger in debug mode."
  (condition-case-unless-debug ex
      (if noninteractive
          (quiet! (funcall fn))
        (funcall fn))
    ('error
     (lwarn hook :error
          "%s in '%s' -> %s"
          (car ex) fn (error-message-string ex))))
  nil)

(defun doom|finalize ()
  (unless (or (not after-init-time) noninteractive)
    (dolist (hook '(doom-init-hook doom-post-init-hook))
      (run-hook-wrapped hook #'doom-try-run-hook hook)))

  ;; Don't keep gc-cons-threshold too high. It helps to stave off the GC while
  ;; Emacs starts up, but afterwards it causes stuttering and random freezes. So
  ;; reset it to a reasonable default.
  (setq gc-cons-threshold 16777216
        gc-cons-percentage 0.1
        file-name-handler-alist doom--file-name-handler-alist)
  t)


;;;
;; Initialize
(eval-and-compile
  (defvar doom--file-name-handler-alist file-name-handler-alist)
  (unless (or after-init-time noninteractive)
    (setq gc-cons-threshold 402653184
          gc-cons-percentage 0.6
          file-name-handler-alist nil))

  (require 'cl-lib)
  (load (concat doom-core-dir "core-packages") nil t)
  (setq load-path (eval-when-compile (doom-initialize t)
                                     (doom-initialize-load-path t))
        doom--package-load-path (eval-when-compile doom--package-load-path))

  (load! core-lib)
  (load! core-os) ; consistent behavior across OSes
  (condition-case-unless-debug ex
      (require 'autoloads doom-autoload-file t)
    ('error
     (lwarn 'doom-autoloads :warning
            "%s in autoloads.el -> %s"
            (car ex) (error-message-string ex))))

  (unless noninteractive
    (load! core-ui)         ; draw me like one of your French editors
    (load! core-popups)     ; taming sudden yet inevitable windows
    (load! core-editor)     ; baseline configuration for text editing
    (load! core-projects)   ; making Emacs project-aware
    (load! core-keybinds))  ; centralized keybind system + which-key

  (add-hook! '(emacs-startup-hook doom-reload-hook)
    #'doom|finalize))

(provide 'core)
;;; core.el ends here