From 68b7203749be6cf6e668d0eca5aa8234550804c9 Mon Sep 17 00:00:00 2001 From: Henrik Lissner Date: Tue, 17 Jan 2017 23:26:48 -0500 Subject: [PATCH] init: remove files, buffers from :emacs (now in lib)g --- init.example.el | 2 - modules/lib/buffers/autoload.el | 291 ++++++++++++++++++++++++++++++++ 2 files changed, 291 insertions(+), 2 deletions(-) create mode 100644 modules/lib/buffers/autoload.el diff --git a/init.example.el b/init.example.el index 0def8b8cb..386fe896a 100644 --- a/init.example.el +++ b/init.example.el @@ -37,8 +37,6 @@ dired ; eshell ; a consistent, cross-platform shell org ; for organized fearless leader - files ; library for manipulating files - buffers ;; Applications are large-scale states that, when activated, will ;; transform Emacs into something other than an editor. See diff --git a/modules/lib/buffers/autoload.el b/modules/lib/buffers/autoload.el new file mode 100644 index 000000000..ace20478a --- /dev/null +++ b/modules/lib/buffers/autoload.el @@ -0,0 +1,291 @@ +;;; autoload.el + +(defvar-local +buffer--narrowed-origin nil) + +(defvar +buffers-unreal-alist + '("^ ?\\*.+" image-mode dired-mode reb-mode messages-buffer-mode + tabulated-list-mode comint-mode magit-mode) + "A list of regexps or modes whose buffers are considered unreal, and will be +ignored when using `doom:next-real-buffer' and `doom:previous-real-buffer' (or +killed by `doom:kill-old-buffers', or after `+buffer-kill').") + +(defvar +buffers-processes-alist + '(("pry" . ruby-mode) + ("irb" . ruby-mode) + ("ipython" . python-mode) + ("tide" . typescript-mode)) + "An alist of (process-name . major-mode) that `+buffers-kill-process-buffers' +checks before killing processes. If there are no buffers with matching +major-modes, the process gets killed.") + +;;;###autoload (autoload '+buffer:narrow "lib/buffer/autoload" nil t) +(evil-define-operator +buffer:narrow (&optional beg end bang) + "Restrict editing in this buffer to the current region, indirectly. With BANG, +clone the buffer and hard-narrow the selection. If mark isn't active, then widen +the buffer (if narrowed). + +Inspired from http://demonastery.org/2013/04/emacs-evil-narrow-region/" + (interactive "") + (if (region-active-p) + (progn + (deactivate-mark) + (when bang + (let ((old-buf (current-buffer))) + (switch-to-buffer (clone-indirect-buffer nil nil)) + (setq +buffer--narrowed-origin old-buf))) + (narrow-to-region beg end)) + (if +buffer--narrowed-origin + (progn + (kill-this-buffer) + (switch-to-buffer +buffer--narrowed-origin) + (setq +buffer--narrowed-origin nil)) + (widen)))) + +;;;###autoload +(defun +buffer-set-readonly-region (begin end) + "Mark a region as read-only (http://stackoverflow.com/questions/7410125)" + (let ((modified (buffer-modified-p))) + (add-text-properties begin end '(read-only t)) + (set-buffer-modified-p modified))) + +;;;###autoload +(defun +buffer-unset-readonly-region (begin end) + "Undoes `+buffer-set-readonly-region' (http://stackoverflow.com/questions/7410125)" + (let ((modified (buffer-modified-p)) + (inhibit-read-only t)) + (remove-text-properties begin end '(read-only t)) + (set-buffer-modified-p modified))) + + +;; Buffer Life and Death ;;;;;;;;;;;;;;; + +;;;###autoload +(defun +buffers-list (&optional all-p) + "Get all buffers in the current project, in the current workgroup. + +If ALL-P is non-nil, get all buffers across all projects in current +workgroup." + (let ((buffers (if (wg-current-workgroup t) + (+buffers-in-workgroup) + (buffer-list))) + (project-root (and (not all-p) (doom-project-root t)))) + (append (if project-root + (funcall (if (eq all-p 'not) '-remove '-filter) + (lambda (b) (projectile-project-buffer-p b project-root)) + buffers) + buffers) + (list doom-buffer)))) + +;;;###autoload +(defun +buffers-list-real (&optional buffer-list) + "Get a list of all buffers (in the current workgroup OR in BUFFER-LIST) that +`+buffer-real-p' returns non-nil for." + (-filter #'+buffer-real-p (or buffer-list (+buffers-list)))) + +;;;###autoload +(defun +buffers-in-workspace () + "Get a list of buffers in current workgroup. Returns nil if workgroups2 isn't +loaded." + (when (featurep 'workgroups2) + (let ((assoc-bufs (wg-workgroup-associated-buffers nil))) + (--filter (memq it assoc-bufs) (buffer-list))))) + +;;;###autoload +(defun +buffers-in-mode (modes &optional buffer-list) + "Get a list of all buffers (in the current workgroup OR in BUFFER-LIST) whose +`major-mode' is one of MODES." + (--filter (memq (buffer-local-value 'major-mode it) modes) + (or buffer-list (+buffers-list)))) + +;;;###autoload +(defun +buffers-visible-windows (&optional window-list) + "Get a list of the visible windows in the current frame (that aren't popups), +OR return only the visible windows in WINDOW-LIST." + (-remove #'doom-popup-p (or window-list (window-list)))) + +;;;###autoload +(defun +buffers-visible (&optional buffer-list) + "Get a list of unburied buffers in the current project and workgroup, OR +return only the unburied buffers in BUFFER-LIST (a list of BUFFER-OR-NAMEs)." + (-filter #'get-buffer-window (or buffer-list (+buffers-list)))) + +;;;###autoload +(defun +buffers-buried (&optional buffer-list) + "Get a list of buried buffers in the current project and workgroup, OR return +only the buried buffers in BUFFER-LIST (a list of BUFFER-OR-NAMEs)." + (-remove 'get-buffer-window (or buffer-list (+buffers-list)))) + +;;;###autoload +(defun +buffers-matching (pattern &optional buffer-list) + "Get a list of all buffers (in the current workgroup OR in BUFFER-LIST) that +match the regex PATTERN." + (--filter (string-match-p pattern (buffer-name it)) + (or buffer-list (+buffers-list)))) + +;;;###autoload +(defun +buffer-kill () + "Kill buffer then switch to a real buffer. Buries the buffer if it is being +displayed in another window. + +See `+buffer-real-p' for what 'real' means." + (interactive) + (let* ((scratch-p (doom-scratch-buffer-p)) + (old-project (doom-project-root)) + (buffer (current-buffer)) + (only-buffer-window-p (= (length (get-buffer-window-list buffer nil t)) 1))) + (unless scratch-p + (when (and buffer-file-name only-buffer-window-p (buffer-modified-p)) + (if (yes-or-no-p "Buffer is unsaved, save it?") + (save-buffer) + (set-buffer-modified-p nil))) + (+buffer-previous) + (unless (eq (current-buffer) buffer) + (when only-buffer-window-p + (kill-buffer buffer) + (unless (+buffer-real-p) + (+buffer-previous)))))) + ;;; TODO Add to `kill-buffer-hook' + ;; (when (doom-scratch-buffer-p) + ;; (doom-scratch-force-reload)) + t) + +;;;###autoload +(defun +buffers-kill-process-buffers () + "Kill all buried buffers that represent running processes." + (interactive) + (let ((buffer-list (buffer-list)) + (killed-processes 0)) + (dolist (p (process-list)) + (let* ((process-name (process-name p)) + (assoc (assoc process-name +buffers-processes-alist))) + (when (and assoc + (not (string= process-name "server")) + (process-live-p p) + (not (--any? (let ((mode (buffer-local-value 'major-mode it))) + (eq mode (cdr assoc))) + buffer-list))) + (delete-process p) + (incf killed-processes)))) + (message "Cleaned up %s processes" killed-processes))) + +;;;###autoload +(defun +buffers-kill-matching (pattern &optional buffer-list) + "Kill all buffers (in current workgroup OR in BUFFER-LIST) that match the +regex PATTERN." + (interactive) + (let ((i 0)) + (mapc (lambda (b) + (when (string-match-p pattern (buffer-name b)) + (kill-buffer b) + (setq i (1+ i)))) + (if buffer-list buffer-list (+buffers-list))) + (message "Killed %s matches" i))) + +(defun +buffers--cycle-real-buffers (&optional n) + "Switch to the previous buffer, skipping over special buffers. If there's +nothing left, create a scratch buffer." + (let* ((start-buffer (current-buffer)) + (move-func (if (> n 0) 'switch-to-next-buffer 'switch-to-prev-buffer)) + (max 25) + (i 0) + (continue t) + (buffers (+buffers-list-real (+buffers-list t))) + (fail-buffer (if (> (length (get-buffer-window-list doom-buffer nil t)) 1) + start-buffer + doom-buffer)) + destbuf) + (setq destbuf + (catch 'goto + (if (or (not buffers) + (= (length buffers) 1)) + (progn (message "No other buffers in workgroup") + (throw 'goto fail-buffer)) + (funcall move-func) + (while (not (memq (current-buffer) buffers)) + (if (or (eq (current-buffer) start-buffer) + (>= i max)) + (throw 'goto fail-buffer) + (funcall move-func)) + (cl-incf i)) + (current-buffer)))) + (when (eq destbuf doom-buffer) + (doom-scratch-reload) + (message "Nowhere to go")) + (switch-to-buffer destbuf))) + +;;;###autoload +(defun +buffer-real-p (&optional buffer) + "Returns whether BUFFER a 'real' buffer or not. Real means: a) it isn't a +popup (or temporary) window and b) it isn't a special buffer (e.g. scratch or +*messages* buffer). See `+buffers-unreal-alist'." + (setq buffer (or (and (bufferp buffer) buffer) + (and (stringp buffer) (get-buffer buffer)) + (current-buffer))) + (when (buffer-live-p buffer) + (with-current-buffer buffer + (not (or (apply #'derived-mode-p (-filter 'symbolp +buffers-unreal-alist)) + (--any? (string-match-p it (buffer-name buffer)) + (-filter 'stringp +buffers-unreal-alist))))))) + +;;;###autoload +(defun +buffer-next () + "Switch to the next real buffer, skipping special buffers. See +`+buffer-real-p'." + (interactive) + (+buffers--cycle-real-buffers +1)) + +;;;###autoload +(defun +buffer-previous () + "Switch to the previous real buffer, skipping special buffers. See +`+buffer-real-p'." + (interactive) + (+buffers--cycle-real-buffers -1)) + +(defun +buffers--kill (buffers &optional filter-func) + (let ((buffers (if filter-func (-filter filter-func buffers) buffers)) + (affected 0)) + (mapc (lambda (b) (when (kill-buffer b) (incf affected))) buffers) + (unless (+buffer-real-p) + (+buffer-previous)) + (message "Killed %s buffers" affected))) + +;;;###autoload (autoload '+buffers:kill-all "lib/buffer/autoload" nil t) +(evil-define-command +buffers:kill-all (&optional bang) + "Kill all buffers in this workgroup. If BANG, kill *all* buffers in workgroup +that belong to this project. Returns to the doom scratch buffer." + (interactive "") + (+buffers--kill (--filter (not (eq it doom-buffer)) + (+buffers-list (not bang)))) + (unless bang + (delete-other-windows)) + (switch-to-buffer doom-buffer)) + +;;;###autoload (autoload '+buffers:kill-others "lib/buffer/autoload" nil t) +(evil-define-command +buffers:kill-others (&optional bang) + "Kill all other buffers in this workgroup. If BANG, kill only the other +buffers that belong to the current project." + (interactive "") + (+buffers--kill (+buffers-list (not bang)) + (lambda (b) (not (eq b (current-buffer))))) + (when bang + (delete-other-windows))) + +;;;###autoload (autoload '+buffers:kill-matching "lib/buffer/autoload" nil t) +(evil-define-command +buffers:kill-matching (&optional bang pattern) + "Kill buffers in current workgroup that match regex PATTERN. If BANG, then +exclude buffers that aren't part of the current project." + :repeat nil + (interactive "") + (+buffers--kill (+buffers-list-matching pattern (+buffers-list (not bang))))) + +;;;###autoload (autoload '+buffers:cleanup "lib/buffer/autoload" nil t) +(evil-define-command +buffers:cleanup (&optional bang) + "Kill all buried and unreal buffers in the current workgroup." + (interactive "") + (let ((kill-list (+buffers-list-buried (+buffers-list t)))) + (+buffers--kill kill-list) + (+buffers-kill-process-buffers) + (message "Cleaned up %s buffers" (length kill-list)))) + +(provide 'autoload) +;;; autoload.el ends here