Browse Source

Hopefully completed the rename process

Samuel W. Flint 7 years ago
parent
commit
40e22ad9da
1 changed files with 146 additions and 146 deletions
  1. 146 146
      buffer-sets.el

+ 146 - 146
buffer-sets.el

@@ -15,7 +15,7 @@
 
 (require 'cl-lib)
 
-(cl-defstruct buffer-layer
+(cl-defstruct buffer-set
   name
   files
   select
@@ -24,81 +24,81 @@
   on-remove
   on-remove-source)
 
-(defvar *buffer-layers* nil
-  "List of all defined buffer layers.")
+(defvar *buffer-sets* nil
+  "List of all defined buffer sets.")
 
-(defvar *buffer-layers-applied* nil
-  "List of applied buffer-layers.")
+(defvar *buffer-sets-applied* nil
+  "List of applied buffer-sets.")
 
-(defvar *buffer-layer-definitions* nil
-  "List of all buffer layer definitions.")
+(defvar *buffer-set-definitions* nil
+  "List of all buffer set definitions.")
 
-(defvar *buffer-layer-buffers* nil
-  "List of buffers in loaded buffer layers.")
+(defvar *buffer-set-buffers* nil
+  "List of buffers in loaded buffer sets.")
 
-(defvar *buffer-layer-file* "~/.emacs.d/buffer-layer-definitions.el"
-  "The file to store buffer layer definitions in.")
+(defvar *buffer-set-file* "~/.emacs.d/buffer-set-definitions.el"
+  "The file to store buffer set definitions in.")
 
-(defun buffer-layers-load-definitions-file ()
-  "Load buffer layer definitions file."
-  (load *buffer-layer-file* t t)
-  (message "Loaded Buffer Layer Definitions."))
+(defun buffer-sets-load-definitions-file ()
+  "Load buffer set definitions file."
+  (load *buffer-set-file* t t)
+  (message "Loaded Buffer Set Definitions."))
 
-(defun buffer-layers-applied-p (layer)
-  "Returns true if LAYER is applied."
-  (member layer *buffer-layers-applied*))
+(defun buffer-sets-applied-p (set)
+  "Returns true if SET is applied."
+  (member set *buffer-sets-applied*))
 
-(defun buffer-layer--get-buffer-layer-definition (layer-name)
-  (car (cl-remove-if-not (lambda (layer)
-			   (eq layer-name (buffer-layer-name layer))) *buffer-layer-definitions*)))
+(defun buffer-set--get-buffer-set-definition (set-name)
+  (car (cl-remove-if-not (lambda (set)
+			   (eq set-name (buffer-set-name set))) *buffer-set-definitions*)))
 
-(defun buffer-layer--generate-buffers-list (layer-name)
-  (intern (format "*buffer-layer-%s--buffers*" layer-name)))
+(defun buffer-set--generate-buffers-list (set-name)
+  (intern (format "*buffer-set-%s--buffers*" set-name)))
 
-(cl-defmacro define-buffer-layer (name &key files select on-apply on-remove)
-  "Define a buffer layer named NAME, taking FILES, RUN-ON-APPLY, RUN-ON-REMOVE and BUFFER-TO-SELECT as keyword arguments."
+(cl-defmacro define-buffer-set (name &key files select on-apply on-remove)
+  "Define a buffer set named NAME, taking FILES, RUN-ON-APPLY, RUN-ON-REMOVE and BUFFER-TO-SELECT as keyword arguments."
   `(progn
-     (cl-pushnew ',name *buffer-layers*)
-     (cl-pushnew (make-buffer-layer :name ',name
+     (cl-pushnew ',name *buffer-sets*)
+     (cl-pushnew (make-buffer-set :name ',name
                                     :files ',files
                                     :select ,select
                                     :on-apply-source ',on-apply
                                     :on-remove-source ',on-remove
                                     :on-apply (lambda () ,@on-apply)
                                     :on-remove (lambda () ,@on-remove))
-                 *buffer-layer-definitions*
-                 :key #'buffer-layer-name)
-     (defvar ,(buffer-layer--generate-buffers-list name) nil)
+                 *buffer-set-definitions*
+                 :key #'buffer-set-name)
+     (defvar ,(buffer-set--generate-buffers-list name) nil)
      ',name))
 
-(defun buffer-layers-load-layer (name)
-  (interactive (list (intern (completing-read "Layer Name: "
-                                              (cl-remove-if #'(lambda (layer) (member layer *buffer-layers-applied*)) *buffer-layers*)
+(defun buffer-sets-load-set (name)
+  (interactive (list (intern (completing-read "Set Name: "
+                                              (cl-remove-if #'(lambda (set) (member set *buffer-sets-applied*)) *buffer-sets*)
                                               nil t))))
-  (let ((layer-definition (buffer-layer--get-buffer-layer-definition name)))
-    (if (not (buffer-layer-p layer-definition))
-    	(error "Layer Undefined: %s" name)
-      (let ((files (buffer-layer-files layer-definition))
-            (select (buffer-layer-select layer-definition))
-            (on-apply (buffer-layer-on-apply layer-definition))
-            (buffers-list (buffer-layer--generate-buffers-list name)))
+  (let ((set-definition (buffer-set--get-buffer-set-definition name)))
+    (if (not (buffer-set-p set-definition))
+    	(error "Set Undefined: %s" name)
+      (let ((files (buffer-set-files set-definition))
+            (select (buffer-set-select set-definition))
+            (on-apply (buffer-set-on-apply set-definition))
+            (buffers-list (buffer-set--generate-buffers-list name)))
         (setf (symbol-value buffers-list) (mapcar #'find-file files))
         (funcall on-apply)
         (when (stringp select)
           (switch-to-buffer select))
-        (add-to-list '*buffer-layers-applied* name)
-        (message "Applied buffer layer %s." name)))))
-
-(defalias 'load-buffer-layer 'buffer-layers-load-layer)
-
-(defun buffer-layers-unload-buffer-layer (name)
-  "Unload Buffer Layer named NAME."
-  (interactive (list (intern (completing-read "Buffer Layer Name: " *buffer-layers-applied*))))
-  (let ((layer-definition (buffer-layer--get-buffer-layer-definition name)))
-    (if (not (buffer-layer-p layer-definition))
-        (error "Layer Undefined: %s" name)
-      (let ((buffers-list (buffer-layer--generate-buffers-list name))
-            (on-remove (buffer-layer-on-remove layer-definition)))
+        (add-to-list '*buffer-sets-applied* name)
+        (message "Applied buffer set %s." name)))))
+
+(defalias 'load-buffer-set 'buffer-sets-load-set)
+
+(defun buffer-sets-unload-buffer-set (name)
+  "Unload Buffer Set named NAME."
+  (interactive (list (intern (completing-read "Buffer Set Name: " *buffer-sets-applied*))))
+  (let ((set-definition (buffer-set--get-buffer-set-definition name)))
+    (if (not (buffer-set-p set-definition))
+        (error "Set Undefined: %s" name)
+      (let ((buffers-list (buffer-set--generate-buffers-list name))
+            (on-remove (buffer-set-on-remove set-definition)))
         (mapc (lambda (buffer)
                 (with-current-buffer buffer
                   (save-buffer)
@@ -106,135 +106,135 @@
               (symbol-value buffers-list))
         (funcall on-remove)
         (setf (symbol-value buffers-list) nil)
-        (setq *buffer-layers-applied* (delq name *buffer-layers-applied*))
-        (message "Removed Buffer Layer: %s" name)))))
+        (setq *buffer-sets-applied* (delq name *buffer-sets-applied*))
+        (message "Removed Buffer Set: %s" name)))))
 
-(defun buffer-layers-list ()
-  "Produce a list of defined buffer layers."
+(defun buffer-sets-list ()
+  "Produce a list of defined buffer sets."
   (interactive)
-  (when (buffer-live-p "*Buffer Layers*")
-    (kill-buffer "*Buffer Layers*"))
-  (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))
-            (insert (format " - %s\n" layer))
-          (insert (format " - %s (Applied)\n" layer)))
-        (dolist (buffer (symbol-value (buffer-layer--generate-buffers-list layer)))
+  (when (buffer-live-p "*Buffer Sets*")
+    (kill-buffer "*Buffer Sets*"))
+  (with-help-window "*Buffer Sets*"
+    (with-current-buffer "*Buffer Sets*"
+      (insert "Defined Buffer Sets:\n\n")
+      (dolist (set *buffer-sets*)
+        (if (not (buffer-sets-applied-p set))
+            (insert (format " - %s\n" set))
+          (insert (format " - %s (Applied)\n" set)))
+        (dolist (buffer (symbol-value (buffer-set--generate-buffers-list set)))
           (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 ()
-  "Unload all loaded buffer layers."
+(defun buffer-sets-unload-all-buffer-sets ()
+  "Unload all loaded buffer sets."
   (interactive)
-  (dolist (buffer-layer *buffer-layers-applied*)
-    (buffer-layers-unload-buffer-layer buffer-layer)))
-
-(defun buffer-layers-create-layer (name)
-  "Create a new layer."
-  (interactive "SNew Layer Name: ")
-  (when (not (member name *buffer-layers*))
-    (pushnew name *buffer-layers*)
-    (setf (symbol-value (buffer-layer--generate-buffers-list name)) nil)
-    (pushnew (make-buffer-layer :name name
+  (dolist (buffer-set *buffer-sets-applied*)
+    (buffer-sets-unload-buffer-set buffer-set)))
+
+(defun buffer-sets-create-set (name)
+  "Create a new set."
+  (interactive "SNew Set Name: ")
+  (when (not (member name *buffer-sets*))
+    (pushnew name *buffer-sets*)
+    (setf (symbol-value (buffer-set--generate-buffers-list name)) nil)
+    (pushnew (make-buffer-set :name name
                                 :on-apply (lambda () nil)
-                                :on-remove (lambda () nil)) *buffer-layer-definitions*)))
+                                :on-remove (lambda () nil)) *buffer-set-definitions*)))
 
-(defun buffer-layers-add-file-to-layer (name file)
-  "Add a file to the layer."
+(defun buffer-sets-add-file-to-set (name file)
+  "Add a file to the set."
   (interactive (list
-                (intern (completing-read "Layer: " *buffer-layers* nil t))
+                (intern (completing-read "Set: " *buffer-sets* nil t))
                 (read-file-name "File Name: ")))
-  (let ((layer (buffer-layer--get-buffer-layer-definition name)))
-    (setf (buffer-layer-files layer) (append (buffer-layer-files layer) (list file)))))
+  (let ((set (buffer-set--get-buffer-set-definition name)))
+    (setf (buffer-set-files set) (append (buffer-set-files set) (list file)))))
 
-(defun buffer-layers-add-directory-to-layer (name directory)
+(defun buffer-sets-add-directory-to-set (name directory)
   (interactive (list
-                (intern (completing-read "Layer: " *buffer-layers* nil t))
+                (intern (completing-read "Set: " *buffer-sets* nil t))
                 (read-directory-name "Directory: ")))
-  (let ((layer (buffer-layer--get-buffer-layer-definition-name)))
-    (setf (buffer-layer-files layer) (append (buffer-layer-files layer) (list directory)))))
+  (let ((set (buffer-set--get-buffer-set-definition-name)))
+    (setf (buffer-set-files set) (append (buffer-set-files set) (list directory)))))
 
-(defun buffer-layers-add-buffer-to-layer (name buffer)
-  "Add a buffer to the given layer."
+(defun buffer-sets-add-buffer-to-set (name buffer)
+  "Add a buffer to the given set."
   (interactive (list
-                (intern (completing-read "Layer: " *buffer-layers* nil t))
+                (intern (completing-read "Set: " *buffer-sets* nil t))
                 (get-buffer (read-buffer "Buffer: " (current-buffer)))))
-  (let ((layer (buffer-layer--get-buffer-layer-definition name))
+  (let ((set (buffer-set--get-buffer-set-definition name))
         (file (buffer-file-name buffer)))
-    (setf (buffer-layer-files layer) (append (buffer-layer-files layer) (list file)))))
+    (setf (buffer-set-files set) (append (buffer-set-files set) (list file)))))
 
-;; (defun buffer-layers-edit-load-actions (layer)
-;;   "Edit the actions to be preformed on buffer layer load."
-;;   (interactive (list (completing-read "Layer: " *buffer-layers* nil t))))
+;; (defun buffer-sets-edit-load-actions (set)
+;;   "Edit the actions to be preformed on buffer set load."
+;;   (interactive (list (completing-read "Set: " *buffer-sets* nil t))))
 
-;; (defun buffer-layers-edit-remove-actions (layer)
-;;   "Edit the actions to be preformed on buffer layer removal."
-;;   (interactive (list (completing-read "Layer: " *buffer-layers* nil t))))
+;; (defun buffer-sets-edit-remove-actions (set)
+;;   "Edit the actions to be preformed on buffer set removal."
+;;   (interactive (list (completing-read "Set: " *buffer-sets* nil t))))
 
-(defun buffer-layers-set-buffer-to-select (layer)
+(defun buffer-sets-set-buffer-to-select (set)
   "Set the buffer to automatically select."
-  (interactive (list (intern (completing-read "Layer: " *buffer-layers* nil t))))
-  (let* ((layer (buffer-layer--get-buffer-layer-definition layer))
-         (files (buffer-layer-files layer)))
-    (setf (buffer-layer-select layer)
+  (interactive (list (intern (completing-read "Set: " *buffer-sets* nil t))))
+  (let* ((set (buffer-set--get-buffer-set-definition set))
+         (files (buffer-set-files set)))
+    (setf (buffer-set-select set)
           (completing-read "File: " files nil t))))
 
-(defun buffer-layers-save (the-layer)
-  "Save defined buffer layers."
+(defun buffer-sets-save (the-set)
+  "Save defined buffer sets."
   (interactive)
-  (insert (format "%S\n\n" (let ((name (buffer-layer-name the-layer))
-                                 (files (buffer-layer-files the-layer))
-                                 (select (buffer-layer-select the-layer))
-                                 (on-apply (buffer-layer-on-apply-source the-layer))
-                                 (on-remove (buffer-layer-on-remove-source the-layer)))
-                             `(define-buffer-layer ,name
+  (insert (format "%S\n\n" (let ((name (buffer-set-name the-set))
+                                 (files (buffer-set-files the-set))
+                                 (select (buffer-set-select the-set))
+                                 (on-apply (buffer-set-on-apply-source the-set))
+                                 (on-remove (buffer-set-on-remove-source the-set)))
+                             `(define-buffer-set ,name
                                 :files ,files
                                 :select ,select
                                 :on-apply ,on-apply
                                 :on-remove ,on-remove)))))
 
-(defun buffer-layers-save-definitions ()
-  (with-current-buffer (find-file *buffer-layer-file*)
+(defun buffer-sets-save-definitions ()
+  (with-current-buffer (find-file *buffer-set-file*)
     (kill-region (buffer-end -1) (buffer-end 1))
-    (mapc #'buffer-layers-save (reverse *buffer-layer-definitions*))
+    (mapc #'buffer-sets-save (reverse *buffer-set-definitions*))
     (save-buffer)
     (kill-buffer))
-  (message "Saved Buffer Layer Definitions."))
-
-(defvar buffer-layers-map (make-keymap)
-  "Keymap for buffer-layer commands.")
-
-(define-key buffer-layers-map (kbd "l") #'buffer-layers-load-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-layers-map (kbd "c") #'buffer-layers-create-layer)
-(define-key buffer-layers-map (kbd "f") #'buffer-layers-add-file-to-layer)
-(define-key buffer-layers-map (kbd "b") #'buffer-layers-add-buffer-to-layer)
-(define-key buffer-layers-map (kbd "d") #'buffer-layers-add-directory-to-layer)
-;; (define-key buffer-layers-map (kbd "a") #'buffer-layers-edit-load-actions)
-;; (define-key buffer-layers-map (kbd "r") #'buffer-layers-edit-remove-actions)
-(define-key buffer-layers-map (kbd "s") #'buffer-layers-set-buffer-to-select)
-(define-key buffer-layers-map (kbd "C-s") #'buffer-layers-save)
-
-(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
+  (message "Saved Buffer Set Definitions."))
+
+(defvar buffer-sets-map (make-keymap)
+  "Keymap for buffer-set commands.")
+
+(define-key buffer-sets-map (kbd "l") #'buffer-sets-load-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-key buffer-sets-map (kbd "c") #'buffer-sets-create-set)
+(define-key buffer-sets-map (kbd "f") #'buffer-sets-add-file-to-set)
+(define-key buffer-sets-map (kbd "b") #'buffer-sets-add-buffer-to-set)
+(define-key buffer-sets-map (kbd "d") #'buffer-sets-add-directory-to-set)
+;; (define-key buffer-sets-map (kbd "a") #'buffer-sets-edit-load-actions)
+;; (define-key buffer-sets-map (kbd "r") #'buffer-sets-edit-remove-actions)
+(define-key buffer-sets-map (kbd "s") #'buffer-sets-set-buffer-to-select)
+(define-key buffer-sets-map (kbd "C-s") #'buffer-sets-save)
+
+(define-minor-mode buffer-sets-mode
+  "A mode for managing sets of buffers."
+  :lighter " BSM" :global t :variable buffer-sets-mode-p
+  (if buffer-sets-mode-p
       (progn
-        (buffer-layers-load-definitions-file)
-        (define-key ctl-x-map (kbd "L") buffer-layers-map)
-        (add-hook 'kill-emacs-hook #'buffer-layers-unload-all-buffer-layers)
-        (add-hook 'kill-emacs-hook #'buffer-layers-save-definitions))
+        (buffer-sets-load-definitions-file)
+        (define-key ctl-x-map (kbd "L") buffer-sets-map)
+        (add-hook 'kill-emacs-hook #'buffer-sets-unload-all-buffer-sets)
+        (add-hook 'kill-emacs-hook #'buffer-sets-save-definitions))
     (progn
-      (buffer-layers-save-definitions)
+      (buffer-sets-save-definitions)
       (define-key ctl-x-map (kbd "L") nil)
-      (remove-hook 'kill-emacs-hook #'buffer-layers-unload-all-buffer-layers)
-      (remove-hook 'kill-emacs-hook #'buffer-layers-save-definitions))))
+      (remove-hook 'kill-emacs-hook #'buffer-sets-unload-all-buffer-sets)
+      (remove-hook 'kill-emacs-hook #'buffer-sets-save-definitions))))
 
 (provide 'buffer-sets)
 
-;;; buffer-layers.el ends here
+;;; buffer-sets.el ends here