use-layer.el

(defvar use-layer-configuration-layers nil)

(defvar use-layer-init-hook nil)

(defvar use-layer-config-hook nil)

(defvar use-layer-excluded-packages nil)

(defsubst use-layer-error (msg)
  (error "use-layer: %s" msg))

(defun use-layer-process-keywords (name plist &optional state)
  (declare (indent 1))
  (unless (null plist)
    (let* ((keyword (car plist))
           (arg (cadr plist))
           (rest (cddr plist)))
      (unless (keywordp keyword)
        (use-layer-error (format "%s is not a keyword" keyword)))
      (let* ((handler (concat "use-layer-handler/" (symbol-name keyword)))
             (handler-sym (intern handler)))
        (if (functionp handler-sym)
            (funcall handler-sym name keyword arg rest state)
          (use-layer-error
           (format "Keyword handler not defined: %s" handler)))))))

(defmacro use-layer-core (name def args)
  `(progn
     (add-to-list 'use-layer-configuration-layers (or def name))
     (use-layer-process-keywords name args)))

(defmacro use-layer (name &rest args)
  (declare (indent 1))
  (unless (memq :disabled args)
    (macroexp-progn
     (condition-case-unless-debug err
         (let ((def (plist-get args :def)))
           (use-layer-core name def args))
       (error
        (ignore
         (display-warning
          'use-layer
          (format "Failed to parse layer %s: %s"
                  name (error-message-string err)) :error)))))))

;;

(defun use-layer-handler/:disabled (name _keyword _arg rest state)
  (use-layer-process-keywords name rest state))

(defun use-layer-handler/:user-init (name _keyword arg rest state)
  (let ((body (use-layer-process-keywords name rest state)))
    (if (null arg)
        body
      (let* ((init (concat "use-layer-init/" (symbol-name name)))
             (init-sym (intern init)))
        `((defun ,init-sym ()
            ,@arg)
          (add-to-list 'use-layer-init-hook ',init-sym)
          ,@body)))))

(defun use-layer-handler/:user-config (name _keyword arg rest state)
  (let ((body (use-layer-process-keywords name rest state)))
    (if (null arg)
        body
      (let* ((init (concat "use-layer-config/" (symbol-name name)))
             (init-sym (intern init)))
        `((defun ,init-sym ()
            ,@arg)
          (add-to-list 'use-layer-config-hook ',init-sym)
          ,@body)))))

(defun use-layer-handler/:excluded-packages (name _keyword arg rest state)
  (let ((body (use-layer-process-keywords name rest state)))
    (if (null arg)
        body
      `((mapc (lambda (pkg) (add-to-list 'use-layer-excluded-packages pkg)) ',arg)
        ,@body))))

(defun use-layer-handler/:def (name _keyword arg rest state)
  (let ((body (use-layer-process-keywords name rest state)))
    body))

(provide 'use-layer)