Changed names to buffer-sets

buffer-layers.el

@@ -1,4 +1,4 @@
-;;; buffer-layers.el --- Layered Buffers for Buffer Management
+;;; buffer-sets.el --- Configurable sets of buffers
 
 ;; Copyright (C) 2016 Samuel Flint
 
@@ -16,14 +16,14 @@
 ;;
 ;; ```elisp
 ;; ;; -*- emacs-lisp -*-
-;; (define-buffer-layer org
+;; (define-buffer-set org
 ;;   :files ("~/org/"
 ;;           "~/org/main.org")
 ;;   :buffer-to-select "main.org"
 ;;   :run-on-apply ((my/find-current-notes-file)))
 ;; ```
 ;;
-;; It can be loaded with `(load-buffer-layer "/path/to/org.layer" nil)`.  If the final `nil` is changed to `t`, it will load and apply the layer.
+;; It can be loaded with `(load-buffer-set "/path/to/org.layer" nil)`.  If the final `nil` is changed to `t`, it will load and apply the layer.
 ;;
 ;; Buffer Layer Definitions take the following arguments:
 ;;
@@ -32,7 +32,7 @@
 ;;  - `:run-on-apply`: This is a list of forms to be executed in between finding files and selecting the given buffer.
 ;;  - `:run-on-remove`: This is a list of forms to be executed after killing the buffers that have been loaded.
 ;;
-;; To manipulate buffer layers, execute `buffer-layer-mode`, and then you can use the following keybindings:
+;; To manipulate buffer layers, execute `buffer-set-mode`, and then you can use the following keybindings:
 ;;
 ;;  - `C-x L l`: Load a buffer layer, if defined, otherwise, load from the given file.
 ;;  - `C-x L u`: Unload a loaded buffer layer.
@@ -41,56 +41,56 @@
 ;;
 ;; The following are the user-facing functions:
 ;;
-;;  - `define-buffer-layer`
-;;  - `buffer-layer-load-buffer-layer`, also known as `load-buffer-layer`
-;;  - `buffer-layers-unload-buffer-layer`
-;;  - `buffer-layers-list`
-;;  - `buffer-layers-unload-all-buffer-layers`
-;;  - `buffer-layers-mode`
+;;  - `define-buffer-set`
+;;  - `buffer-set-load-buffer-set`, also known as `load-buffer-set`
+;;  - `buffer-sets-unload-buffer-set`
+;;  - `buffer-sets-list`
+;;  - `buffer-sets-unload-all-buffer-sets`
+;;  - `buffer-sets-mode`
 ;;
-;; On enabling `buffer-layer-mode`, the map is placed onto `C-x L`, and `buffer-layers-unload-all-buffer-layers` is added to the `kill-emacs-hook`, and on disabling the mode, they are removed.
+;; On enabling `buffer-set-mode`, the map is placed onto `C-x L`, and `buffer-sets-unload-all-buffer-sets` is added to the `kill-emacs-hook`, and on disabling the mode, they are removed.
 
 
 ;;; Code:
 
 (require 'cl-lib)
 
-(defvar *buffer-layers* nil
+(defvar *buffer-sets* nil
   "List of all defined buffer layers.")
 
-(defvar *buffer-layers-applied* nil
-  "List of applied buffer-layers.")
+(defvar *buffer-sets-applied* nil
+  "List of applied buffer-sets.")
 
-(defun buffer-layers-applied-p (layer)
+(defun buffer-sets-applied-p (layer)
   "Returns true if LAYER is applied."
-  (member layer *buffer-layers-applied*))
+  (member layer *buffer-sets-applied*))
 
-(defun buffer-layers--applier-name (name)
+(defun buffer-sets--applier-name (name)
   "Generate name to apply a buffer layer based on NAME."
-  (intern (format "apply-buffer-layers-%s" name)))
+  (intern (format "apply-buffer-sets-%s" name)))
 
-(defun buffer-layers--remover-name (name)
+(defun buffer-sets--remover-name (name)
   "Generate name to remove a buffer layer based on NAME."
-  (intern (format "remove-buffer-layers-%s" name)))
+  (intern (format "remove-buffer-sets-%s" name)))
 
-(defun buffer-layers--buffer-list-name (name)
+(defun buffer-sets--buffer-list-name (name)
   "Generate name to contain buffer layer buffer list based on NAME."
-  (intern (format "*buffer-layers-%s-buffers*" name)))
+  (intern (format "*buffer-sets-%s-buffers*" name)))
 
-(cl-defmacro define-buffer-layer (name &key files run-on-apply run-on-remove buffer-to-select)
+(cl-defmacro define-buffer-set (name &key files run-on-apply run-on-remove buffer-to-select)
   "Define a buffer layer named NAME, taking FILES, RUN-ON-APPLY, RUN-ON-REMOVE and BUFFER-TO-SELECT as keyword arguments."
-  (let ((applier (buffer-layers--applier-name name))
-        (remover (buffer-layers--remover-name name))
-        (buffers-list (buffer-layers--buffer-list-name name))
+  (let ((applier (buffer-sets--applier-name name))
+        (remover (buffer-sets--remover-name name))
+        (buffers-list (buffer-sets--buffer-list-name name))
         (files-list (cons 'list
                           (when (not (null files))
                             (mapcar #'(lambda (name)
                                         (format "%s" name)) files)))))
     `(progn
-       (add-to-list '*buffer-layers* ',name)
+       (add-to-list '*buffer-sets* ',name)
        (defvar ,buffers-list nil)
        (defun ,applier ()
-         ,(format "Apply buffer-layer %s." name)
+         ,(format "Apply buffer-set %s." name)
          (interactive)
          (mapcar #'(lambda (file)
                      (add-to-list ',buffers-list (find-file file)))
@@ -98,10 +98,10 @@
          ,@run-on-apply
          (when (not (null ,buffer-to-select))
            (switch-to-buffer ,buffer-to-select))
-         (add-to-list '*buffer-layers-applied* ',name)
+         (add-to-list '*buffer-sets-applied* ',name)
          (message "Applied Buffer Layer %s" ',name))
        (defun ,remover ()
-         ,(format "Remove buffer-layer %s." name)
+         ,(format "Remove buffer-set %s." name)
          (interactive)
          (mapc #'(lambda (buffer)
                    (when (buffer-live-p buffer)
@@ -111,31 +111,31 @@
                ,buffers-list)
          ,@run-on-remove
          (setq ,buffers-list nil)
-         (setq *buffer-layers-applied* (delq ',name *buffer-layers-applied*))
+         (setq *buffer-sets-applied* (delq ',name *buffer-sets-applied*))
          (message "Removed Buffer Layer %s" ',name))
        (setq current-buffer-applier ',applier)
        (list ',applier ',remover))))
 
-(defun buffer-layers-load-buffer-layer (name-or-path load-it-p)
+(defun buffer-sets-load-buffer-set (name-or-path load-it-p)
   "Load a buffer named NAME-OR-PATH, and if a file, apply if LOAD-IT-P is true."
   (interactive (list (completing-read "Buffer Layer Name or Path: " (cl-remove-if #'(lambda (layer)
-                                                                                      (member layer *buffer-layers-applied*))
-                                                                                  *buffer-layers*))
+                                                                                      (member layer *buffer-sets-applied*))
+                                                                                  *buffer-sets*))
                      nil))
-  (if (functionp (buffer-layers--applier-name name-or-path))
-      (funcall (buffer-layers--applier-name name-or-path))
+  (if (functionp (buffer-sets--applier-name name-or-path))
+      (funcall (buffer-sets--applier-name name-or-path))
     (load name-or-path)
     (when load-it-p
       (funcall current-buffer-applier))))
 
-(defalias 'load-buffer-layer 'buffer-layers-load-buffer-layer)
+(defalias 'load-buffer-set 'buffer-sets-load-buffer-set)
 
-(defun buffer-layers-unload-buffer-layer (name)
+(defun buffer-sets-unload-buffer-set (name)
   "Unload Buffer Layer named NAME."
-  (interactive (list (completing-read "Buffer Layer Name: " *buffer-layers-applied*)))
-  (funcall (buffer-layers--remover-name name)))
+  (interactive (list (completing-read "Buffer Layer Name: " *buffer-sets-applied*)))
+  (funcall (buffer-sets--remover-name name)))
 
-(defun buffer-layers-list ()
+(defun buffer-sets-list ()
   "Produce a list of defined buffer layers."
   (interactive)
   (when (buffer-live-p "*Buffer Layers*")
@@ -143,40 +143,40 @@
   (with-help-window "*Buffer Layers*"
     (with-current-buffer "*Buffer Layers*"
       (insert "Defined Buffer Layers:\n\n")
-      (dolist (layer *buffer-layers*)
-        (if (not (buffer-layers-applied-p layer))
+      (dolist (layer *buffer-sets*)
+        (if (not (buffer-sets-applied-p layer))
             (insert (format " - %s\n" layer))
           (insert (format " - %s (Applied)\n" layer)))
-        (dolist (buffer (symbol-value (buffer-layers--buffer-list-name layer)))
+        (dolist (buffer (symbol-value (buffer-sets--buffer-list-name layer)))
           (if (null (get-buffer-window-list buffer nil t))
               (insert (format "    - %s\n" (buffer-name buffer)))
             (insert (format "    - %s (visible)\n" (buffer-name buffer)))))))))
 
-(defun buffer-layers-unload-all-buffer-layers ()
+(defun buffer-sets-unload-all-buffer-sets ()
   "Unload all loaded buffer layers."
   (interactive)
-  (dolist (buffer-layer *buffer-layers-applied*)
-    (buffer-layers-unload-buffer-layer buffer-layer)))
+  (dolist (buffer-set *buffer-sets-applied*)
+    (buffer-sets-unload-buffer-set buffer-set)))
 
-(defvar buffer-layers-map (make-keymap)
-  "Keymap for buffer-layer commands.")
+(defvar buffer-sets-map (make-keymap)
+  "Keymap for buffer-set commands.")
 
-(define-key buffer-layers-map (kbd "l") #'buffer-layers-load-buffer-layer)
-(define-key buffer-layers-map (kbd "L") #'buffer-layers-list)
-(define-key buffer-layers-map (kbd "u") #'buffer-layers-unload-buffer-layer)
-(define-key buffer-layers-map (kbd "U") #'buffer-layers-unload-all-buffer-layers)
+(define-key buffer-sets-map (kbd "l") #'buffer-sets-load-buffer-set)
+(define-key buffer-sets-map (kbd "L") #'buffer-sets-list)
+(define-key buffer-sets-map (kbd "u") #'buffer-sets-unload-buffer-set)
+(define-key buffer-sets-map (kbd "U") #'buffer-sets-unload-all-buffer-sets)
 
-(define-minor-mode buffer-layers-mode
-  "A mode for managing layers of buffers."
-  :lighter " BLM" :global t :variable buffer-layers-mode-p
-  (if buffer-layers-mode-p
+(define-minor-mode buffer-sets-mode
+  "A mode for managing configurable sets of buffers."
+  :lighter " BSS" :global t :variable buffer-sets-mode-p
+  (if buffer-sets-mode-p
       (progn
-        (define-key ctl-x-map (kbd "L") buffer-layers-map)
-        (add-hook 'kill-emacs-hook #'buffer-layers-unload-all-buffer-layers))
+        (define-key ctl-x-map (kbd "S") buffer-sets-map)
+        (add-hook 'kill-emacs-hook #'buffer-sets-unload-all-buffer-sets))
     (progn
-      (define-key ctl-x-map (kbd "L") nil)
-      (remove-hook 'kill-emacs-hook #'buffer-layers-unload-all-buffer-layers))))
+      (define-key ctl-x-map (kbd "S") nil)
+      (remove-hook 'kill-emacs-hook #'buffer-sets-unload-all-buffer-sets))))
 
-(provide 'buffer-layers)
+(provide 'buffer-sets)
 
-;;; buffer-layers.el ends here
+;;; buffer-sets.el ends here