diff --git a/bundle/custom.el b/bundle/custom.el index 29841e73..cf13f448 100644 --- a/bundle/custom.el +++ b/bundle/custom.el @@ -68,7 +68,7 @@ '(package-enable-at-startup t) '(package-selected-packages (quote - (graphviz-dot-mode dot-mode plantuml-mode elisp-format elisp-lint flymake-racket google-translate org-pomodoro olivetti elm-mode dashboard pickle poet-theme flymake-eslint json-mode elpy darkroom dockerfile-mode ein spacemacs-theme flucui-themes leuven-theme htmlize scss-mode berrys-theme web-mode python-docstring sphinx-doc sphinx-frontend sphinx-mode ox-nikola racket-mode slime gherkin-mode powershell typescript-mode ob-http ob-ipython ob-restclient nord-theme restclient request restclient-test yaml-mode magit))) + (ace-window graphviz-dot-mode dot-mode plantuml-mode elisp-format elisp-lint flymake-racket google-translate org-pomodoro elm-mode dashboard pickle poet-theme flymake-eslint json-mode elpy darkroom dockerfile-mode ein spacemacs-theme flucui-themes leuven-theme htmlize scss-mode berrys-theme web-mode python-docstring sphinx-doc sphinx-frontend sphinx-mode ox-nikola racket-mode slime gherkin-mode powershell typescript-mode ob-http ob-ipython ob-restclient nord-theme restclient request restclient-test yaml-mode magit))) '(python-shell-interpreter "python3") '(register-preview-delay 2) '(register-separator 43) diff --git a/elpa/ace-window-20200311.1025/ace-window-autoloads.el b/elpa/ace-window-20200311.1025/ace-window-autoloads.el new file mode 100644 index 00000000..e720b3a2 --- /dev/null +++ b/elpa/ace-window-20200311.1025/ace-window-autoloads.el @@ -0,0 +1,81 @@ +;;; ace-window-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "ace-window" "ace-window.el" (0 0 0 0)) +;;; Generated autoloads from ace-window.el + +(autoload 'ace-select-window "ace-window" "\ +Ace select window. + +\(fn)" t nil) + +(autoload 'ace-delete-window "ace-window" "\ +Ace delete window. + +\(fn)" t nil) + +(autoload 'ace-swap-window "ace-window" "\ +Ace swap window. + +\(fn)" t nil) + +(autoload 'ace-delete-other-windows "ace-window" "\ +Ace delete other windows. + +\(fn)" t nil) + +(autoload 'ace-display-buffer "ace-window" "\ +Make `display-buffer' and `pop-to-buffer' select using `ace-window'. +See sample config for `display-buffer-base-action' and `display-buffer-alist': +https://github.com/abo-abo/ace-window/wiki/display-buffer. + +\(fn BUFFER ALIST)" nil nil) + +(autoload 'ace-window "ace-window" "\ +Select a window. +Perform an action based on ARG described below. + +By default, behaves like extended `other-window'. +See `aw-scope' which extends it to work with frames. + +Prefixed with one \\[universal-argument], does a swap between the +selected window and the current window, so that the selected +buffer moves to current window (and current buffer moves to +selected window). + +Prefixed with two \\[universal-argument]'s, deletes the selected +window. + +\(fn ARG)" t nil) + +(defvar ace-window-display-mode nil "\ +Non-nil if Ace-Window-Display mode is enabled. +See the `ace-window-display-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `ace-window-display-mode'.") + +(custom-autoload 'ace-window-display-mode "ace-window" nil) + +(autoload 'ace-window-display-mode "ace-window" "\ +Minor mode for showing the ace window key in the mode line. + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ace-window" '("ace-window-mode" "aw-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; ace-window-autoloads.el ends here diff --git a/elpa/ace-window-20200311.1025/ace-window-pkg.el b/elpa/ace-window-20200311.1025/ace-window-pkg.el new file mode 100644 index 00000000..9462228e --- /dev/null +++ b/elpa/ace-window-20200311.1025/ace-window-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "ace-window" "20200311.1025" "Quickly switch windows." '((avy "0.5.0")) :commit "7003c88cd9cad58dc35c7cd13ebc61c355fb5be7" :keywords '("window" "location") :authors '(("Oleh Krehel" . "ohwoeowho@gmail.com")) :maintainer '("Oleh Krehel" . "ohwoeowho@gmail.com") :url "https://github.com/abo-abo/ace-window") diff --git a/elpa/ace-window-20200311.1025/ace-window.el b/elpa/ace-window-20200311.1025/ace-window.el new file mode 100644 index 00000000..53593a05 --- /dev/null +++ b/elpa/ace-window-20200311.1025/ace-window.el @@ -0,0 +1,953 @@ +;;; ace-window.el --- Quickly switch windows. -*- lexical-binding: t -*- + +;; Copyright (C) 2015-2020 Free Software Foundation, Inc. + +;; Author: Oleh Krehel +;; Maintainer: Oleh Krehel +;; URL: https://github.com/abo-abo/ace-window +;; Package-Version: 20200311.1025 +;; Version: 0.10.0 +;; Package-Requires: ((avy "0.5.0")) +;; Keywords: window, location + +;; This file is part of GNU Emacs. + +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; For a full copy of the GNU General Public License +;; see . + +;;; Commentary: +;; +;; The main function, `ace-window' is meant to replace `other-window' +;; by assigning each window a short, unique label. When there are only +;; two windows present, `other-window' is called (unless +;; aw-dispatch-always is set non-nil). If there are more, each +;; window will have its first label character highlighted. Once a +;; unique label is typed, ace-window will switch to that window. +;; +;; To setup this package, just add to your .emacs: +;; +;; (global-set-key (kbd "M-o") 'ace-window) +;; +;; replacing "M-o" with an appropriate shortcut. +;; +;; By default, ace-window uses numbers for window labels so the window +;; labeling is intuitively ordered. But if you prefer to type keys on +;; your home row for quicker access, use this setting: +;; +;; (setq aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l)) +;; +;; Whenever ace-window prompts for a window selection, it grays out +;; all the window characters, highlighting window labels in red. To +;; disable this behavior, set this: +;; +;; (setq aw-background nil) +;; +;; If you want to know the selection characters ahead of time, turn on +;; `ace-window-display-mode'. +;; +;; When prefixed with one `universal-argument', instead of switching +;; to the selected window, the selected window is swapped with the +;; current one. +;; +;; When prefixed with two `universal-argument', the selected window is +;; deleted instead. + +;;; Code: +(require 'avy) +(require 'ring) +(require 'subr-x) + +;;* Customization +(defgroup ace-window nil + "Quickly switch current window." + :group 'convenience + :prefix "aw-") + +(defcustom aw-keys '(?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9) + "Keys for selecting window." + :type '(repeat character)) + +(defcustom aw-scope 'global + "The scope used by `ace-window'." + :type '(choice + (const :tag "visible frames" visible) + (const :tag "global" global) + (const :tag "frame" frame))) + +(defcustom aw-translate-char-function #'identity + "Function to translate user input key into another key. +For example, to make SPC do the same as ?a, use +\(lambda (c) (if (= c 32) ?a c))." + :type '(choice + (const :tag "Off" #'identity) + (const :tag "Ignore Case" #'downcase) + (function :tag "Custom"))) + +(defcustom aw-minibuffer-flag nil + "When non-nil, also display `ace-window-mode' string in the minibuffer when ace-window is active." + :type 'boolean) + +(defcustom aw-ignored-buffers '("*Calc Trail*" " *LV*") + "List of buffers and major-modes to ignore when choosing a window from the window list. +Active only when `aw-ignore-on' is non-nil." + :type '(repeat string)) + +(defcustom aw-ignore-on t + "When t, `ace-window' will ignore buffers and major-modes in `aw-ignored-buffers'. +Use M-0 `ace-window' to toggle this value." + :type 'boolean) + +(defcustom aw-ignore-current nil + "When t, `ace-window' will ignore `selected-window'." + :type 'boolean) + +(defcustom aw-background t + "When t, `ace-window' will dim out all buffers temporarily when used." + :type 'boolean) + +(defcustom aw-leading-char-style 'char + "Style of the leading char overlay." + :type '(choice + (const :tag "single char" 'char) + (const :tag "full path" 'path))) + +(defcustom aw-dispatch-always nil + "When non-nil, `ace-window' will issue a `read-char' even for one window. +This will make `ace-window' act different from `other-window' for + one or two windows." + :type 'boolean) + +(defcustom aw-dispatch-when-more-than 2 + "If the number of windows is more than this, activate ace-window-ness." + :type 'integer) + +(defcustom aw-reverse-frame-list nil + "When non-nil `ace-window' will order frames for selection in +the reverse of `frame-list'" + :type 'boolean) + +(defcustom aw-frame-offset '(13 . 23) + "Increase in pixel offset for new ace-window frames relative to the selected frame. +Its value is an (x-offset . y-offset) pair in pixels." + :type '(cons integer integer)) + +(defcustom aw-frame-size nil + "Frame size to make new ace-window frames. +Its value is a (width . height) pair in pixels or nil for the default frame size. +(0 . 0) is special and means make the frame size the same as the last selected frame size." + :type '(cons integer integer)) + +(defcustom aw-char-position 'top-left + "Window positions of the character overlay. +Consider changing this if the overlay tends to overlap with other things." + :type '(choice + (const :tag "top left corner only" 'top-left) + (const :tag "both left corners" 'left))) + +;; Must be defined before `aw-make-frame-char' since its :set function references this. +(defvar aw-dispatch-alist + '((?x aw-delete-window "Delete Window") + (?m aw-swap-window "Swap Windows") + (?M aw-move-window "Move Window") + (?c aw-copy-window "Copy Window") + (?j aw-switch-buffer-in-window "Select Buffer") + (?n aw-flip-window) + (?u aw-switch-buffer-other-window "Switch Buffer Other Window") + (?e aw-execute-command-other-window "Execute Command Other Window") + (?F aw-split-window-fair "Split Fair Window") + (?v aw-split-window-vert "Split Vert Window") + (?b aw-split-window-horz "Split Horz Window") + (?o delete-other-windows "Delete Other Windows") + (?T aw-transpose-frame "Transpose Frame") + ;; ?i ?r ?t are used by hyperbole.el + (?? aw-show-dispatch-help)) + "List of actions for `aw-dispatch-default'. +Each action is a list of either: + (char function description) where function takes a single window argument +or + (char function) where function takes no argument and the description is omitted.") + +(defun aw-set-make-frame-char (option value) + ;; Signal an error if `aw-make-frame-char' is ever set to an invalid + ;; or conflicting value. + (when value + (cond ((not (characterp value)) + (user-error "`aw-make-frame-char' must be a character, not `%s'" value)) + ((memq value aw-keys) + (user-error "`aw-make-frame-char' is `%c'; this conflicts with the same character in `aw-keys'" value)) + ((assq value aw-dispatch-alist) + (user-error "`aw-make-frame-char' is `%c'; this conflicts with the same character in `aw-dispatch-alist'" value)))) + (set option value)) + +(defcustom aw-make-frame-char ?z + "Non-existing ace window label character that triggers creation of a new single-window frame for display." + :set 'aw-set-make-frame-char + :type 'character) + +(defface aw-leading-char-face + '((((class color)) (:foreground "red")) + (((background dark)) (:foreground "gray100")) + (((background light)) (:foreground "gray0")) + (t (:foreground "gray100" :underline nil))) + "Face for each window's leading char.") + +(defface aw-minibuffer-leading-char-face + '((t :inherit aw-leading-char-face)) + "Face for minibuffer leading char.") + +(defface aw-background-face + '((t (:foreground "gray40"))) + "Face for whole window background during selection.") + +(defface aw-mode-line-face + '((t (:inherit mode-line-buffer-id))) + "Face used for displaying the ace window key in the mode-line.") + +(defface aw-key-face + '((t :inherit font-lock-builtin-face)) + "Face used by `aw-show-dispatch-help'.") + +;;* Implementation +(defun aw-ignored-p (window) + "Return t if WINDOW should be ignored when choosing from the window list." + (or (and aw-ignore-on + ;; Ignore major-modes and buffer-names in `aw-ignored-buffers'. + (or (memq (buffer-local-value 'major-mode (window-buffer window)) + aw-ignored-buffers) + (member (buffer-name (window-buffer window)) aw-ignored-buffers))) + ;; ignore child frames + (and (fboundp 'frame-parent) (frame-parent (window-frame window))) + ;; Ignore selected window if `aw-ignore-current' is non-nil. + (and aw-ignore-current + (equal window (selected-window))) + ;; When `ignore-window-parameters' is nil, ignore windows whose + ;; `no-other-window’ or `no-delete-other-windows' parameter is non-nil. + (unless ignore-window-parameters + (cl-case this-command + (ace-select-window (window-parameter window 'no-other-window)) + (ace-delete-window (window-parameter window 'no-delete-other-windows)) + (ace-delete-other-windows (window-parameter + window 'no-delete-other-windows)))))) + +(defun aw-window-list () + "Return the list of interesting windows." + (sort + (cl-remove-if + (lambda (w) + (let ((f (window-frame w))) + (or (not (and (frame-live-p f) + (frame-visible-p f))) + (string= "initial_terminal" (terminal-name f)) + (aw-ignored-p w)))) + (cl-case aw-scope + (visible + (cl-mapcan #'window-list (visible-frame-list))) + (global + (cl-mapcan #'window-list (frame-list))) + (frame + (window-list)) + (t + (error "Invalid `aw-scope': %S" aw-scope)))) + 'aw-window<)) + +(defvar aw-overlays-back nil + "Hold overlays for when `aw-background' is t.") + +(defvar ace-window-mode nil + "Minor mode during the selection process.") + +;; register minor mode +(or (assq 'ace-window-mode minor-mode-alist) + (nconc minor-mode-alist + (list '(ace-window-mode ace-window-mode)))) + +(defvar aw-empty-buffers-list nil + "Store the read-only empty buffers which had to be modified. +Modify them back eventually.") + +(defvar aw--windows-hscroll nil + "List of (window . hscroll-columns) items, each listing a window whose + horizontal scroll will be restored upon ace-window action completion.") + +(defvar aw--windows-points nil + "List of (window . point) items. The point position had to be + moved in order to display the overlay.") + +(defun aw--done () + "Clean up mode line and overlays." + ;; mode line + (aw-set-mode-line nil) + ;; background + (mapc #'delete-overlay aw-overlays-back) + (setq aw-overlays-back nil) + (avy--remove-leading-chars) + (dolist (b aw-empty-buffers-list) + (with-current-buffer b + (when (string= (buffer-string) " ") + (let ((inhibit-read-only t)) + (delete-region (point-min) (point-max)))))) + (setq aw-empty-buffers-list nil) + (aw--restore-windows-hscroll) + (let (c) + (while (setq c (pop aw--windows-points)) + (with-selected-window (car c) + (goto-char (cdr c)))))) + +(defun aw--restore-windows-hscroll () + "Restore horizontal scroll of windows from `aw--windows-hscroll' list." + (let (wnd hscroll) + (mapc (lambda (wnd-and-hscroll) + (setq wnd (car wnd-and-hscroll) + hscroll (cdr wnd-and-hscroll)) + (when (window-live-p wnd) + (set-window-hscroll wnd hscroll))) + aw--windows-hscroll)) + (setq aw--windows-hscroll nil)) + +(defun aw--overlay-str (wnd pos path) + "Return the replacement text for an overlay in WND at POS, +accessible by typing PATH." + (let ((old-str (or + (ignore-errors + (with-selected-window wnd + (buffer-substring pos (1+ pos)))) + ""))) + (concat + (cl-case aw-leading-char-style + (char + (string (avy--key-to-char (car (last path))))) + (path + (mapconcat + (lambda (x) (string (avy--key-to-char x))) + (reverse path) + "")) + (t + (error "Bad `aw-leading-char-style': %S" + aw-leading-char-style))) + (cond ((string-equal old-str "\t") + (make-string (1- tab-width) ?\ )) + ((string-equal old-str "\n") + "\n") + (t + (make-string + (max 0 (1- (string-width old-str))) + ?\ )))))) + +(defun aw--point-visible-p () + "Return non-nil if point is visible in the selected window. +Return nil when horizontal scrolling has moved it off screen." + (and (>= (- (current-column) (window-hscroll)) 0) + (< (- (current-column) (window-hscroll)) + (window-width)))) + +(defun aw--lead-overlay (path leaf) + "Create an overlay using PATH at LEAF. +LEAF is (PT . WND)." + ;; Properly adds overlay in visible region of most windows except for any one + ;; receiving output while this function is executing, since that moves point, + ;; potentially shifting the added overlay outside the window's visible region. + (let ((wnd (cdr leaf)) + ;; Prevent temporary movement of point from scrolling any window. + (scroll-margin 0)) + (with-selected-window wnd + (when (= 0 (buffer-size)) + (push (current-buffer) aw-empty-buffers-list) + (let ((inhibit-read-only t)) + (insert " "))) + ;; If point is not visible due to horizontal scrolling of the + ;; window, this next expression temporarily scrolls the window + ;; right until point is visible, so that the leading-char can be + ;; seen when it is inserted. When ace-window's action finishes, + ;; the horizontal scroll is restored by (aw--done). + (while (and (not (aw--point-visible-p)) + (not (zerop (window-hscroll))) + (progn (push (cons (selected-window) (window-hscroll)) aw--windows-hscroll) t) + (not (zerop (scroll-right))))) + (let* ((ws (window-start)) + (prev nil) + (vertical-pos (if (eq aw-char-position 'left) -1 0)) + (horizontal-pos (if (zerop (window-hscroll)) 0 (1+ (window-hscroll)))) + (old-pt (point)) + (pt + (progn + ;; If leading-char is to be displayed at the top-left, move + ;; to the first visible line in the window, otherwise, move + ;; to the last visible line. + (move-to-window-line vertical-pos) + (move-to-column horizontal-pos) + ;; Find a nearby point that is not at the end-of-line but + ;; is visible so have space for the overlay. + (setq prev (1- (point))) + (while (and (>= prev ws) (/= prev (point)) (eolp)) + (setq prev (point)) + (unless (bobp) + (line-move -1 t) + (move-to-column horizontal-pos))) + (recenter vertical-pos) + (point))) + (ol (make-overlay pt (1+ pt) (window-buffer wnd)))) + (if (= (aw--face-rel-height) 1) + (goto-char old-pt) + (when (/= pt old-pt) + (goto-char (+ pt 1)) + (push (cons wnd old-pt) aw--windows-points))) + (overlay-put ol 'display (aw--overlay-str wnd pt path)) + (if (window-minibuffer-p wnd) + (overlay-put ol 'face 'aw-minibuffer-leading-char-face) + (overlay-put ol 'face 'aw-leading-char-face)) + (overlay-put ol 'window wnd) + (push ol avy--overlays-lead))))) + +(defun aw--make-backgrounds (wnd-list) + "Create a dim background overlay for each window on WND-LIST." + (when aw-background + (setq aw-overlays-back + (mapcar (lambda (w) + (let ((ol (make-overlay + (window-start w) + (window-end w) + (window-buffer w)))) + (overlay-put ol 'face 'aw-background-face) + ol)) + wnd-list)))) + +(defvar aw-dispatch-function 'aw-dispatch-default + "Function to call when a character not in `aw-keys' is pressed.") + +(defvar aw-action nil + "Function to call at the end of `aw-select'.") + +(defun aw-set-mode-line (str) + "Set mode line indicator to STR." + (setq ace-window-mode str) + (when (and aw-minibuffer-flag ace-window-mode) + (message "%s" (string-trim-left str))) + (force-mode-line-update)) + +(defun aw--dispatch-action (char) + "Return item from `aw-dispatch-alist' matching CHAR." + (assoc char aw-dispatch-alist)) + +(defun aw-make-frame () + "Make a new Emacs frame using the values of `aw-frame-size' and `aw-frame-offset'." + (make-frame + (delq nil + (list + ;; This first parameter is important because an + ;; aw-dispatch-alist command may not want to leave this + ;; frame with input focus. If it is given focus, the + ;; command may not be able to return focus to a different + ;; frame since this is done asynchronously by the window + ;; manager. + '(no-focus-on-map . t) + (when aw-frame-size + (cons 'width + (if (zerop (car aw-frame-size)) + (frame-width) + (car aw-frame-size)))) + (when aw-frame-size + (cons 'height + (if (zerop (cdr aw-frame-size)) + (frame-height) + (car aw-frame-size)))) + (cons 'left (+ (car aw-frame-offset) + (car (frame-position)))) + (cons 'top (+ (cdr aw-frame-offset) + (cdr (frame-position)))))))) + +(defun aw-use-frame (window) + "Create a new frame using the contents of WINDOW. + +The new frame is set to the same size as the previous frame, offset by +`aw-frame-offset' (x . y) pixels." + (aw-switch-to-window window) + (aw-make-frame)) + +(defun aw-clean-up-avy-current-path () + "Edit `avy-current-path' so only window label characters remain." + ;; Remove any possible ace-window command char that may + ;; precede the last specified window label, so + ;; functions can use `avy-current-path' as the chosen + ;; window label. + (when (and (> (length avy-current-path) 0) + (assq (aref avy-current-path 0) aw-dispatch-alist)) + (setq avy-current-path (substring avy-current-path 1)))) + +(defun aw-dispatch-default (char) + "Perform an action depending on CHAR." + (cond ((and (fboundp 'avy-mouse-event-window) + (avy-mouse-event-window char))) + ((= char (aref (kbd "C-g") 0)) + (throw 'done 'exit)) + ((and aw-make-frame-char (= char aw-make-frame-char)) + ;; Make a new frame and perform any action on its window. + (let ((start-win (selected-window)) + (end-win (frame-selected-window (aw-make-frame)))) + (if aw-action + ;; Action must be called from the start-win. The action + ;; determines which window to leave selected. + (progn (select-frame-set-input-focus (window-frame start-win)) + (funcall aw-action end-win)) + ;; Select end-win when no action + (aw-switch-to-window end-win))) + (throw 'done 'exit)) + (t + (let ((action (aw--dispatch-action char))) + (if action + (cl-destructuring-bind (_key fn &optional description) action + (if (and fn description) + (prog1 (setq aw-action fn) + (aw-set-mode-line (format " Ace - %s" description))) + (if (commandp fn) + (call-interactively fn) + (funcall fn)) + (throw 'done 'exit))) + (aw-clean-up-avy-current-path) + ;; Prevent any char from triggering an avy dispatch command. + (let ((avy-dispatch-alist)) + (avy-handler-default char))))))) + +(defcustom aw-display-mode-overlay t + "When nil, don't display overlays. Rely on the mode line instead." + :type 'boolean) + +(defvar ace-window-display-mode) + +(defun aw-select (mode-line &optional action) + "Return a selected other window. +Amend MODE-LINE to the mode line for the duration of the selection." + (setq aw-action action) + (let ((start-window (selected-window)) + (next-window-scope (cl-case aw-scope + ('visible 'visible) + ('global 'visible) + ('frame 'frame))) + (wnd-list (aw-window-list)) + window) + (setq window + (cond ((<= (length wnd-list) 1) + (when aw-dispatch-always + (setq aw-action + (unwind-protect + (catch 'done + (funcall aw-dispatch-function (read-char))) + (aw--done))) + (when (eq aw-action 'exit) + (setq aw-action nil))) + (or (car wnd-list) start-window)) + ((and (<= (+ (length wnd-list) (if (aw-ignored-p start-window) 1 0)) + aw-dispatch-when-more-than) + (not aw-dispatch-always) + (not aw-ignore-current)) + (let ((wnd (next-window nil nil next-window-scope))) + (while (and (or (not (memq wnd wnd-list)) + (aw-ignored-p wnd)) + (not (equal wnd start-window))) + (setq wnd (next-window wnd nil next-window-scope))) + wnd)) + (t + (let ((candidate-list + (mapcar (lambda (wnd) + (cons (aw-offset wnd) wnd)) + wnd-list))) + (aw--make-backgrounds wnd-list) + (aw-set-mode-line mode-line) + ;; turn off helm transient map + (remove-hook 'post-command-hook 'helm--maybe-update-keymap) + (unwind-protect + (let* ((avy-handler-function aw-dispatch-function) + (avy-translate-char-function aw-translate-char-function) + (transient-mark-mode nil) + (res (avy-read (avy-tree candidate-list aw-keys) + (if (and ace-window-display-mode + (null aw-display-mode-overlay)) + (lambda (_path _leaf)) + #'aw--lead-overlay) + #'avy--remove-leading-chars))) + (if (eq res 'exit) + (setq aw-action nil) + (or (cdr res) + start-window))) + (aw--done)))))) + (if aw-action + (funcall aw-action window) + window))) + +;;* Interactive +;;;###autoload +(defun ace-select-window () + "Ace select window." + (interactive) + (aw-select " Ace - Window" + #'aw-switch-to-window)) + +;;;###autoload +(defun ace-delete-window () + "Ace delete window." + (interactive) + (aw-select " Ace - Delete Window" + #'aw-delete-window)) + +;;;###autoload +(defun ace-swap-window () + "Ace swap window." + (interactive) + (aw-select " Ace - Swap Window" + #'aw-swap-window)) + +;;;###autoload +(defun ace-delete-other-windows () + "Ace delete other windows." + (interactive) + (aw-select " Ace - Delete Other Windows" + #'delete-other-windows)) + +;;;###autoload +(defun ace-display-buffer (buffer alist) + "Make `display-buffer' and `pop-to-buffer' select using `ace-window'. +See sample config for `display-buffer-base-action' and `display-buffer-alist': +https://github.com/abo-abo/ace-window/wiki/display-buffer." + (let* ((aw-ignore-current (cdr (assq 'inhibit-same-window alist))) + (rf (cdr (assq 'reusable-frames alist))) + (aw-scope (cl-case rf + ((nil) 'frame) + (visible 'visible) + ((0 t) 'global)))) + (unless (or (<= (length (aw-window-list)) 1) + (not aw-scope)) + (window--display-buffer + buffer (aw-select "Ace - Display Buffer") 'reuse)))) + +(declare-function transpose-frame "ext:transpose-frame") +(defun aw-transpose-frame (w) + "Select any window on frame and `tranpose-frame'." + (transpose-frame (window-frame w))) + +;;;###autoload +(defun ace-window (arg) + "Select a window. +Perform an action based on ARG described below. + +By default, behaves like extended `other-window'. +See `aw-scope' which extends it to work with frames. + +Prefixed with one \\[universal-argument], does a swap between the +selected window and the current window, so that the selected +buffer moves to current window (and current buffer moves to +selected window). + +Prefixed with two \\[universal-argument]'s, deletes the selected +window." + (interactive "p") + (setq avy-current-path "") + (cl-case arg + (0 + (let ((aw-ignore-on (not aw-ignore-on))) + (ace-select-window))) + (4 (ace-swap-window)) + (16 (ace-delete-window)) + (t (ace-select-window)))) + +;;* Utility +(unless (fboundp 'frame-position) + (defun frame-position (&optional frame) + (let ((pl (frame-parameter frame 'left)) + (pt (frame-parameter frame 'top))) + (when (consp pl) + (setq pl (eval pl))) + (when (consp pt) + (setq pt (eval pt))) + (cons pl pt)))) + +(defun aw-window< (wnd1 wnd2) + "Return true if WND1 is less than WND2. +This is determined by their respective window coordinates. +Windows are numbered top down, left to right." + (let* ((f1 (window-frame wnd1)) + (f2 (window-frame wnd2)) + (e1 (window-edges wnd1)) + (e2 (window-edges wnd2)) + (p1 (frame-position f1)) + (p2 (frame-position f2)) + (nl (or (null (car p1)) (null (car p2))))) + (cond ((and (not nl) (< (car p1) (car p2))) + (not aw-reverse-frame-list)) + ((and (not nl) (> (car p1) (car p2))) + aw-reverse-frame-list) + ((< (car e1) (car e2)) + t) + ((> (car e1) (car e2)) + nil) + ((< (cadr e1) (cadr e2)) + t)))) + +(defvar aw--window-ring (make-ring 10) + "Hold the window switching history.") + +(defun aw--push-window (window) + "Store WINDOW to `aw--window-ring'." + (when (or (zerop (ring-length aw--window-ring)) + (not (equal + (ring-ref aw--window-ring 0) + window))) + (ring-insert aw--window-ring (selected-window)))) + +(defun aw--pop-window () + "Return the removed top of `aw--window-ring'." + (let (res) + (condition-case nil + (while (or (not (window-live-p + (setq res (ring-remove aw--window-ring 0)))) + (equal res (selected-window)))) + (error + (if (= (length (aw-window-list)) 2) + (progn + (other-window 1) + (setq res (selected-window))) + (error "No previous windows stored")))) + res)) + +(defun aw-switch-to-window (window) + "Switch to the window WINDOW." + (let ((frame (window-frame window))) + (aw--push-window (selected-window)) + (when (and (frame-live-p frame) + (not (eq frame (selected-frame)))) + (select-frame-set-input-focus frame)) + (if (window-live-p window) + (select-window window) + (error "Got a dead window %S" window)))) + +(defun aw-flip-window () + "Switch to the window you were previously in." + (interactive) + (aw-switch-to-window (aw--pop-window))) + +(defun aw-show-dispatch-help () + "Display action shortucts in echo area." + (interactive) + (message "%s" (mapconcat + (lambda (action) + (cl-destructuring-bind (key fn &optional description) action + (format "%s: %s" + (propertize + (char-to-string key) + 'face 'aw-key-face) + (or description fn)))) + aw-dispatch-alist + "\n")) + ;; Prevent this from replacing any help display + ;; in the minibuffer. + (let (aw-minibuffer-flag) + (mapc #'delete-overlay aw-overlays-back) + (call-interactively 'ace-window))) + +(defun aw-delete-window (window &optional kill-buffer) + "Delete window WINDOW. +When KILL-BUFFER is non-nil, also kill the buffer." + (let ((frame (window-frame window))) + (when (and (frame-live-p frame) + (not (eq frame (selected-frame)))) + (select-frame-set-input-focus (window-frame window))) + (if (= 1 (length (window-list))) + (delete-frame frame) + (if (window-live-p window) + (let ((buffer (window-buffer window))) + (delete-window window) + (when kill-buffer + (kill-buffer buffer))) + (error "Got a dead window %S" window))))) + +(defun aw-switch-buffer-in-window (window) + "Select buffer in WINDOW." + (aw-switch-to-window window) + (aw--switch-buffer)) + +(declare-function ivy-switch-buffer "ext:ivy") + +(defun aw--switch-buffer () + (cond ((bound-and-true-p ivy-mode) + (ivy-switch-buffer)) + ((bound-and-true-p ido-mode) + (ido-switch-buffer)) + (t + (call-interactively 'switch-to-buffer)))) + +(defcustom aw-swap-invert nil + "When non-nil, the other of the two swapped windows gets the point." + :type 'boolean) + +(defun aw-swap-window (window) + "Swap buffers of current window and WINDOW." + (cl-labels ((swap-windows (window1 window2) + "Swap the buffers of WINDOW1 and WINDOW2." + (let ((buffer1 (window-buffer window1)) + (buffer2 (window-buffer window2))) + (set-window-buffer window1 buffer2) + (set-window-buffer window2 buffer1) + (select-window window2)))) + (let ((frame (window-frame window)) + (this-window (selected-window))) + (when (and (frame-live-p frame) + (not (eq frame (selected-frame)))) + (select-frame-set-input-focus (window-frame window))) + (when (and (window-live-p window) + (not (eq window this-window))) + (aw--push-window this-window) + (if aw-swap-invert + (swap-windows window this-window) + (swap-windows this-window window)))))) + +(defun aw-move-window (window) + "Move the current buffer to WINDOW. +Switch the current window to the previous buffer." + (let ((buffer (current-buffer))) + (switch-to-buffer (other-buffer)) + (aw-switch-to-window window) + (switch-to-buffer buffer))) + +(defun aw-copy-window (window) + "Copy the current buffer to WINDOW." + (let ((buffer (current-buffer))) + (aw-switch-to-window window) + (switch-to-buffer buffer))) + +(defun aw-split-window-vert (window) + "Split WINDOW vertically." + (select-window window) + (split-window-vertically)) + +(defun aw-split-window-horz (window) + "Split WINDOW horizontally." + (select-window window) + (split-window-horizontally)) + +(defcustom aw-fair-aspect-ratio 2 + "The aspect ratio to aim for when splitting windows. +Sizes are based on the number of characters, not pixels. +Increase to prefer wider windows, or decrease for taller windows." + :type 'number) + +(defun aw-split-window-fair (window) + "Split WINDOW vertically or horizontally, based on its current dimensions. +Modify `aw-fair-aspect-ratio' to tweak behavior." + (let ((w (window-body-width window)) + (h (window-body-height window))) + (if (< (* h aw-fair-aspect-ratio) w) + (aw-split-window-horz window) + (aw-split-window-vert window)))) + +(defun aw-switch-buffer-other-window (window) + "Switch buffer in WINDOW." + (aw-switch-to-window window) + (unwind-protect + (aw--switch-buffer) + (aw-flip-window))) + +(defun aw-execute-command-other-window (window) + "Execute a command in WINDOW." + (aw-switch-to-window window) + (unwind-protect + (funcall + (key-binding + (read-key-sequence + "Enter key sequence: "))) + (aw-flip-window))) + +(defun aw--face-rel-height () + (let ((h (face-attribute 'aw-leading-char-face :height))) + (cond + ((eq h 'unspecified) + 1) + ((floatp h) + (max (floor h) 1)) + ((integerp h) + 1) + (t + (error "unexpected: %s" h))))) + +(defun aw-offset (window) + "Return point in WINDOW that's closest to top left corner. +The point is writable, i.e. it's not part of space after newline." + (let ((h (window-hscroll window)) + (beg (window-start window)) + (end (window-end window)) + (inhibit-field-text-motion t)) + (with-current-buffer (window-buffer window) + (save-excursion + (goto-char beg) + (forward-line (1- + (min + (count-lines + (point) + (point-max)) + (aw--face-rel-height)))) + (while (and (< (point) end) + (< (- (line-end-position) + (line-beginning-position)) + h)) + (forward-line)) + (+ (point) h))))) + +(defun aw--after-make-frame (f) + (aw-update) + (make-frame-visible f)) + +;;* Mode line +;;;###autoload +(define-minor-mode ace-window-display-mode + "Minor mode for showing the ace window key in the mode line." + :global t + (if ace-window-display-mode + (progn + (aw-update) + (set-default + 'mode-line-format + `((ace-window-display-mode + (:eval (window-parameter (selected-window) 'ace-window-path))) + ,@(assq-delete-all + 'ace-window-display-mode + (default-value 'mode-line-format)))) + (force-mode-line-update t) + (add-hook 'window-configuration-change-hook 'aw-update) + ;; Add at the end so does not precede select-frame call. + (add-hook 'after-make-frame-functions #'aw--after-make-frame t)) + (set-default + 'mode-line-format + (assq-delete-all + 'ace-window-display-mode + (default-value 'mode-line-format))) + (remove-hook 'window-configuration-change-hook 'aw-update) + (remove-hook 'after-make-frame-functions 'aw--after-make-frame))) + +(defun aw-update () + "Update ace-window-path window parameter for all windows. + +Ensure all windows are labeled so the user can select a specific +one, even from the set of windows typically ignored when making a +window list." + (let ((aw-ignore-on) + (aw-ignore-current) + (ignore-window-parameters t)) + (avy-traverse + (avy-tree (aw-window-list) aw-keys) + (lambda (path leaf) + (set-window-parameter + leaf 'ace-window-path + (propertize + (apply #'string (reverse path)) + 'face 'aw-mode-line-face)))))) + +(provide 'ace-window) + +;;; ace-window.el ends here diff --git a/elpa/ace-window-20200311.1025/ace-window.elc b/elpa/ace-window-20200311.1025/ace-window.elc new file mode 100644 index 00000000..417c46c7 Binary files /dev/null and b/elpa/ace-window-20200311.1025/ace-window.elc differ diff --git a/elpa/ace-window-readme.txt b/elpa/ace-window-readme.txt new file mode 100644 index 00000000..847b3ddb --- /dev/null +++ b/elpa/ace-window-readme.txt @@ -0,0 +1,34 @@ +The main function, `ace-window' is meant to replace `other-window' +by assigning each window a short, unique label. When there are only +two windows present, `other-window' is called (unless +aw-dispatch-always is set non-nil). If there are more, each +window will have its first label character highlighted. Once a +unique label is typed, ace-window will switch to that window. + +To setup this package, just add to your .emacs: + + (global-set-key (kbd "M-o") 'ace-window) + +replacing "M-o" with an appropriate shortcut. + +By default, ace-window uses numbers for window labels so the window +labeling is intuitively ordered. But if you prefer to type keys on +your home row for quicker access, use this setting: + + (setq aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l)) + +Whenever ace-window prompts for a window selection, it grays out +all the window characters, highlighting window labels in red. To +disable this behavior, set this: + + (setq aw-background nil) + +If you want to know the selection characters ahead of time, turn on +`ace-window-display-mode'. + +When prefixed with one `universal-argument', instead of switching +to the selected window, the selected window is swapped with the +current one. + +When prefixed with two `universal-argument', the selected window is +deleted instead. diff --git a/elpa/archives/gnu/archive-contents b/elpa/archives/gnu/archive-contents index 6980f666..f66a8d64 100644 --- a/elpa/archives/gnu/archive-contents +++ b/elpa/archives/gnu/archive-contents @@ -1396,7 +1396,7 @@ ("Felix Lee , Michal Nazarewicz" . "mina86@mina86.com")) (:maintainer "Michal Nazarewicz" . "mina86@mina86.com"))]) (oauth2 . - [(0 11) + [(0 12) nil "OAuth 2.0 Authorization Protocol" single ((:url . "http://elpa.gnu.org/packages/oauth2.html") (:keywords "comm") diff --git a/elpa/avy-20200311.1106/avy-autoloads.el b/elpa/avy-20200311.1106/avy-autoloads.el new file mode 100644 index 00000000..28a10e8f --- /dev/null +++ b/elpa/avy-20200311.1106/avy-autoloads.el @@ -0,0 +1,272 @@ +;;; avy-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "avy" "avy.el" (0 0 0 0)) +;;; Generated autoloads from avy.el + +(autoload 'avy-goto-char "avy" "\ +Jump to the currently visible CHAR. +The window scope is determined by `avy-all-windows' (ARG negates it). + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-char-in-line "avy" "\ +Jump to the currently visible CHAR in the current line. + +\(fn CHAR)" t nil) + +(autoload 'avy-goto-char-2 "avy" "\ +Jump to the currently visible CHAR1 followed by CHAR2. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. + +\(fn CHAR1 CHAR2 &optional ARG BEG END)" t nil) + +(autoload 'avy-goto-char-2-above "avy" "\ +Jump to the currently visible CHAR1 followed by CHAR2. +This is a scoped version of `avy-goto-char-2', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR1 CHAR2 &optional ARG)" t nil) + +(autoload 'avy-goto-char-2-below "avy" "\ +Jump to the currently visible CHAR1 followed by CHAR2. +This is a scoped version of `avy-goto-char-2', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR1 CHAR2 &optional ARG)" t nil) + +(autoload 'avy-isearch "avy" "\ +Jump to one of the current isearch candidates. + +\(fn)" t nil) + +(autoload 'avy-goto-word-0 "avy" "\ +Jump to a word start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. + +\(fn ARG &optional BEG END)" t nil) + +(autoload 'avy-goto-whitespace-end "avy" "\ +Jump to the end of a whitespace sequence. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. + +\(fn ARG &optional BEG END)" t nil) + +(autoload 'avy-goto-word-1 "avy" "\ +Jump to the currently visible CHAR at a word start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. +When SYMBOL is non-nil, jump to symbol start instead of word start. + +\(fn CHAR &optional ARG BEG END SYMBOL)" t nil) + +(autoload 'avy-goto-word-1-above "avy" "\ +Jump to the currently visible CHAR at a word start. +This is a scoped version of `avy-goto-word-1', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-word-1-below "avy" "\ +Jump to the currently visible CHAR at a word start. +This is a scoped version of `avy-goto-word-1', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-symbol-1 "avy" "\ +Jump to the currently visible CHAR at a symbol start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-symbol-1-above "avy" "\ +Jump to the currently visible CHAR at a symbol start. +This is a scoped version of `avy-goto-symbol-1', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-symbol-1-below "avy" "\ +Jump to the currently visible CHAR at a symbol start. +This is a scoped version of `avy-goto-symbol-1', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-subword-0 "avy" "\ +Jump to a word or subword start. +The window scope is determined by `avy-all-windows' (ARG negates it). + +When PREDICATE is non-nil it's a function of zero parameters that +should return true. + +BEG and END narrow the scope where candidates are searched. + +\(fn &optional ARG PREDICATE BEG END)" t nil) + +(autoload 'avy-goto-subword-1 "avy" "\ +Jump to the currently visible CHAR at a subword start. +The window scope is determined by `avy-all-windows' (ARG negates it). +The case of CHAR is ignored. + +\(fn CHAR &optional ARG)" t nil) + +(autoload 'avy-goto-word-or-subword-1 "avy" "\ +Forward to `avy-goto-subword-1' or `avy-goto-word-1'. +Which one depends on variable `subword-mode'. + +\(fn)" t nil) + +(autoload 'avy-goto-line "avy" "\ +Jump to a line start in current buffer. + +When ARG is 1, jump to lines currently visible, with the option +to cancel to `goto-line' by entering a number. + +When ARG is 4, negate the window scope determined by +`avy-all-windows'. + +Otherwise, forward to `goto-line' with ARG. + +\(fn &optional ARG)" t nil) + +(autoload 'avy-goto-line-above "avy" "\ +Goto visible line above the cursor. +OFFSET changes the distance between the closest key to the cursor and +the cursor +When BOTTOM-UP is non-nil, display avy candidates from top to bottom + +\(fn &optional OFFSET BOTTOM-UP)" t nil) + +(autoload 'avy-goto-line-below "avy" "\ +Goto visible line below the cursor. +OFFSET changes the distance between the closest key to the cursor and +the cursor +When BOTTOM-UP is non-nil, display avy candidates from top to bottom + +\(fn &optional OFFSET BOTTOM-UP)" t nil) + +(autoload 'avy-goto-end-of-line "avy" "\ +Call `avy-goto-line' and move to the end of the line. + +\(fn &optional ARG)" t nil) + +(autoload 'avy-copy-line "avy" "\ +Copy a selected line above the current line. +ARG lines can be used. + +\(fn ARG)" t nil) + +(autoload 'avy-move-line "avy" "\ +Move a selected line above the current line. +ARG lines can be used. + +\(fn ARG)" t nil) + +(autoload 'avy-copy-region "avy" "\ +Select two lines and copy the text between them to point. + +The window scope is determined by `avy-all-windows' or +`avy-all-windows-alt' when ARG is non-nil. + +\(fn ARG)" t nil) + +(autoload 'avy-move-region "avy" "\ +Select two lines and move the text between them above the current line. + +\(fn)" t nil) + +(autoload 'avy-kill-region "avy" "\ +Select two lines and kill the region between them. + +The window scope is determined by `avy-all-windows' or +`avy-all-windows-alt' when ARG is non-nil. + +\(fn ARG)" t nil) + +(autoload 'avy-kill-ring-save-region "avy" "\ +Select two lines and save the region between them to the kill ring. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. + +\(fn ARG)" t nil) + +(autoload 'avy-kill-whole-line "avy" "\ +Select line and kill the whole selected line. + +With a numerical prefix ARG, kill ARG line(s) starting from the +selected line. If ARG is negative, kill backward. + +If ARG is zero, kill the selected line but exclude the trailing +newline. + +\\[universal-argument] 3 \\[avy-kil-whole-line] kill three lines +starting from the selected line. \\[universal-argument] -3 + +\\[avy-kill-whole-line] kill three lines backward including the +selected line. + +\(fn ARG)" t nil) + +(autoload 'avy-kill-ring-save-whole-line "avy" "\ +Select line and save the whole selected line as if killed, but don’t kill it. + +This command is similar to `avy-kill-whole-line', except that it +saves the line(s) as if killed, but does not kill it(them). + +With a numerical prefix ARG, kill ARG line(s) starting from the +selected line. If ARG is negative, kill backward. + +If ARG is zero, kill the selected line but exclude the trailing +newline. + +\(fn ARG)" t nil) + +(autoload 'avy-setup-default "avy" "\ +Setup the default shortcuts. + +\(fn)" nil nil) + +(autoload 'avy-goto-char-timer "avy" "\ +Read one or many consecutive chars and jump to the first one. +The window scope is determined by `avy-all-windows' (ARG negates it). + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "avy" '("avy-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; avy-autoloads.el ends here diff --git a/elpa/avy-20200311.1106/avy-pkg.el b/elpa/avy-20200311.1106/avy-pkg.el new file mode 100644 index 00000000..441d8fe8 --- /dev/null +++ b/elpa/avy-20200311.1106/avy-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "avy" "20200311.1106" "Jump to arbitrary positions in visible text and select text quickly." '((emacs "24.1") (cl-lib "0.5")) :commit "3bf83140fad4c28f2dc4c7107b9d8fef84d17cb9" :keywords '("point" "location") :authors '(("Oleh Krehel" . "ohwoeowho@gmail.com")) :maintainer '("Oleh Krehel" . "ohwoeowho@gmail.com") :url "https://github.com/abo-abo/avy") diff --git a/elpa/avy-20200311.1106/avy.el b/elpa/avy-20200311.1106/avy.el new file mode 100644 index 00000000..75c61874 --- /dev/null +++ b/elpa/avy-20200311.1106/avy.el @@ -0,0 +1,2197 @@ +;;; avy.el --- Jump to arbitrary positions in visible text and select text quickly. -*- lexical-binding: t -*- + +;; Copyright (C) 2015-2019 Free Software Foundation, Inc. + +;; Author: Oleh Krehel +;; URL: https://github.com/abo-abo/avy +;; Package-Version: 20200311.1106 +;; Version: 0.5.0 +;; Package-Requires: ((emacs "24.1") (cl-lib "0.5")) +;; Keywords: point, location + +;; This file is part of GNU Emacs. + +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; For a full copy of the GNU General Public License +;; see . + +;;; Commentary: +;; +;; With Avy, you can move point to any position in Emacs – even in a +;; different window – using very few keystrokes. For this, you look at +;; the position where you want point to be, invoke Avy, and then enter +;; the sequence of characters displayed at that position. +;; +;; If the position you want to jump to can be determined after only +;; issuing a single keystroke, point is moved to the desired position +;; immediately after that keystroke. In case this isn't possible, the +;; sequence of keystrokes you need to enter is comprised of more than +;; one character. Avy uses a decision tree where each candidate position +;; is a leaf and each edge is described by a character which is distinct +;; per level of the tree. By entering those characters, you navigate the +;; tree, quickly arriving at the desired candidate position, such that +;; Avy can move point to it. +;; +;; Note that this only makes sense for positions you are able to see +;; when invoking Avy. These kinds of positions are supported: +;; +;; * character positions +;; * word or subword start positions +;; * line beginning positions +;; * link positions +;; * window positions +;; +;; If you're familiar with the popular `ace-jump-mode' package, this +;; package does all that and more, without the implementation +;; headache. + +;;; Code: +(require 'cl-lib) +(require 'ring) + +;;* Customization +(defgroup avy nil + "Jump to things tree-style." + :group 'convenience + :prefix "avy-") + +(defcustom avy-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l) + "Default keys for jumping. +Any key is either a character representing a self-inserting +key (letters, digits, punctuation, etc.) or a symbol denoting a +non-printing key like an arrow key (left, right, up, down). For +non-printing keys, a corresponding entry in +`avy-key-to-char-alist' must exist in order to visualize the key +in the avy overlays. + +If `avy-style' is set to words, make sure there are at least three +keys different than the following: a, e, i, o, u, y" + :type '(repeat :tag "Keys" (choice + (character :tag "char") + (symbol :tag "non-printing key")))) + +(defconst avy--key-type + '(choice :tag "Command" + (const avy-goto-char) + (const avy-goto-char-2) + (const avy-isearch) + (const avy-goto-line) + (const avy-goto-subword-0) + (const avy-goto-subword-1) + (const avy-goto-word-0) + (const avy-goto-word-1) + (const avy-copy-line) + (const avy-copy-region) + (const avy-move-line) + (const avy-move-region) + (const avy-kill-whole-line) + (const avy-kill-region) + (const avy-kill-ring-save-whole-line) + (const avy-kill-ring-save-region) + (function :tag "Other command"))) + +(defcustom avy-keys-alist nil + "Alist of avy-jump commands to `avy-keys' overriding the default `avy-keys'." + :type `(alist + :key-type ,avy--key-type + :value-type (repeat :tag "Keys" character))) + +(defcustom avy-orders-alist '((avy-goto-char . avy-order-closest)) + "Alist of candidate ordering functions. +Usually, candidates appear in their point position order." + :type `(alist + :key-type ,avy--key-type + :value-type function)) + +(defcustom avy-words + '("am" "by" "if" "is" "it" "my" "ox" "up" + "ace" "act" "add" "age" "ago" "aim" "air" "ale" "all" "and" "ant" "any" + "ape" "apt" "arc" "are" "arm" "art" "ash" "ate" "awe" "axe" "bad" "bag" + "ban" "bar" "bat" "bay" "bed" "bee" "beg" "bet" "bid" "big" "bit" "bob" + "bot" "bow" "box" "boy" "but" "cab" "can" "cap" "car" "cat" "cog" "cop" + "cow" "cry" "cup" "cut" "day" "dew" "did" "die" "dig" "dim" "dip" "dog" + "dot" "dry" "dub" "dug" "dye" "ear" "eat" "eel" "egg" "ego" "elf" "eve" + "eye" "fan" "far" "fat" "fax" "fee" "few" "fin" "fit" "fix" "flu" "fly" + "foe" "fog" "for" "fox" "fry" "fun" "fur" "gag" "gap" "gas" "gel" "gem" + "get" "gig" "gin" "gnu" "god" "got" "gum" "gun" "gut" "guy" "gym" "had" + "hag" "ham" "has" "hat" "her" "hid" "him" "hip" "his" "hit" "hop" "hot" + "how" "hub" "hue" "hug" "hut" "ice" "icy" "imp" "ink" "inn" "ion" "ire" + "ivy" "jab" "jam" "jar" "jaw" "jet" "job" "jog" "joy" "key" "kid" "kit" + "lag" "lap" "lay" "let" "lid" "lie" "lip" "lit" "lob" "log" "lot" "low" + "mad" "man" "map" "mat" "may" "men" "met" "mix" "mob" "mop" "mud" "mug" + "nag" "nap" "new" "nil" "nod" "nor" "not" "now" "nun" "oak" "odd" "off" + "oil" "old" "one" "orb" "ore" "ork" "our" "out" "owl" "own" "pad" "pan" + "par" "pat" "paw" "pay" "pea" "pen" "pet" "pig" "pin" "pit" "pod" "pot" + "pry" "pub" "pun" "put" "rag" "ram" "ran" "rat" "raw" "ray" "red" "rib" + "rim" "rip" "rob" "rod" "rot" "row" "rub" "rug" "rum" "run" "sad" "sat" + "saw" "say" "sea" "see" "sew" "she" "shy" "sin" "sip" "sit" "six" "ski" + "sky" "sly" "sob" "son" "soy" "spy" "sum" "sun" "tab" "tad" "tag" "tan" + "tap" "tar" "tax" "tea" "the" "tie" "tin" "tip" "toe" "ton" "too" "top" + "toy" "try" "tub" "two" "urn" "use" "van" "war" "was" "wax" "way" "web" + "wed" "wet" "who" "why" "wig" "win" "wit" "woe" "won" "wry" "you" "zap" + "zip" "zoo") + "Words to use in case `avy-style' is set to `words'. +Every word should contain at least one vowel i.e. one of the following +characters: a, e, i, o, u, y +They do not have to be sorted but no word should be a prefix of another one." + :type '(repeat string)) + +(defcustom avy-style 'at-full + "The default method of displaying the overlays. +Use `avy-styles-alist' to customize this per-command." + :type '(choice + (const :tag "Pre" pre) + (const :tag "At" at) + (const :tag "At Full" at-full) + (const :tag "Post" post) + (const :tag "De Bruijn" de-bruijn) + (const :tag "Words" words))) + +(defcustom avy-styles-alist nil + "Alist of avy-jump commands to the style for each command. +If the commands isn't on the list, `avy-style' is used." + :type '(alist + :key-type (choice :tag "Command" + (const avy-goto-char) + (const avy-goto-char-2) + (const avy-isearch) + (const avy-goto-line) + (const avy-goto-subword-0) + (const avy-goto-subword-1) + (const avy-goto-word-0) + (const avy-goto-word-1) + (const avy-copy-line) + (const avy-copy-region) + (const avy-move-line) + (const avy-move-region) + (const avy-kill-whole-line) + (const avy-kill-region) + (const avy-kill-ring-save-whole-line) + (const avy-kill-ring-save-region) + (function :tag "Other command")) + :value-type (choice + (const :tag "Pre" pre) + (const :tag "At" at) + (const :tag "At Full" at-full) + (const :tag "Post" post) + (const :tag "De Bruijn" de-bruijn) + (const :tag "Words" words)))) + +(defcustom avy-dispatch-alist + '((?x . avy-action-kill-move) + (?X . avy-action-kill-stay) + (?t . avy-action-teleport) + (?m . avy-action-mark) + (?n . avy-action-copy) + (?y . avy-action-yank) + (?i . avy-action-ispell) + (?z . avy-action-zap-to-char)) + "List of actions for `avy-handler-default'. + +Each item is (KEY . ACTION). When KEY not on `avy-keys' is +pressed during the dispatch, ACTION is set to replace the default +`avy-action-goto' once a candidate is finally selected." + :type + '(alist + :key-type (choice (character :tag "Char")) + :value-type (choice + (const :tag "Mark" avy-action-mark) + (const :tag "Copy" avy-action-copy) + (const :tag "Kill and move point" avy-action-kill-move) + (const :tag "Kill" avy-action-kill-stay)))) + +(defcustom avy-background nil + "When non-nil, a gray background will be added during the selection." + :type 'boolean) + +(defcustom avy-all-windows t + "Determine the list of windows to consider in search of candidates." + :type + '(choice + (const :tag "All Frames" all-frames) + (const :tag "This Frame" t) + (const :tag "This Window" nil))) + +(defcustom avy-case-fold-search t + "Non-nil if searches should ignore case." + :type 'boolean) + +(defcustom avy-word-punc-regexp "[!-/:-@[-`{-~]" + "Regexp of punctuation chars that count as word starts for `avy-goto-word-1. +When nil, punctuation chars will not be matched. + +\"[!-/:-@[-`{-~]\" will match all printable punctuation chars." + :type 'regexp) + +(defcustom avy-goto-word-0-regexp "\\b\\sw" + "Regexp that determines positions for `avy-goto-word-0'." + :type '(choice + (const :tag "Default" "\\b\\sw") + (const :tag "Symbol" "\\_<\\(\\sw\\|\\s_\\)") + (const :tag "Not whitespace" "[^ \r\n\t]+") + (regexp :tag "Regex"))) + +(defcustom avy-ignored-modes '(image-mode doc-view-mode pdf-view-mode) + "List of modes to ignore when searching for candidates. +Typically, these modes don't use the text representation." + :type 'list) + +(defcustom avy-single-candidate-jump t + "In case there is only one candidate jumps directly to it." + :type 'boolean) + +(defcustom avy-del-last-char-by '(?\b ?\d) + "List of event types, i.e. key presses, that delete the last +character read. The default represents `C-h' and `DEL'. See +`event-convert-list'." + :type 'list) + +(defvar avy-ring (make-ring 20) + "Hold the window and point history.") + +(defvar avy-translate-char-function #'identity + "Function to translate user input key into another key. +For example, to make SPC do the same as ?a, use +\(lambda (c) (if (= c 32) ?a c)).") + +(defface avy-lead-face-0 + '((t (:foreground "white" :background "#4f57f9"))) + "Face used for first non-terminating leading chars.") + +(defface avy-lead-face-1 + '((t (:foreground "white" :background "gray"))) + "Face used for matched leading chars.") + +(defface avy-lead-face-2 + '((t (:foreground "white" :background "#f86bf3"))) + "Face used for leading chars.") + +(defface avy-lead-face + '((t (:foreground "white" :background "#e52b50"))) + "Face used for the leading chars.") + +(defface avy-background-face + '((t (:foreground "gray40"))) + "Face for whole window background during selection.") + +(defface avy-goto-char-timer-face + '((t (:inherit highlight))) + "Face for matches during reading chars using `avy-goto-char-timer'.") + +(defconst avy-lead-faces '(avy-lead-face + avy-lead-face-0 + avy-lead-face-2 + avy-lead-face + avy-lead-face-0 + avy-lead-face-2) + "Face sequence for `avy--overlay-at-full'.") + +(defvar avy-key-to-char-alist '((left . ?◀) + (right . ?▶) + (up . ?▲) + (down . ?▼) + (prior . ?△) + (next . ?▽)) + "An alist from non-character keys to printable chars used in avy overlays. +This alist must contain all keys used in `avy-keys' which are not +self-inserting keys and thus aren't read as characters.") + +;;* Internals +;;** Tree +(defmacro avy-multipop (lst n) + "Remove LST's first N elements and return them." + `(if (<= (length ,lst) ,n) + (prog1 ,lst + (setq ,lst nil)) + (prog1 ,lst + (setcdr + (nthcdr (1- ,n) (prog1 ,lst (setq ,lst (nthcdr ,n ,lst)))) + nil)))) + +(defun avy--de-bruijn (keys n) + "De Bruijn sequence for alphabet KEYS and subsequences of length N." + (let* ((k (length keys)) + (a (make-list (* n k) 0)) + sequence) + (cl-labels ((db (T p) + (if (> T n) + (if (eq (% n p) 0) + (setq sequence + (append sequence + (cl-subseq a 1 (1+ p))))) + (setf (nth T a) (nth (- T p) a)) + (db (1+ T) p) + (cl-loop for j from (1+ (nth (- T p) a)) to (1- k) do + (setf (nth T a) j) + (db (1+ T) T))))) + (db 1 1) + (mapcar (lambda (n) + (nth n keys)) + sequence)))) + +(defun avy--path-alist-1 (lst seq-len keys) + "Build a De Bruin sequence from LST. +SEQ-LEN is how many elements of KEYS it takes to identify a match." + (let ((db-seq (avy--de-bruijn keys seq-len)) + prev-pos prev-seq prev-win path-alist) + ;; The De Bruijn seq is cyclic, so append the seq-len - 1 first chars to + ;; the end. + (setq db-seq (nconc db-seq (cl-subseq db-seq 0 (1- seq-len)))) + (cl-labels ((subseq-and-pop () + (when (nth (1- seq-len) db-seq) + (prog1 (cl-subseq db-seq 0 seq-len) + (pop db-seq))))) + (while lst + (let* ((cur (car lst)) + (pos (cond + ;; ace-window has matches of the form (pos . wnd) + ((integerp (car cur)) (car cur)) + ;; avy-jump have form ((start . end) . wnd) + ((consp (car cur)) (caar cur)) + (t (error "Unexpected match representation: %s" cur)))) + (win (cdr cur)) + (path (if prev-pos + (let ((diff (if (eq win prev-win) + (- pos prev-pos) + 0))) + (when (and (> diff 0) (< diff seq-len)) + (while (and (nth (1- seq-len) db-seq) + (not + (eq 0 + (cl-search + (cl-subseq prev-seq diff) + (cl-subseq db-seq 0 seq-len))))) + (pop db-seq))) + (subseq-and-pop)) + (subseq-and-pop)))) + (if (not path) + (setq lst nil + path-alist nil) + (push (cons path (car lst)) path-alist) + (setq prev-pos pos + prev-seq path + prev-win win + lst (cdr lst)))))) + (nreverse path-alist))) + +(defun avy-order-closest (x) + (abs (- (caar x) (point)))) + +(defvar avy-command nil + "Store the current command symbol. +E.g. 'avy-goto-line or 'avy-goto-char.") + +(defun avy-tree (lst keys) + "Coerce LST into a balanced tree. +The degree of the tree is the length of KEYS. +KEYS are placed appropriately on internal nodes." + (let* ((len (length keys)) + (order-fn (cdr (assq avy-command avy-orders-alist))) + (lst (if order-fn + (cl-sort lst #'< :key order-fn) + lst))) + (cl-labels + ((rd (ls) + (let ((ln (length ls))) + (if (< ln len) + (cl-pairlis keys + (mapcar (lambda (x) (cons 'leaf x)) ls)) + (let ((ks (copy-sequence keys)) + res) + (dolist (s (avy-subdiv ln len)) + (push (cons (pop ks) + (if (eq s 1) + (cons 'leaf (pop ls)) + (rd (avy-multipop ls s)))) + res)) + (nreverse res)))))) + (rd lst)))) + +(defun avy-subdiv (n b) + "Distribute N in B terms in a balanced way." + (let* ((p (1- (floor (+ (log n b) 1e-6)))) + (x1 (expt b p)) + (x2 (* b x1)) + (delta (- n x2)) + (n2 (/ delta (- x2 x1))) + (n1 (- b n2 1))) + (append + (make-list n1 x1) + (list + (- n (* n1 x1) (* n2 x2))) + (make-list n2 x2)))) + +(defun avy-traverse (tree walker &optional recur-key) + "Traverse TREE generated by `avy-tree'. +WALKER is a function that takes KEYS and LEAF. + +RECUR-KEY is used in recursion. + +LEAF is a member of LST argument of `avy-tree'. + +KEYS is the path from the root of `avy-tree' to LEAF." + (dolist (br tree) + (let ((key (cons (car br) recur-key))) + (if (eq (cadr br) 'leaf) + (funcall walker key (cddr br)) + (avy-traverse (cdr br) walker key))))) + +(defvar avy-action nil + "Function to call at the end of select.") + +(defun avy-handler-default (char) + "The default handler for a bad CHAR." + (let (dispatch) + (cond ((setq dispatch (assoc char avy-dispatch-alist)) + (unless (eq avy-style 'words) + (setq avy-action (cdr dispatch))) + (throw 'done 'restart)) + ((memq char '(?\e ?\C-g)) + ;; exit silently + (throw 'done 'abort)) + ((eq char ??) + (avy-show-dispatch-help) + (throw 'done 'restart)) + ((mouse-event-p char) + (signal 'user-error (list "Mouse event not handled" char))) + (t + (message "No such candidate: %s, hit `C-g' to quit." + (if (characterp char) (string char) char)))))) + +(defun avy-show-dispatch-help () + "Display action shortucts in echo area." + (let ((len (length "avy-action-"))) + (message "%s" (mapconcat + (lambda (x) + (format "%s: %s" + (propertize + (char-to-string (car x)) + 'face 'aw-key-face) + (substring (symbol-name (cdr x)) len))) + avy-dispatch-alist + " ")))) + +(defvar avy-handler-function 'avy-handler-default + "A function to call for a bad `read-key' in `avy-read'.") + +(defvar avy-current-path "" + "Store the current incomplete path during `avy-read'.") + +(defun avy-mouse-event-window (char) + "If CHAR is a mouse event, return the window of the event if any or the selected window. +Return nil if not a mouse event." + (when (mouse-event-p char) + (cond ((windowp (posn-window (event-start char))) + (posn-window (event-start char))) + ((framep (posn-window (event-start char))) + (frame-selected-window (posn-window (event-start char)))) + (t (selected-window))))) + +(defun avy-read (tree display-fn cleanup-fn) + "Select a leaf from TREE using consecutive `read-key'. + +DISPLAY-FN should take CHAR and LEAF and signify that LEAFs +associated with CHAR will be selected if CHAR is pressed. This is +commonly done by adding a CHAR overlay at LEAF position. + +CLEANUP-FN should take no arguments and remove the effects of +multiple DISPLAY-FN invocations." + (catch 'done + (setq avy-current-path "") + (while tree + (let ((avy--leafs nil)) + (avy-traverse tree + (lambda (path leaf) + (push (cons path leaf) avy--leafs))) + (dolist (x avy--leafs) + (funcall display-fn (car x) (cdr x)))) + (let ((char (funcall avy-translate-char-function (read-key))) + window + branch) + (funcall cleanup-fn) + (if (setq window (avy-mouse-event-window char)) + (throw 'done (cons char window)) + (if (setq branch (assoc char tree)) + (progn + ;; Ensure avy-current-path stores the full path prior to + ;; exit so other packages can utilize its value. + (setq avy-current-path + (concat avy-current-path (string (avy--key-to-char char)))) + (if (eq (car (setq tree (cdr branch))) 'leaf) + (throw 'done (cdr tree)))) + (funcall avy-handler-function char))))))) + +(defun avy-read-de-bruijn (lst keys) + "Select from LST dispatching on KEYS." + ;; In theory, the De Bruijn sequence B(k,n) has k^n subsequences of length n + ;; (the path length) usable as paths, thus that's the lower bound. Due to + ;; partially overlapping matches, not all subsequences may be usable, so it's + ;; possible that the path-len must be incremented, e.g., if we're matching + ;; for x and a buffer contains xaxbxcx only every second subsequence is + ;; usable for the four matches. + (catch 'done + (let* ((path-len (ceiling (log (length lst) (length keys)))) + (alist (avy--path-alist-1 lst path-len keys))) + (while (not alist) + (cl-incf path-len) + (setq alist (avy--path-alist-1 lst path-len keys))) + (let* ((len (length (caar alist))) + (i 0)) + (setq avy-current-path "") + (while (< i len) + (dolist (x (reverse alist)) + (avy--overlay-at-full (reverse (car x)) (cdr x))) + (let ((char (funcall avy-translate-char-function (read-key)))) + (avy--remove-leading-chars) + (setq alist + (delq nil + (mapcar (lambda (x) + (when (eq (caar x) char) + (cons (cdr (car x)) (cdr x)))) + alist))) + (setq avy-current-path + (concat avy-current-path (string (avy--key-to-char char)))) + (cl-incf i) + (unless alist + (funcall avy-handler-function char)))) + (cdar alist))))) + +(defun avy-read-words (lst words) + "Select from LST using WORDS." + (catch 'done + (let ((num-words (length words)) + (num-entries (length lst)) + alist) + ;; If there are not enough words to cover all the candidates, + ;; we use a De Bruijn sequence to generate the remaining ones. + (when (< num-words num-entries) + (let ((keys avy-keys) + (bad-keys '(?a ?e ?i ?o ?u ?y)) + (path-len 1) + (num-remaining (- num-entries num-words)) + tmp-alist) + ;; Delete all keys which could lead to duplicates. + ;; We want at least three keys left to work with. + (dolist (x bad-keys) + (when (memq x keys) + (setq keys (delq ?a keys)))) + (when (< (length keys) 3) + (signal 'user-error + '("Please add more keys to the variable `avy-keys'."))) + ;; Generate the sequence and add the keys to the existing words. + (while (not tmp-alist) + (cl-incf path-len) + (setq tmp-alist (avy--path-alist-1 lst path-len keys))) + (while (>= (cl-decf num-remaining) 0) + (push (mapconcat 'string (caar tmp-alist) nil) (cdr (last words))) + (setq tmp-alist (cdr tmp-alist))))) + (dolist (x lst) + (push (cons (string-to-list (pop words)) x) alist)) + (setq avy-current-path "") + (while (or (> (length alist) 1) + (caar alist)) + (dolist (x (reverse alist)) + (avy--overlay-at-full (reverse (car x)) (cdr x))) + (let ((char (funcall avy-translate-char-function (read-key)))) + (avy--remove-leading-chars) + (setq alist + (delq nil + (mapcar (lambda (x) + (when (eq (caar x) char) + (cons (cdr (car x)) (cdr x)))) + alist))) + (setq avy-current-path + (concat avy-current-path (string (avy--key-to-char char)))) + (unless alist + (funcall avy-handler-function char)))) + (cdar alist)))) + +;;** Rest +(defun avy-window-list () + "Return a list of windows depending on `avy-all-windows'." + (cond ((eq avy-all-windows 'all-frames) + (cl-mapcan #'window-list (frame-list))) + + ((eq avy-all-windows t) + (window-list)) + + ((null avy-all-windows) + (list (selected-window))) + + (t + (error "Unrecognized option: %S" avy-all-windows)))) + +(defcustom avy-all-windows-alt nil + "The alternative `avy-all-windows' for use with \\[universal-argument]." + :type '(choice + (const :tag "Current window" nil) + (const :tag "All windows on the current frame" t) + (const :tag "All windows on all frames" all-frames))) + +(defmacro avy-dowindows (flip &rest body) + "Depending on FLIP and `avy-all-windows' run BODY in each or selected window." + (declare (indent 1) + (debug (form body))) + `(let ((avy-all-windows (if ,flip + avy-all-windows-alt + avy-all-windows))) + (dolist (wnd (avy-window-list)) + (with-selected-window wnd + (unless (memq major-mode avy-ignored-modes) + ,@body))))) + +(defun avy-resume () + "Stub to hold last avy command. +Commands using `avy-with' macro can be resumed." + (interactive)) + +(defmacro avy-with (command &rest body) + "Set `avy-keys' according to COMMAND and execute BODY. +Set `avy-style' according to COMMAND as well." + (declare (indent 1) + (debug (form body))) + `(let ((avy-keys (or (cdr (assq ',command avy-keys-alist)) + avy-keys)) + (avy-style (or (cdr (assq ',command avy-styles-alist)) + avy-style)) + (avy-command ',command)) + (setq avy-action nil) + (setf (symbol-function 'avy-resume) + (lambda () + (interactive) + ,@(if (eq command 'avy-goto-char-timer) + (cdr body) + body))) + ,@body)) + +(defun avy-action-goto (pt) + "Goto PT." + (let ((frame (window-frame (selected-window)))) + (unless (equal frame (selected-frame)) + (select-frame-set-input-focus frame) + (raise-frame frame)) + (goto-char pt))) + +(defun avy-forward-item () + (if (eq avy-command 'avy-goto-line) + (end-of-line) + (forward-sexp)) + (point)) + +(defun avy-action-mark (pt) + "Mark sexp at PT." + (goto-char pt) + (set-mark (point)) + (avy-forward-item)) + +(defun avy-action-copy (pt) + "Copy sexp starting on PT." + (save-excursion + (let (str) + (goto-char pt) + (avy-forward-item) + (setq str (buffer-substring pt (point))) + (kill-new str) + (message "Copied: %s" str))) + (let ((dat (ring-ref avy-ring 0))) + (select-frame-set-input-focus + (window-frame (cdr dat))) + (select-window (cdr dat)) + (goto-char (car dat)))) + +(defun avy-action-yank (pt) + "Yank sexp starting at PT at the current point." + (avy-action-copy pt) + (yank) + t) + +(defun avy-action-kill-move (pt) + "Kill sexp at PT and move there." + (goto-char pt) + (avy-forward-item) + (kill-region pt (point)) + (message "Killed: %s" (current-kill 0)) + (point)) + +(defun avy-action-kill-stay (pt) + "Kill sexp at PT." + (save-excursion + (goto-char pt) + (avy-forward-item) + (kill-region pt (point)) + (just-one-space)) + (message "Killed: %s" (current-kill 0)) + (select-window + (cdr + (ring-ref avy-ring 0))) + t) + +(defun avy-action-zap-to-char (pt) + "Kill from point up to PT." + (if (> pt (point)) + (kill-region (point) pt) + (kill-region pt (point)))) + +(defun avy-action-teleport (pt) + "Kill sexp starting on PT and yank into the current location." + (avy-action-kill-stay pt) + (select-window + (cdr + (ring-ref avy-ring 0))) + (save-excursion + (yank)) + t) + +(declare-function flyspell-correct-word-before-point "flyspell") + +(defcustom avy-flyspell-correct-function #'flyspell-correct-word-before-point + "Function called to correct word by `avy-action-ispell' when +`flyspell-mode' is enabled." + :type 'function) + +(defun avy-action-ispell (pt) + "Auto correct word at PT." + (save-excursion + (goto-char pt) + (cond + ((eq avy-command 'avy-goto-line) + (ispell-region + (line-beginning-position) + (line-end-position))) + ((bound-and-true-p flyspell-mode) + (funcall avy-flyspell-correct-function)) + ((looking-at-p "\\b") + (ispell-word)) + (t + (progn + (backward-word) + (when (looking-at-p "\\b") + (ispell-word))))))) + +(defvar avy-pre-action #'avy-pre-action-default + "Function to call before `avy-action' is called.") + +(defun avy-pre-action-default (res) + (avy-push-mark) + (when (and (consp res) + (windowp (cdr res))) + (let* ((window (cdr res)) + (frame (window-frame window))) + (unless (equal frame (selected-frame)) + (select-frame-set-input-focus frame)) + (select-window window)))) + +(defun avy--process-1 (candidates overlay-fn &optional cleanup-fn) + (let ((len (length candidates))) + (cond ((= len 0) + nil) + ((and (= len 1) avy-single-candidate-jump) + (car candidates)) + (t + (unwind-protect + (progn + (avy--make-backgrounds + (avy-window-list)) + (cond ((eq avy-style 'de-bruijn) + (avy-read-de-bruijn + candidates avy-keys)) + ((eq avy-style 'words) + (avy-read-words + candidates avy-words)) + (t + (avy-read (avy-tree candidates avy-keys) + overlay-fn + (or cleanup-fn #'avy--remove-leading-chars))))) + (avy--done)))))) + +(defvar avy-last-candidates nil + "Store the last candidate list.") + +(defun avy--last-candidates-cycle (advancer) + (let* ((avy-last-candidates + (cl-remove-if-not + (lambda (x) (equal (cdr x) (selected-window))) + avy-last-candidates)) + (min-dist + (apply #'min + (mapcar (lambda (x) (abs (- (caar x) (point)))) avy-last-candidates))) + (pos + (cl-position-if + (lambda (x) + (= (- (caar x) (point)) min-dist)) + avy-last-candidates))) + (funcall advancer pos avy-last-candidates))) + +(defun avy-prev () + "Go to the previous candidate of the last `avy-read'." + (interactive) + (avy--last-candidates-cycle + (lambda (pos lst) + (when (> pos 0) + (goto-char (caar (nth (1- pos) lst))))))) + +(defun avy-next () + "Go to the next candidate of the last `avy-read'." + (interactive) + (avy--last-candidates-cycle + (lambda (pos lst) + (when (< pos (1- (length lst))) + (goto-char (caar (nth (1+ pos) lst))))))) + +(defun avy-process (candidates &optional overlay-fn cleanup-fn) + "Select one of CANDIDATES using `avy-read'. +Use OVERLAY-FN to visualize the decision overlay. +CLEANUP-FN should take no arguments and remove the effects of +multiple OVERLAY-FN invocations." + (setq overlay-fn (or overlay-fn (avy--style-fn avy-style))) + (setq cleanup-fn (or cleanup-fn #'avy--remove-leading-chars)) + (unless (and (consp (car candidates)) + (windowp (cdar candidates))) + (setq candidates + (mapcar (lambda (x) (cons x (selected-window))) + candidates))) + (setq avy-last-candidates (copy-sequence candidates)) + (let ((original-cands (copy-sequence candidates)) + (res (avy--process-1 candidates overlay-fn cleanup-fn))) + (cond + ((null res) + (if (and (eq avy-style 'words) candidates) + (avy-process original-cands overlay-fn cleanup-fn) + (message "zero candidates") + t)) + ((eq res 'restart) + (avy-process original-cands overlay-fn cleanup-fn)) + ;; ignore exit from `avy-handler-function' + ((eq res 'exit)) + ((eq res 'abort) + nil) + (t + (funcall avy-pre-action res) + (setq res (car res)) + (funcall (or avy-action 'avy-action-goto) + (if (consp res) + (car res) + res)) + res)))) + +(define-obsolete-function-alias 'avy--process 'avy-process + "0.4.0") + +(defvar avy--overlays-back nil + "Hold overlays for when `avy-background' is t.") + +(defun avy--make-backgrounds (wnd-list) + "Create a dim background overlay for each window on WND-LIST." + (when avy-background + (setq avy--overlays-back + (mapcar (lambda (w) + (let ((ol (make-overlay + (window-start w) + (window-end w) + (window-buffer w)))) + (overlay-put ol 'face 'avy-background-face) + (overlay-put ol 'window w) + ol)) + wnd-list)))) + +(defun avy--done () + "Clean up overlays." + (mapc #'delete-overlay avy--overlays-back) + (setq avy--overlays-back nil) + (avy--remove-leading-chars)) + +(defun avy--visible-p (s) + (let ((invisible (get-char-property s 'invisible))) + (or (null invisible) + (eq t buffer-invisibility-spec) + (null (assoc invisible buffer-invisibility-spec))))) + +(defun avy--next-visible-point () + "Return the next closest point without 'invisible property." + (let ((s (point))) + (while (and (not (= (point-max) (setq s (next-char-property-change s)))) + (not (avy--visible-p s)))) + s)) + +(defun avy--next-invisible-point () + "Return the next closest point with 'invisible property." + (let ((s (point))) + (while (and (not (= (point-max) (setq s (next-char-property-change s)))) + (avy--visible-p s))) + s)) + +(defun avy--find-visible-regions (rbeg rend) + "Return a list of all visible regions between RBEG and REND." + (setq rbeg (max rbeg (point-min))) + (setq rend (min rend (point-max))) + (when (< rbeg rend) + (let (visibles beg) + (save-excursion + (save-restriction + (narrow-to-region rbeg rend) + (setq beg (goto-char (point-min))) + (while (not (= (point) (point-max))) + (goto-char (avy--next-invisible-point)) + (push (cons beg (point)) visibles) + (setq beg (goto-char (avy--next-visible-point)))) + (nreverse visibles)))))) + +(defun avy--regex-candidates (regex &optional beg end pred group) + "Return all elements that match REGEX. +Each element of the list is ((BEG . END) . WND) +When PRED is non-nil, it's a filter for matching point positions. +When GROUP is non-nil, (BEG . END) should delimit that regex group." + (setq group (or group 0)) + (let ((case-fold-search (or avy-case-fold-search + (string= regex (downcase regex)))) + candidates) + (avy-dowindows current-prefix-arg + (dolist (pair (avy--find-visible-regions + (or beg (window-start)) + (or end (window-end (selected-window) t)))) + (save-excursion + (goto-char (car pair)) + (while (re-search-forward regex (cdr pair) t) + (when (avy--visible-p (1- (point))) + (when (or (null pred) + (funcall pred)) + (push (cons + (if (numberp group) + (cons (match-beginning group) + (match-end group)) + (funcall group)) + wnd) candidates))))))) + (nreverse candidates))) + +(defvar avy--overlay-offset 0 + "The offset to apply in `avy--overlay'.") + +(defvar avy--overlays-lead nil + "Hold overlays for leading chars.") + +(defun avy--remove-leading-chars () + "Remove leading char overlays." + (mapc #'delete-overlay avy--overlays-lead) + (setq avy--overlays-lead nil)) + +(defun avy--old-str (pt wnd) + "Return a one-char string at PT in WND." + (let ((old-str (with-selected-window wnd + (buffer-substring pt (1+ pt))))) + (if avy-background + (propertize old-str 'face 'avy-background-face) + old-str))) + +(defun avy--overlay (str beg end wnd &optional compose-fn) + "Create an overlay with STR from BEG to END in WND. +COMPOSE-FN is a lambda that concatenates the old string at BEG with STR." + (let ((eob (with-selected-window wnd (point-max)))) + (when (<= beg eob) + (let* ((beg (+ beg avy--overlay-offset)) + (ol (make-overlay beg (or end (1+ beg)) (window-buffer wnd))) + (old-str (if (eq beg eob) "" (avy--old-str beg wnd))) + (os-line-prefix (get-text-property 0 'line-prefix old-str)) + (os-wrap-prefix (get-text-property 0 'wrap-prefix old-str)) + other-ol) + (when os-line-prefix + (add-text-properties 0 1 `(line-prefix ,os-line-prefix) str)) + (when os-wrap-prefix + (add-text-properties 0 1 `(wrap-prefix ,os-wrap-prefix) str)) + (when (setq other-ol (cl-find-if + (lambda (o) (overlay-get o 'goto-address)) + (overlays-at beg))) + (add-text-properties + 0 (length old-str) + `(face ,(overlay-get other-ol 'face)) old-str)) + (overlay-put ol 'window wnd) + (overlay-put ol 'category 'avy) + (overlay-put ol (if (eq beg eob) + 'after-string + 'display) + (funcall + (or compose-fn #'concat) + str old-str)) + (push ol avy--overlays-lead))))) + +(defcustom avy-highlight-first nil + "When non-nil highlight the first decision char with `avy-lead-face-0'. +Do this even when the char is terminating." + :type 'boolean) + +(defun avy--key-to-char (c) + "If C is no character, translate it using `avy-key-to-char-alist'." + (cond ((characterp c) c) + ((cdr (assoc c avy-key-to-char-alist))) + ((mouse-event-p c) c) + (t + (error "Unknown key %s" c)))) + +(defun avy-candidate-beg (leaf) + "Return the start position for LEAF." + (cond ((numberp leaf) + leaf) + ((consp (car leaf)) + (caar leaf)) + (t + (car leaf)))) + +(defun avy-candidate-end (leaf) + "Return the end position for LEAF." + (cond ((numberp leaf) + leaf) + ((consp (car leaf)) + (cdar leaf)) + (t + (car leaf)))) + +(defun avy-candidate-wnd (leaf) + "Return the window for LEAF." + (if (consp leaf) + (cdr leaf) + (selected-window))) + +(defun avy--overlay-pre (path leaf) + "Create an overlay with PATH at LEAF. +PATH is a list of keys from tree root to LEAF. +LEAF is normally ((BEG . END) . WND)." + (let* ((path (mapcar #'avy--key-to-char path)) + (str (propertize (apply #'string (reverse path)) + 'face 'avy-lead-face))) + (when (or avy-highlight-first (> (length str) 1)) + (set-text-properties 0 1 '(face avy-lead-face-0) str)) + (setq str (concat + (propertize avy-current-path + 'face 'avy-lead-face-1) + str)) + (avy--overlay + str + (avy-candidate-beg leaf) nil + (avy-candidate-wnd leaf)))) + +(defun avy--overlay-at (path leaf) + "Create an overlay with PATH at LEAF. +PATH is a list of keys from tree root to LEAF. +LEAF is normally ((BEG . END) . WND)." + (let* ((path (mapcar #'avy--key-to-char path)) + (str (propertize + (string (car (last path))) + 'face 'avy-lead-face))) + (avy--overlay + str + (avy-candidate-beg leaf) nil + (avy-candidate-wnd leaf) + (lambda (str old-str) + (cond ((string= old-str "\n") + (concat str "\n")) + ;; add padding for wide-width character + ((eq (string-width old-str) 2) + (concat str " ")) + (t + str)))))) + +(defun avy--overlay-at-full (path leaf) + "Create an overlay with PATH at LEAF. +PATH is a list of keys from tree root to LEAF. +LEAF is normally ((BEG . END) . WND)." + (let* ((path (mapcar #'avy--key-to-char path)) + (str (propertize + (apply #'string (reverse path)) + 'face 'avy-lead-face)) + (len (length path)) + (beg (avy-candidate-beg leaf)) + (wnd (cdr leaf)) + end) + (dotimes (i len) + (set-text-properties i (1+ i) + `(face ,(nth i avy-lead-faces)) + str)) + (when (eq avy-style 'de-bruijn) + (setq str (concat + (propertize avy-current-path + 'face 'avy-lead-face-1) + str)) + (setq len (length str))) + (with-selected-window wnd + (save-excursion + (goto-char beg) + (let* ((lep (if (bound-and-true-p visual-line-mode) + (save-excursion + (end-of-visual-line) + (point)) + (line-end-position))) + ;; `end-of-visual-line' is bugged sometimes + (lep (if (< lep beg) + (line-end-position) + lep)) + (len-and-str (avy--update-offset-and-str len str lep))) + (setq len (car len-and-str)) + (setq str (cdr len-and-str)) + (setq end (if (= beg lep) + (1+ beg) + (min (+ beg + (if (eq (char-after) ?\t) + 1 + len)) + lep))) + (when (and (bound-and-true-p visual-line-mode) + (> len (- end beg)) + (not (eq lep beg))) + (setq len (- end beg)) + (let ((old-str (apply #'string (reverse path)))) + (setq str + (substring + (propertize + old-str + 'face + (if (= (length old-str) 1) + 'avy-lead-face + 'avy-lead-face-0)) + 0 len))))))) + (avy--overlay + str beg end wnd + (lambda (str old-str) + (cond ((string= old-str "\n") + (concat str "\n")) + ((string= old-str "\t") + (concat str (make-string (max (- tab-width len) 0) ?\ ))) + (t + ;; add padding for wide-width character + (if (eq (string-width old-str) 2) + (concat str " ") + str))))))) + +(defun avy--overlay-post (path leaf) + "Create an overlay with PATH at LEAF. +PATH is a list of keys from tree root to LEAF. +LEAF is normally ((BEG . END) . WND)." + (let* ((path (mapcar #'avy--key-to-char path)) + (str (propertize (apply #'string (reverse path)) + 'face 'avy-lead-face))) + (when (or avy-highlight-first (> (length str) 1)) + (set-text-properties 0 1 '(face avy-lead-face-0) str)) + (setq str (concat + (propertize avy-current-path + 'face 'avy-lead-face-1) + str)) + (avy--overlay + str + (avy-candidate-end leaf) nil + (avy-candidate-wnd leaf)))) + +(defun avy--update-offset-and-str (offset str lep) + "Recalculate the length of the new overlay at point. + +OFFSET is the previous overlay length. +STR is the overlay string that we wish to add. +LEP is the line end position. + +We want to add an overlay between point and END=point+OFFSET. +When other overlays already exist between point and END, set +OFFSET to be the difference between the start of the first +overlay and point. This is equivalent to truncating our new +overlay, so that it doesn't intersect with overlays that already +exist." + (let* ((wnd (selected-window)) + (beg (point)) + (oov (delq nil + (mapcar + (lambda (o) + (and (eq (overlay-get o 'category) 'avy) + (eq (overlay-get o 'window) wnd) + (overlay-start o))) + (overlays-in beg (min (+ beg offset) lep)))))) + (when oov + (setq offset (- (apply #'min oov) beg)) + (setq str (substring str 0 offset))) + (let ((other-ov (cl-find-if + (lambda (o) + (and (eq (overlay-get o 'category) 'avy) + (eq (overlay-start o) beg) + (not (eq (overlay-get o 'window) wnd)))) + (overlays-in (point) (min (+ (point) offset) lep))))) + (when (and other-ov + (> (overlay-end other-ov) + (+ beg offset))) + (setq str (concat str (buffer-substring + (+ beg offset) + (overlay-end other-ov)))) + (setq offset (- (overlay-end other-ov) + beg)))) + (cons offset str))) + +(defun avy--style-fn (style) + "Transform STYLE symbol to a style function." + (cl-case style + (pre #'avy--overlay-pre) + (at #'avy--overlay-at) + (at-full 'avy--overlay-at-full) + (post #'avy--overlay-post) + (de-bruijn #'avy--overlay-at-full) + (words #'avy--overlay-at-full) + (ignore #'ignore) + (t (error "Unexpected style %S" style)))) + +(cl-defun avy-jump (regex &key window-flip beg end action pred group) + "Jump to REGEX. +The window scope is determined by `avy-all-windows'. +When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. +ACTION is a function that takes point position as an argument. +When PRED is non-nil, it's a filter for matching point positions. +When GROUP is non-nil, it's either a match group in REGEX, or a function +that returns a cons of match beginning and end." + (setq avy-action (or action avy-action)) + (let ((avy-all-windows + (if window-flip + (not avy-all-windows) + avy-all-windows))) + (avy-process + (avy--regex-candidates regex beg end pred group)))) + +(defun avy--generic-jump (regex window-flip &optional beg end) + "Jump to REGEX. +The window scope is determined by `avy-all-windows'. +When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched." + (declare (obsolete avy-jump "0.4.0")) + (let ((avy-all-windows + (if window-flip + (not avy-all-windows) + avy-all-windows))) + (avy-process + (avy--regex-candidates regex beg end)))) + +;;* Commands +;;;###autoload +(defun avy-goto-char (char &optional arg) + "Jump to the currently visible CHAR. +The window scope is determined by `avy-all-windows' (ARG negates it)." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-char + (avy-jump + (if (= 13 char) + "\n" + (regexp-quote (string char))) + :window-flip arg))) + +;;;###autoload +(defun avy-goto-char-in-line (char) + "Jump to the currently visible CHAR in the current line." + (interactive (list (read-char "char: " t))) + (avy-with avy-goto-char + (avy-jump + (regexp-quote (string char)) + :beg (line-beginning-position) + :end (line-end-position)))) + +;;;###autoload +(defun avy-goto-char-2 (char1 char2 &optional arg beg end) + "Jump to the currently visible CHAR1 followed by CHAR2. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched." + (interactive (list (read-char "char 1: " t) + (read-char "char 2: " t) + current-prefix-arg + nil nil)) + (when (eq char1 ? ) + (setq char1 ?\n)) + (when (eq char2 ? ) + (setq char2 ?\n)) + (avy-with avy-goto-char-2 + (avy-jump + (regexp-quote (string char1 char2)) + :window-flip arg + :beg beg + :end end))) + +;;;###autoload +(defun avy-goto-char-2-above (char1 char2 &optional arg) + "Jump to the currently visible CHAR1 followed by CHAR2. +This is a scoped version of `avy-goto-char-2', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char 1: " t) + (read-char "char 2: " t) + current-prefix-arg)) + (avy-with avy-goto-char-2-above + (avy-goto-char-2 + char1 char2 arg + (window-start) (point)))) + +;;;###autoload +(defun avy-goto-char-2-below (char1 char2 &optional arg) + "Jump to the currently visible CHAR1 followed by CHAR2. +This is a scoped version of `avy-goto-char-2', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char 1: " t) + (read-char "char 2: " t) + current-prefix-arg)) + (avy-with avy-goto-char-2-below + (avy-goto-char-2 + char1 char2 arg + (point) (window-end (selected-window) t)))) + +;;;###autoload +(defun avy-isearch () + "Jump to one of the current isearch candidates." + (interactive) + (avy-with avy-isearch + (let ((avy-background nil) + (avy-case-fold-search case-fold-search)) + (prog1 + (avy-process + (avy--regex-candidates (if isearch-regexp + isearch-string + (regexp-quote isearch-string)))) + (isearch-done))))) + +;;;###autoload +(defun avy-goto-word-0 (arg &optional beg end) + "Jump to a word start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched." + (interactive "P") + (avy-with avy-goto-word-0 + (avy-jump avy-goto-word-0-regexp + :window-flip arg + :beg beg + :end end))) + +;;;###autoload +(defun avy-goto-whitespace-end (arg &optional beg end) + "Jump to the end of a whitespace sequence. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched." + (interactive "P") + (avy-with avy-goto-whitespace-end + (avy-jump "[ \t]+\\|\n[ \t]*" + :window-flip arg + :beg beg + :end end + :group (lambda () (cons (point) (1+ (point))))))) + +(defun avy-goto-word-0-above (arg) + "Jump to a word start between window start and point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive "P") + (avy-with avy-goto-word-0 + (avy-goto-word-0 arg (window-start) (point)))) + +(defun avy-goto-word-0-below (arg) + "Jump to a word start between point and window end. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive "P") + (avy-with avy-goto-word-0 + (avy-goto-word-0 arg (point) (window-end (selected-window) t)))) + +(defun avy-goto-whitespace-end-above (arg) + "Jump to the end of a whitespace sequence between point and window end. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive "P") + (avy-with avy-goto-whitespace-end + (avy-goto-whitespace-end arg (window-start) (point)))) + +(defun avy-goto-whitespace-end-below (arg) + "Jump to the end of a whitespace sequence between window start and point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive "P") + (avy-with avy-goto-whitespace-end + (avy-goto-whitespace-end arg (point) (window-end (selected-window) t)))) + +;;;###autoload +(defun avy-goto-word-1 (char &optional arg beg end symbol) + "Jump to the currently visible CHAR at a word start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. +When SYMBOL is non-nil, jump to symbol start instead of word start." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-word-1 + (let* ((str (string char)) + (regex (cond ((string= str ".") + "\\.") + ((and avy-word-punc-regexp + (string-match avy-word-punc-regexp str)) + (regexp-quote str)) + ((<= char 26) + str) + (t + (concat + (if symbol "\\_<" "\\b") + str))))) + (avy-jump regex + :window-flip arg + :beg beg + :end end)))) + +;;;###autoload +(defun avy-goto-word-1-above (char &optional arg) + "Jump to the currently visible CHAR at a word start. +This is a scoped version of `avy-goto-word-1', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-word-1 + (avy-goto-word-1 char arg (window-start) (point)))) + +;;;###autoload +(defun avy-goto-word-1-below (char &optional arg) + "Jump to the currently visible CHAR at a word start. +This is a scoped version of `avy-goto-word-1', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-word-1 + (avy-goto-word-1 char arg (point) (window-end (selected-window) t)))) + +;;;###autoload +(defun avy-goto-symbol-1 (char &optional arg) + "Jump to the currently visible CHAR at a symbol start. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-symbol-1 + (avy-goto-word-1 char arg nil nil t))) + +;;;###autoload +(defun avy-goto-symbol-1-above (char &optional arg) + "Jump to the currently visible CHAR at a symbol start. +This is a scoped version of `avy-goto-symbol-1', where the scope is +the visible part of the current buffer up to point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-symbol-1-above + (avy-goto-word-1 char arg (window-start) (point) t))) + +;;;###autoload +(defun avy-goto-symbol-1-below (char &optional arg) + "Jump to the currently visible CHAR at a symbol start. +This is a scoped version of `avy-goto-symbol-1', where the scope is +the visible part of the current buffer following point. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-symbol-1-below + (avy-goto-word-1 char arg (point) (window-end (selected-window) t) t))) + +(declare-function subword-backward "subword") +(defvar subword-backward-regexp) + +(defcustom avy-subword-extra-word-chars '(?{ ?= ?} ?* ?: ?> ?<) + "A list of characters that should temporarily match \"\\w\". +This variable is used by `avy-goto-subword-0' and `avy-goto-subword-1'." + :type '(repeat character)) + +;;;###autoload +(defun avy-goto-subword-0 (&optional arg predicate beg end) + "Jump to a word or subword start. +The window scope is determined by `avy-all-windows' (ARG negates it). + +When PREDICATE is non-nil it's a function of zero parameters that +should return true. + +BEG and END narrow the scope where candidates are searched." + (interactive "P") + (require 'subword) + (avy-with avy-goto-subword-0 + (let ((case-fold-search nil) + (subword-backward-regexp + "\\(\\(\\W\\|[[:lower:][:digit:]]\\)\\([!-/:@`~[:upper:]]+\\W*\\)\\|\\W\\w+\\)") + candidates) + (avy-dowindows arg + (let ((syn-tbl (copy-syntax-table))) + (dolist (char avy-subword-extra-word-chars) + (modify-syntax-entry char "w" syn-tbl)) + (with-syntax-table syn-tbl + (let ((ws (or beg (window-start))) + window-cands) + (save-excursion + (goto-char (or end (window-end (selected-window) t))) + (subword-backward) + (while (> (point) ws) + (when (or (null predicate) + (and predicate (funcall predicate))) + (unless (not (avy--visible-p (point))) + (push (cons (cons (point) (1+ (point))) + (selected-window)) window-cands))) + (subword-backward)) + (and (= (point) ws) + (or (null predicate) + (and predicate (funcall predicate))) + (not (get-char-property (point) 'invisible)) + (push (cons (cons (point) (1+ (point))) + (selected-window)) window-cands))) + (setq candidates (nconc candidates window-cands)))))) + (avy-process candidates)))) + +;;;###autoload +(defun avy-goto-subword-1 (char &optional arg) + "Jump to the currently visible CHAR at a subword start. +The window scope is determined by `avy-all-windows' (ARG negates it). +The case of CHAR is ignored." + (interactive (list (read-char "char: " t) + current-prefix-arg)) + (avy-with avy-goto-subword-1 + (let ((char (downcase char))) + (avy-goto-subword-0 + arg (lambda () + (and (char-after) + (eq (downcase (char-after)) char))))))) + +;;;###autoload +(defun avy-goto-word-or-subword-1 () + "Forward to `avy-goto-subword-1' or `avy-goto-word-1'. +Which one depends on variable `subword-mode'." + (interactive) + (if (bound-and-true-p subword-mode) + (call-interactively #'avy-goto-subword-1) + (call-interactively #'avy-goto-word-1))) + +(defvar visual-line-mode) + +(defcustom avy-indent-line-overlay nil + "When non-nil, `avy-goto-line' will display the line overlay next to the first non-whitespace character of each line." + :type 'boolean) + +(defun avy--line-cands (&optional arg beg end bottom-up) + "Get candidates for selecting a line. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. +When BOTTOM-UP is non-nil, display avy candidates from top to bottom" + (let (candidates) + (avy-dowindows arg + (let ((ws (or beg (window-start)))) + (save-excursion + (save-restriction + (narrow-to-region ws (or end (window-end (selected-window) t))) + (goto-char (point-min)) + (while (< (point) (point-max)) + (when (member (get-char-property + (max (1- (point)) ws) 'invisible) '(nil org-link)) + (push (cons + (if (eq avy-style 'post) + (line-end-position) + (save-excursion + (when avy-indent-line-overlay + (skip-chars-forward " \t")) + (point))) + (selected-window)) candidates)) + (if visual-line-mode + (progn + (setq temporary-goal-column 0) + (line-move-visual 1 t)) + (forward-line 1))))))) + (if bottom-up + candidates + (nreverse candidates)))) + +(defun avy--linum-strings () + "Get strings for `avy-linum-mode'." + (let* ((lines (mapcar #'car (avy--line-cands))) + (line-tree (avy-tree lines avy-keys)) + (line-list nil)) + (avy-traverse + line-tree + (lambda (path _leaf) + (let ((str (propertize (apply #'string (reverse path)) + 'face 'avy-lead-face))) + (when (> (length str) 1) + (set-text-properties 0 1 '(face avy-lead-face-0) str)) + (push str line-list)))) + (nreverse line-list))) + +(defvar linum-available) +(defvar linum-overlays) +(defvar linum-format) +(declare-function linum--face-width "linum") + +(define-minor-mode avy-linum-mode + "Minor mode that uses avy hints for `linum-mode'." + :group 'avy + (if avy-linum-mode + (progn + (require 'linum) + (advice-add 'linum-update-window :around 'avy--linum-update-window) + (linum-mode 1)) + (advice-remove 'linum-update-window 'avy--linum-update-window) + (linum-mode -1))) + +(defun avy--linum-update-window (_ win) + "Update line numbers for the portion visible in window WIN." + (goto-char (window-start win)) + (let ((line (line-number-at-pos)) + (limit (window-end win t)) + (fmt (cond ((stringp linum-format) linum-format) + ((eq linum-format 'dynamic) + (let ((w (length (number-to-string + (count-lines (point-min) (point-max)))))) + (concat "%" (number-to-string w) "d"))))) + (width 0) + (avy-strs (when avy-linum-mode + (avy--linum-strings)))) + (run-hooks 'linum-before-numbering-hook) + ;; Create an overlay (or reuse an existing one) for each + ;; line visible in this window, if necessary. + (while (and (not (eobp)) (< (point) limit)) + (let* ((str + (cond (avy-linum-mode + (pop avy-strs)) + (fmt + (propertize (format fmt line) 'face 'linum)) + (t + (funcall linum-format line)))) + (visited (catch 'visited + (dolist (o (overlays-in (point) (point))) + (when (equal-including-properties + (overlay-get o 'linum-str) str) + (unless (memq o linum-overlays) + (push o linum-overlays)) + (setq linum-available (delq o linum-available)) + (throw 'visited t)))))) + (setq width (max width (length str))) + (unless visited + (let ((ov (if (null linum-available) + (make-overlay (point) (point)) + (move-overlay (pop linum-available) (point) (point))))) + (push ov linum-overlays) + (overlay-put ov 'before-string + (propertize " " 'display `((margin left-margin) ,str))) + (overlay-put ov 'linum-str str)))) + ;; Text may contain those nasty intangible properties, but that + ;; shouldn't prevent us from counting those lines. + (let ((inhibit-point-motion-hooks t)) + (forward-line)) + (setq line (1+ line))) + (when (display-graphic-p) + (setq width (ceiling + (/ (* width 1.0 (linum--face-width 'linum)) + (frame-char-width))))) + (set-window-margins win width (cdr (window-margins win))))) + +(defun avy--line (&optional arg beg end bottom-up) + "Select a line. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'. +BEG and END narrow the scope where candidates are searched. +When BOTTOM-UP is non-nil, display avy candidates from top to bottom" + (setq avy-action (or avy-action #'identity)) + (let ((avy-style (if avy-linum-mode + (progn + (message "Goto line:") + 'ignore) + avy-style))) + (avy-process + (avy--line-cands arg beg end bottom-up)))) + +;;;###autoload +(defun avy-goto-line (&optional arg) + "Jump to a line start in current buffer. + +When ARG is 1, jump to lines currently visible, with the option +to cancel to `goto-line' by entering a number. + +When ARG is 4, negate the window scope determined by +`avy-all-windows'. + +Otherwise, forward to `goto-line' with ARG." + (interactive "p") + (setq arg (or arg 1)) + (if (not (memq arg '(1 4))) + (progn + (goto-char (point-min)) + (forward-line (1- arg))) + (avy-with avy-goto-line + (let* ((avy-handler-old avy-handler-function) + (avy-handler-function + (lambda (char) + (if (or (< char ?0) + (> char ?9)) + (funcall avy-handler-old char) + (let ((line (read-from-minibuffer + "Goto line: " (string char)))) + (when line + (avy-push-mark) + (save-restriction + (widen) + (goto-char (point-min)) + (forward-line (1- (string-to-number line)))) + (throw 'done 'exit)))))) + (r (avy--line (eq arg 4)))) + (when (and (not (memq r '(t nil))) (eq avy-action #'identity)) + (avy-action-goto r)))))) + +;;;###autoload +(defun avy-goto-line-above (&optional offset bottom-up) + "Goto visible line above the cursor. +OFFSET changes the distance between the closest key to the cursor and +the cursor +When BOTTOM-UP is non-nil, display avy candidates from top to bottom" + (interactive) + (if offset + (setq offset (+ 2 (- offset)))) + (let* ((avy-all-windows nil) + (r (avy--line nil (window-start) + (line-beginning-position (or offset 1)) + bottom-up))) + (unless (eq r t) + (avy-action-goto r)))) + +;;;###autoload +(defun avy-goto-line-below (&optional offset bottom-up) + "Goto visible line below the cursor. +OFFSET changes the distance between the closest key to the cursor and +the cursor +When BOTTOM-UP is non-nil, display avy candidates from top to bottom" + (interactive) + (if offset + (setq offset (+ offset 1))) + (let* ((avy-all-windows nil) + (r (avy--line + nil (line-beginning-position (or offset 2)) + (window-end (selected-window) t) + bottom-up))) + (unless (eq r t) + (avy-action-goto r)))) + +(defcustom avy-line-insert-style 'above + "How to insert the newly copied/cut line." + :type '(choice + (const :tag "Above" above) + (const :tag "Below" below))) + +;;;###autoload +(defun avy-goto-end-of-line (&optional arg) + "Call `avy-goto-line' and move to the end of the line." + (interactive "p") + (avy-goto-line arg) + (end-of-line)) + +;;;###autoload +(defun avy-copy-line (arg) + "Copy a selected line above the current line. +ARG lines can be used." + (interactive "p") + (let ((initial-window (selected-window))) + (avy-with avy-copy-line + (let* ((start (avy--line)) + (str (buffer-substring-no-properties + start + (save-excursion + (goto-char start) + (move-end-of-line arg) + (point))))) + (select-window initial-window) + (cond ((eq avy-line-insert-style 'above) + (beginning-of-line) + (save-excursion + (insert str "\n"))) + ((eq avy-line-insert-style 'below) + (end-of-line) + (insert "\n" str) + (beginning-of-line)) + (t + (user-error "Unexpected `avy-line-insert-style'"))))))) + +;;;###autoload +(defun avy-move-line (arg) + "Move a selected line above the current line. +ARG lines can be used." + (interactive "p") + (let ((initial-window (selected-window))) + (avy-with avy-move-line + (let ((start (avy--line))) + (save-excursion + (goto-char start) + (kill-whole-line arg)) + (select-window initial-window) + (cond ((eq avy-line-insert-style 'above) + (beginning-of-line) + (save-excursion + (insert + (current-kill 0)))) + ((eq avy-line-insert-style 'below) + (end-of-line) + (newline) + (save-excursion + (insert (substring (current-kill 0) 0 -1)))) + (t + (user-error "Unexpected `avy-line-insert-style'"))))))) + +;;;###autoload +(defun avy-copy-region (arg) + "Select two lines and copy the text between them to point. + +The window scope is determined by `avy-all-windows' or +`avy-all-windows-alt' when ARG is non-nil." + (interactive "P") + (let ((initial-window (selected-window))) + (avy-with avy-copy-region + (let* ((beg (save-selected-window + (avy--line arg))) + (end (avy--line arg)) + (str (buffer-substring-no-properties + beg + (save-excursion + (goto-char end) + (line-end-position))))) + (select-window initial-window) + (cond ((eq avy-line-insert-style 'above) + (beginning-of-line) + (save-excursion + (insert str "\n"))) + ((eq avy-line-insert-style 'below) + (end-of-line) + (newline) + (save-excursion + (insert str))) + (t + (user-error "Unexpected `avy-line-insert-style'"))))))) + +;;;###autoload +(defun avy-move-region () + "Select two lines and move the text between them above the current line." + (interactive) + (avy-with avy-move-region + (let* ((initial-window (selected-window)) + (beg (avy--line)) + (end (avy--line)) + text) + (when (> beg end) + (cl-rotatef beg end)) + (setq end (save-excursion + (goto-char end) + (1+ (line-end-position)))) + (setq text (buffer-substring beg end)) + (move-beginning-of-line nil) + (delete-region beg end) + (select-window initial-window) + (insert text)))) + +;;;###autoload +(defun avy-kill-region (arg) + "Select two lines and kill the region between them. + +The window scope is determined by `avy-all-windows' or +`avy-all-windows-alt' when ARG is non-nil." + (interactive "P") + (let ((initial-window (selected-window))) + (avy-with avy-kill-region + (let* ((beg (save-selected-window + (list (avy--line arg) (selected-window)))) + (end (list (avy--line arg) (selected-window)))) + (cond + ((not (numberp (car beg))) + (user-error "Fail to select the beginning of region")) + ((not (numberp (car end))) + (user-error "Fail to select the end of region")) + ;; Restrict operation to same window. It's better if it can be + ;; different windows but same buffer; however, then the cloned + ;; buffers with different narrowed regions might cause problem. + ((not (equal (cdr beg) (cdr end))) + (user-error "Selected points are not in the same window")) + ((< (car beg) (car end)) + (save-excursion + (kill-region + (car beg) + (progn (goto-char (car end)) (forward-visible-line 1) (point))))) + (t + (save-excursion + (kill-region + (progn (goto-char (car beg)) (forward-visible-line 1) (point)) + (car end))))))) + (select-window initial-window))) + +;;;###autoload +(defun avy-kill-ring-save-region (arg) + "Select two lines and save the region between them to the kill ring. +The window scope is determined by `avy-all-windows'. +When ARG is non-nil, do the opposite of `avy-all-windows'." + (interactive "P") + (let ((initial-window (selected-window))) + (avy-with avy-kill-ring-save-region + (let* ((beg (save-selected-window + (list (avy--line arg) (selected-window)))) + (end (list (avy--line arg) (selected-window)))) + (cond + ((not (numberp (car beg))) + (user-error "Fail to select the beginning of region")) + ((not (numberp (car end))) + (user-error "Fail to select the end of region")) + ((not (equal (cdr beg) (cdr end))) + (user-error "Selected points are not in the same window")) + ((< (car beg) (car end)) + (save-excursion + (kill-ring-save + (car beg) + (progn (goto-char (car end)) (forward-visible-line 1) (point))))) + (t + (save-excursion + (kill-ring-save + (progn (goto-char (car beg)) (forward-visible-line 1) (point)) + (car end))))))) + (select-window initial-window))) + +;;;###autoload +(defun avy-kill-whole-line (arg) + "Select line and kill the whole selected line. + +With a numerical prefix ARG, kill ARG line(s) starting from the +selected line. If ARG is negative, kill backward. + +If ARG is zero, kill the selected line but exclude the trailing +newline. + +\\[universal-argument] 3 \\[avy-kil-whole-line] kill three lines +starting from the selected line. \\[universal-argument] -3 + +\\[avy-kill-whole-line] kill three lines backward including the +selected line." + (interactive "P") + (let ((initial-window (selected-window))) + (avy-with avy-kill-whole-line + (let* ((start (avy--line))) + (if (not (numberp start)) + (user-error "Fail to select the line to kill") + (save-excursion (goto-char start) + (kill-whole-line arg))))) + (select-window initial-window))) + +;;;###autoload +(defun avy-kill-ring-save-whole-line (arg) + "Select line and save the whole selected line as if killed, but don’t kill it. + +This command is similar to `avy-kill-whole-line', except that it +saves the line(s) as if killed, but does not kill it(them). + +With a numerical prefix ARG, kill ARG line(s) starting from the +selected line. If ARG is negative, kill backward. + +If ARG is zero, kill the selected line but exclude the trailing +newline." + (interactive "P") + (let ((initial-window (selected-window))) + (avy-with avy-kill-ring-save-whole-line + (let* ((start (avy--line))) + (if (not (numberp start)) + (user-error "Fail to select the line to kill") + (save-excursion + (let ((kill-read-only-ok t) + (buffer-read-only t)) + (goto-char start) + (kill-whole-line arg)))))) + (select-window initial-window))) + +;;;###autoload +(defun avy-setup-default () + "Setup the default shortcuts." + (eval-after-load "isearch" + '(define-key isearch-mode-map (kbd "C-'") 'avy-isearch))) + +(defcustom avy-timeout-seconds 0.5 + "How many seconds to wait for the second char." + :type 'float) + +(defcustom avy-enter-times-out t + "Whether enter exits avy-goto-char-timer early. If nil it matches newline" + :type 'boolean) + +(defun avy--read-candidates (&optional re-builder) + "Read as many chars as possible and return their occurrences. +At least one char must be read, and then repeatedly one next char +may be read if it is entered before `avy-timeout-seconds'. DEL +deletes the last char entered, and RET exits with the currently +read string immediately instead of waiting for another char for +`avy-timeout-seconds'. +The format of the result is the same as that of `avy--regex-candidates'. +This function obeys `avy-all-windows' setting. +RE-BUILDER is a function that takes a string and returns a regex. +When nil, `regexp-quote' is used. +If a group is captured, the first group is highlighted. +Otherwise, the whole regex is highlighted." + (let ((str "") + (re-builder (or re-builder #'regexp-quote)) + char break overlays regex) + (unwind-protect + (progn + (avy--make-backgrounds + (avy-window-list)) + (while (and (not break) + (setq char + (read-char (format "%d char%s: " + (length overlays) + (if (string= str "") + str + (format " (%s)" str))) + t + (and (not (string= str "")) + avy-timeout-seconds)))) + ;; Unhighlight + (dolist (ov overlays) + (delete-overlay ov)) + (setq overlays nil) + (cond + ;; Handle RET + ((= char 13) + (if avy-enter-times-out + (setq break t) + (setq str (concat str (list ?\n))))) + ;; Handle C-h, DEL + ((memq char avy-del-last-char-by) + (let ((l (length str))) + (when (>= l 1) + (setq str (substring str 0 (1- l)))))) + ;; Handle ESC + ((= char 27) + (keyboard-quit)) + (t + (setq str (concat str (list char))))) + ;; Highlight + (when (>= (length str) 1) + (let ((case-fold-search + (or avy-case-fold-search (string= str (downcase str)))) + found) + (avy-dowindows current-prefix-arg + (dolist (pair (avy--find-visible-regions + (window-start) + (window-end (selected-window) t))) + (save-excursion + (goto-char (car pair)) + (setq regex (funcall re-builder str)) + (while (re-search-forward regex (cdr pair) t) + (unless (not (avy--visible-p (1- (point)))) + (let* ((idx (if (= (length (match-data)) 4) 1 0)) + (ov (make-overlay + (match-beginning idx) (match-end idx)))) + (setq found t) + (push ov overlays) + (overlay-put + ov 'window (selected-window)) + (overlay-put + ov 'face 'avy-goto-char-timer-face))))))) + ;; No matches at all, so there's surely a typo in the input. + (unless found (beep))))) + (nreverse (mapcar (lambda (ov) + (cons (cons (overlay-start ov) + (overlay-end ov)) + (overlay-get ov 'window))) + overlays))) + (dolist (ov overlays) + (delete-overlay ov)) + (avy--done)))) + +(defvar avy--old-cands nil) + +;;;###autoload +(defun avy-goto-char-timer (&optional arg) + "Read one or many consecutive chars and jump to the first one. +The window scope is determined by `avy-all-windows' (ARG negates it)." + (interactive "P") + (let ((avy-all-windows (if arg + (not avy-all-windows) + avy-all-windows))) + (avy-with avy-goto-char-timer + (setq avy--old-cands (avy--read-candidates)) + (avy-process avy--old-cands)))) + +(defun avy-push-mark () + "Store the current point and window." + (let ((inhibit-message t)) + (ring-insert avy-ring + (cons (point) (selected-window))) + (unless (region-active-p) + (push-mark)))) + +(defun avy-pop-mark () + "Jump back to the last location of `avy-push-mark'." + (interactive) + (let (res) + (condition-case nil + (progn + (while (not (window-live-p + (cdr (setq res (ring-remove avy-ring 0)))))) + (let* ((window (cdr res)) + (frame (window-frame window))) + (when (and (frame-live-p frame) + (not (eq frame (selected-frame)))) + (select-frame-set-input-focus frame)) + (select-window window) + (goto-char (car res)))) + (error + (set-mark-command 4))))) + +;; ** Org-mode +(defvar org-reverse-note-order) +(declare-function org-refile "org") +(declare-function org-back-to-heading "org") +(declare-function org-reveal "org") + +(defvar org-after-refile-insert-hook) + +(defun avy-org-refile-as-child () + "Refile current heading as first child of heading selected with `avy.'" + ;; Inspired by `org-teleport': http://kitchingroup.cheme.cmu.edu/blog/2016/03/18/Org-teleport-headlines/ + (interactive) + (let* ((org-reverse-note-order t) + (marker (save-excursion + (avy-with avy-goto-line + (unless (eq 't (avy-jump (rx bol (1+ "*") (1+ space)))) + ;; `avy-jump' returns t when aborted with C-g. + (point-marker))))) + (filename (buffer-file-name (or (buffer-base-buffer (marker-buffer marker)) + (marker-buffer marker)))) + (rfloc (list nil filename nil marker)) + ;; Ensure the refiled heading is visible. + (org-after-refile-insert-hook (if (member 'org-reveal org-after-refile-insert-hook) + org-after-refile-insert-hook + (cons #'org-reveal org-after-refile-insert-hook)))) + (when marker + ;; Only attempt refile if avy session was not aborted. + (org-refile nil nil rfloc)))) + +(defun avy-org-goto-heading-timer (&optional arg) + "Read one or many characters and jump to matching Org headings. +The window scope is determined by `avy-all-windows' (ARG negates it)." + (interactive "P") + (let ((avy-all-windows (if arg + (not avy-all-windows) + avy-all-windows))) + (avy-with avy-goto-char-timer + (avy-process + (avy--read-candidates + (lambda (input) + (format "^\\*+ .*\\(%s\\)" input)))) + (org-back-to-heading)))) + +(provide 'avy) + +;;; avy.el ends here diff --git a/elpa/avy-20200311.1106/avy.elc b/elpa/avy-20200311.1106/avy.elc new file mode 100644 index 00000000..13c6a776 Binary files /dev/null and b/elpa/avy-20200311.1106/avy.elc differ diff --git a/elpa/elpy-20200323.1647/elpy-autoloads.el b/elpa/elpy-20200326.2207/elpy-autoloads.el similarity index 100% rename from elpa/elpy-20200323.1647/elpy-autoloads.el rename to elpa/elpy-20200326.2207/elpy-autoloads.el diff --git a/elpa/elpy-20200323.1647/elpy-django.el b/elpa/elpy-20200326.2207/elpy-django.el similarity index 100% rename from elpa/elpy-20200323.1647/elpy-django.el rename to elpa/elpy-20200326.2207/elpy-django.el diff --git a/elpa/elpy-20200323.1647/elpy-django.elc b/elpa/elpy-20200326.2207/elpy-django.elc similarity index 100% rename from elpa/elpy-20200323.1647/elpy-django.elc rename to elpa/elpy-20200326.2207/elpy-django.elc diff --git a/elpa/elpy-20200323.1647/elpy-pkg.el b/elpa/elpy-20200326.2207/elpy-pkg.el similarity index 76% rename from elpa/elpy-20200323.1647/elpy-pkg.el rename to elpa/elpy-20200326.2207/elpy-pkg.el index 49b194db..50d38ccb 100644 --- a/elpa/elpy-20200323.1647/elpy-pkg.el +++ b/elpa/elpy-20200326.2207/elpy-pkg.el @@ -1,4 +1,4 @@ -(define-package "elpy" "20200323.1647" "Emacs Python Development Environment" +(define-package "elpy" "20200326.2207" "Emacs Python Development Environment" '((company "0.9.2") (emacs "24.4") (highlight-indentation "0.5.0") diff --git a/elpa/elpy-20200323.1647/elpy-profile.el b/elpa/elpy-20200326.2207/elpy-profile.el similarity index 100% rename from elpa/elpy-20200323.1647/elpy-profile.el rename to elpa/elpy-20200326.2207/elpy-profile.el diff --git a/elpa/elpy-20200323.1647/elpy-profile.elc b/elpa/elpy-20200326.2207/elpy-profile.elc similarity index 100% rename from elpa/elpy-20200323.1647/elpy-profile.elc rename to elpa/elpy-20200326.2207/elpy-profile.elc diff --git a/elpa/elpy-20200323.1647/elpy-refactor.el b/elpa/elpy-20200326.2207/elpy-refactor.el similarity index 100% rename from elpa/elpy-20200323.1647/elpy-refactor.el rename to elpa/elpy-20200326.2207/elpy-refactor.el diff --git a/elpa/elpy-20200323.1647/elpy-refactor.elc b/elpa/elpy-20200326.2207/elpy-refactor.elc similarity index 100% rename from elpa/elpy-20200323.1647/elpy-refactor.elc rename to elpa/elpy-20200326.2207/elpy-refactor.elc diff --git a/elpa/elpy-20200323.1647/elpy-rpc.el b/elpa/elpy-20200326.2207/elpy-rpc.el similarity index 98% rename from elpa/elpy-20200323.1647/elpy-rpc.el rename to elpa/elpy-20200326.2207/elpy-rpc.el index ba259f82..92a3db41 100644 --- a/elpa/elpy-20200323.1647/elpy-rpc.el +++ b/elpa/elpy-20200326.2207/elpy-rpc.el @@ -1051,6 +1051,19 @@ Returns a calltip string for the function call at point." success error))) +(defun elpy-rpc-get-calltip-or-oneline-docstring (&optional success error) + "Call the get_calltip_or_oneline_doc API function. + +Returns a calltip string or a oneline docstring for the function call at point." + (when (< (buffer-size) elpy-rpc-ignored-buffer-size) + (elpy-rpc "get_calltip_or_oneline_docstring" + (list buffer-file-name + (elpy-rpc--buffer-contents) + (- (point) + (point-min))) + success error))) + + (defun elpy-rpc-get-oneline-docstring (&optional success error) "Call the get_oneline_docstring API function. diff --git a/elpa/elpy-20200323.1647/elpy-rpc.elc b/elpa/elpy-20200326.2207/elpy-rpc.elc similarity index 97% rename from elpa/elpy-20200323.1647/elpy-rpc.elc rename to elpa/elpy-20200326.2207/elpy-rpc.elc index dce4b737..58103e48 100644 Binary files a/elpa/elpy-20200323.1647/elpy-rpc.elc and b/elpa/elpy-20200326.2207/elpy-rpc.elc differ diff --git a/elpa/elpy-20200323.1647/elpy-shell.el b/elpa/elpy-20200326.2207/elpy-shell.el similarity index 100% rename from elpa/elpy-20200323.1647/elpy-shell.el rename to elpa/elpy-20200326.2207/elpy-shell.el diff --git a/elpa/elpy-20200323.1647/elpy-shell.elc b/elpa/elpy-20200326.2207/elpy-shell.elc similarity index 94% rename from elpa/elpy-20200323.1647/elpy-shell.elc rename to elpa/elpy-20200326.2207/elpy-shell.elc index 7c5c5c79..008b24bb 100644 Binary files a/elpa/elpy-20200323.1647/elpy-shell.elc and b/elpa/elpy-20200326.2207/elpy-shell.elc differ diff --git a/elpa/elpy-20200323.1647/elpy.el b/elpa/elpy-20200326.2207/elpy.el similarity index 98% rename from elpa/elpy-20200323.1647/elpy.el rename to elpa/elpy-20200326.2207/elpy.el index f2631f5f..50865e5f 100644 --- a/elpa/elpy-20200323.1647/elpy.el +++ b/elpa/elpy-20200326.2207/elpy.el @@ -2279,10 +2279,10 @@ prefix argument is given, prompt for a symbol from the user." (when (interactive-p) (message "Autoformatting code with yapf.")) (elpy-yapf-fix-code)) ((elpy-config--package-available-p "autopep8") - ((when (interactive-p) message "Autoformatting code with autopep8.")) + (when (interactive-p) (message "Autoformatting code with autopep8.")) (elpy-autopep8-fix-code)) ((elpy-config--package-available-p "black") - ((when (interactive-p) message "Autoformatting code with black.")) + (when (interactive-p) (message "Autoformatting code with black.")) (elpy-black-fix-code)) (t (message "Install yapf/autopep8 to format code.")))) @@ -3115,16 +3115,17 @@ display the current class and method instead." (let ((flymake-error (elpy-flymake-error-at-point))) (if flymake-error flymake-error - ;; Try getting calltip - (elpy-rpc-get-calltip - (lambda (calltip) + (elpy-rpc-get-calltip-or-oneline-docstring + (lambda (info) (cond - ((stringp calltip) - (eldoc-message calltip)) - (calltip - (let ((name (cdr (assq 'name calltip))) - (index (cdr (assq 'index calltip))) - (params (cdr (assq 'params calltip)))) + ;; INFO is a string, just display it + ((stringp info) + (eldoc-message info)) + ;; INFO is a calltip + ((string= (cdr (assq 'kind info)) "calltip") + (let ((name (cdr (assq 'name info))) + (index (cdr (assq 'index info))) + (params (cdr (assq 'params info)))) (when index (setf (nth index params) (propertize (nth index params) @@ -3137,28 +3138,29 @@ display the current class and method instead." (if (version<= emacs-version "25") (format "%s%s" prefix args) (eldoc-docstring-format-sym-doc prefix args nil)))))) + ;; INFO is a oneline docstring + ((string= (cdr (assq 'kind info)) "oneline_doc") + (let ((name (cdr (assq 'name info))) + (docs (cdr (assq 'doc info)))) + (let ((prefix (propertize (format "%s: " name) + 'face + 'font-lock-function-name-face))) + (eldoc-message + (if (version<= emacs-version "25") + (format "%s%s" prefix docs) + (let ((eldoc-echo-area-use-multiline-p nil)) + (eldoc-docstring-format-sym-doc prefix docs nil))))))) + ;; INFO is nil, maybe display the current function (t - ;; Try getting oneline docstring - (elpy-rpc-get-oneline-docstring - (lambda (doc) - (cond - (doc - (let ((name (cdr (assq 'name doc))) - (doc (cdr (assq 'doc doc)))) - (let ((prefix (propertize (format "%s: " name) - 'face - 'font-lock-function-name-face))) - (eldoc-message - (if (version<= emacs-version "25") - (format "%s%s" prefix doc) - (let ((eldoc-echo-area-use-multiline-p nil)) - (eldoc-docstring-format-sym-doc prefix doc nil))))))) - ;; Give the current definition - (elpy-eldoc-show-current-function - (let ((current-defun (python-info-current-defun))) - (when current-defun - (eldoc-message - (format "In: %s()" current-defun)))))))))))) + (if elpy-eldoc-show-current-function + (let ((current-defun (python-info-current-defun))) + (when current-defun + (eldoc-message + (concat "In: " + (propertize + (format "%s()" current-defun) + 'face 'font-lock-function-name-face))))) + (eldoc-message "")))))) ;; Return the last message until we're done eldoc-last-message))) diff --git a/elpa/elpy-20200323.1647/elpy.elc b/elpa/elpy-20200326.2207/elpy.elc similarity index 91% rename from elpa/elpy-20200323.1647/elpy.elc rename to elpa/elpy-20200326.2207/elpy.elc index 49c0a260..64728ab7 100644 Binary files a/elpa/elpy-20200323.1647/elpy.elc and b/elpa/elpy-20200326.2207/elpy.elc differ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/.yas-setup.el b/elpa/elpy-20200326.2207/snippets/python-mode/.yas-setup.el similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/.yas-setup.el rename to elpa/elpy-20200326.2207/snippets/python-mode/.yas-setup.el diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/.yas-setup.elc b/elpa/elpy-20200326.2207/snippets/python-mode/.yas-setup.elc similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/.yas-setup.elc rename to elpa/elpy-20200326.2207/snippets/python-mode/.yas-setup.elc diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__abs__ b/elpa/elpy-20200326.2207/snippets/python-mode/__abs__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__abs__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__abs__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__add__ b/elpa/elpy-20200326.2207/snippets/python-mode/__add__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__add__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__add__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__and__ b/elpa/elpy-20200326.2207/snippets/python-mode/__and__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__and__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__and__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__bool__ b/elpa/elpy-20200326.2207/snippets/python-mode/__bool__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__bool__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__bool__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__call__ b/elpa/elpy-20200326.2207/snippets/python-mode/__call__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__call__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__call__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__cmp__ b/elpa/elpy-20200326.2207/snippets/python-mode/__cmp__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__cmp__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__cmp__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__coerce__ b/elpa/elpy-20200326.2207/snippets/python-mode/__coerce__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__coerce__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__coerce__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__complex__ b/elpa/elpy-20200326.2207/snippets/python-mode/__complex__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__complex__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__complex__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__contains__ b/elpa/elpy-20200326.2207/snippets/python-mode/__contains__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__contains__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__contains__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__del__ b/elpa/elpy-20200326.2207/snippets/python-mode/__del__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__del__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__del__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__delattr__ b/elpa/elpy-20200326.2207/snippets/python-mode/__delattr__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__delattr__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__delattr__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__delete__ b/elpa/elpy-20200326.2207/snippets/python-mode/__delete__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__delete__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__delete__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__delitem__ b/elpa/elpy-20200326.2207/snippets/python-mode/__delitem__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__delitem__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__delitem__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__div__ b/elpa/elpy-20200326.2207/snippets/python-mode/__div__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__div__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__div__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__divmod__ b/elpa/elpy-20200326.2207/snippets/python-mode/__divmod__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__divmod__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__divmod__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__enter__ b/elpa/elpy-20200326.2207/snippets/python-mode/__enter__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__enter__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__enter__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__eq__ b/elpa/elpy-20200326.2207/snippets/python-mode/__eq__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__eq__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__eq__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__exit__ b/elpa/elpy-20200326.2207/snippets/python-mode/__exit__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__exit__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__exit__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__float__ b/elpa/elpy-20200326.2207/snippets/python-mode/__float__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__float__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__float__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__floordiv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__floordiv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__floordiv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__floordiv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ge__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ge__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ge__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ge__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__get__ b/elpa/elpy-20200326.2207/snippets/python-mode/__get__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__get__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__get__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__getattr__ b/elpa/elpy-20200326.2207/snippets/python-mode/__getattr__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__getattr__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__getattr__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__getattribute__ b/elpa/elpy-20200326.2207/snippets/python-mode/__getattribute__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__getattribute__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__getattribute__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__getitem__ b/elpa/elpy-20200326.2207/snippets/python-mode/__getitem__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__getitem__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__getitem__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__gt__ b/elpa/elpy-20200326.2207/snippets/python-mode/__gt__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__gt__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__gt__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__hash__ b/elpa/elpy-20200326.2207/snippets/python-mode/__hash__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__hash__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__hash__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__hex__ b/elpa/elpy-20200326.2207/snippets/python-mode/__hex__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__hex__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__hex__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__iadd__ b/elpa/elpy-20200326.2207/snippets/python-mode/__iadd__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__iadd__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__iadd__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__iand__ b/elpa/elpy-20200326.2207/snippets/python-mode/__iand__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__iand__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__iand__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__idiv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__idiv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__idiv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__idiv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ifloordiv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ifloordiv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ifloordiv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ifloordiv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ilshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ilshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ilshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ilshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__imod__ b/elpa/elpy-20200326.2207/snippets/python-mode/__imod__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__imod__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__imod__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__imul__ b/elpa/elpy-20200326.2207/snippets/python-mode/__imul__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__imul__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__imul__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__index__ b/elpa/elpy-20200326.2207/snippets/python-mode/__index__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__index__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__index__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__init__ b/elpa/elpy-20200326.2207/snippets/python-mode/__init__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__init__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__init__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__instancecheck__ b/elpa/elpy-20200326.2207/snippets/python-mode/__instancecheck__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__instancecheck__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__instancecheck__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__int__ b/elpa/elpy-20200326.2207/snippets/python-mode/__int__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__int__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__int__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__invert__ b/elpa/elpy-20200326.2207/snippets/python-mode/__invert__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__invert__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__invert__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ior__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ior__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ior__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ior__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ipow__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ipow__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ipow__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ipow__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__irshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__irshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__irshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__irshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__isub__ b/elpa/elpy-20200326.2207/snippets/python-mode/__isub__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__isub__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__isub__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__iter__ b/elpa/elpy-20200326.2207/snippets/python-mode/__iter__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__iter__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__iter__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__itruediv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__itruediv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__itruediv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__itruediv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ixor__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ixor__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ixor__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ixor__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__le__ b/elpa/elpy-20200326.2207/snippets/python-mode/__le__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__le__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__le__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__len__ b/elpa/elpy-20200326.2207/snippets/python-mode/__len__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__len__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__len__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__long__ b/elpa/elpy-20200326.2207/snippets/python-mode/__long__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__long__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__long__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__lshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__lshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__lshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__lshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__lt__ b/elpa/elpy-20200326.2207/snippets/python-mode/__lt__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__lt__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__lt__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__mod__ b/elpa/elpy-20200326.2207/snippets/python-mode/__mod__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__mod__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__mod__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__mul__ b/elpa/elpy-20200326.2207/snippets/python-mode/__mul__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__mul__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__mul__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ne__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ne__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ne__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ne__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__neg__ b/elpa/elpy-20200326.2207/snippets/python-mode/__neg__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__neg__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__neg__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__new__ b/elpa/elpy-20200326.2207/snippets/python-mode/__new__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__new__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__new__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__nonzero__ b/elpa/elpy-20200326.2207/snippets/python-mode/__nonzero__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__nonzero__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__nonzero__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__oct__ b/elpa/elpy-20200326.2207/snippets/python-mode/__oct__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__oct__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__oct__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__or__ b/elpa/elpy-20200326.2207/snippets/python-mode/__or__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__or__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__or__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__pos__ b/elpa/elpy-20200326.2207/snippets/python-mode/__pos__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__pos__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__pos__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__pow__ b/elpa/elpy-20200326.2207/snippets/python-mode/__pow__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__pow__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__pow__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__radd__ b/elpa/elpy-20200326.2207/snippets/python-mode/__radd__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__radd__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__radd__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rand__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rand__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rand__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rand__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rdivmod__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rdivmod__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rdivmod__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rdivmod__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__repr__ b/elpa/elpy-20200326.2207/snippets/python-mode/__repr__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__repr__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__repr__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__reversed__ b/elpa/elpy-20200326.2207/snippets/python-mode/__reversed__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__reversed__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__reversed__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rfloordiv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rfloordiv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rfloordiv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rfloordiv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rlshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rlshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rlshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rlshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rmod__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rmod__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rmod__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rmod__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rmul__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rmul__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rmul__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rmul__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__ror__ b/elpa/elpy-20200326.2207/snippets/python-mode/__ror__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__ror__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__ror__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rpow__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rpow__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rpow__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rpow__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rrshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rrshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rrshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rrshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rshift__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rshift__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rshift__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rshift__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rsub__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rsub__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rsub__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rsub__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rtruediv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rtruediv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rtruediv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rtruediv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__rxor__ b/elpa/elpy-20200326.2207/snippets/python-mode/__rxor__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__rxor__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__rxor__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__set__ b/elpa/elpy-20200326.2207/snippets/python-mode/__set__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__set__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__set__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__setattr__ b/elpa/elpy-20200326.2207/snippets/python-mode/__setattr__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__setattr__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__setattr__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__setitem__ b/elpa/elpy-20200326.2207/snippets/python-mode/__setitem__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__setitem__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__setitem__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__slots__ b/elpa/elpy-20200326.2207/snippets/python-mode/__slots__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__slots__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__slots__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__str__ b/elpa/elpy-20200326.2207/snippets/python-mode/__str__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__str__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__str__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__sub__ b/elpa/elpy-20200326.2207/snippets/python-mode/__sub__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__sub__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__sub__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__subclasscheck__ b/elpa/elpy-20200326.2207/snippets/python-mode/__subclasscheck__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__subclasscheck__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__subclasscheck__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__truediv__ b/elpa/elpy-20200326.2207/snippets/python-mode/__truediv__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__truediv__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__truediv__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__unicode__ b/elpa/elpy-20200326.2207/snippets/python-mode/__unicode__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__unicode__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__unicode__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/__xor__ b/elpa/elpy-20200326.2207/snippets/python-mode/__xor__ similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/__xor__ rename to elpa/elpy-20200326.2207/snippets/python-mode/__xor__ diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_abs b/elpa/elpy-20200326.2207/snippets/python-mode/_abs similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_abs rename to elpa/elpy-20200326.2207/snippets/python-mode/_abs diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_add b/elpa/elpy-20200326.2207/snippets/python-mode/_add similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_add rename to elpa/elpy-20200326.2207/snippets/python-mode/_add diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_and b/elpa/elpy-20200326.2207/snippets/python-mode/_and similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_and rename to elpa/elpy-20200326.2207/snippets/python-mode/_and diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_bool b/elpa/elpy-20200326.2207/snippets/python-mode/_bool similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_bool rename to elpa/elpy-20200326.2207/snippets/python-mode/_bool diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_call b/elpa/elpy-20200326.2207/snippets/python-mode/_call similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_call rename to elpa/elpy-20200326.2207/snippets/python-mode/_call diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_cmp b/elpa/elpy-20200326.2207/snippets/python-mode/_cmp similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_cmp rename to elpa/elpy-20200326.2207/snippets/python-mode/_cmp diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_coerce b/elpa/elpy-20200326.2207/snippets/python-mode/_coerce similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_coerce rename to elpa/elpy-20200326.2207/snippets/python-mode/_coerce diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_complex b/elpa/elpy-20200326.2207/snippets/python-mode/_complex similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_complex rename to elpa/elpy-20200326.2207/snippets/python-mode/_complex diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_contains b/elpa/elpy-20200326.2207/snippets/python-mode/_contains similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_contains rename to elpa/elpy-20200326.2207/snippets/python-mode/_contains diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_del b/elpa/elpy-20200326.2207/snippets/python-mode/_del similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_del rename to elpa/elpy-20200326.2207/snippets/python-mode/_del diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_delattr b/elpa/elpy-20200326.2207/snippets/python-mode/_delattr similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_delattr rename to elpa/elpy-20200326.2207/snippets/python-mode/_delattr diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_delete b/elpa/elpy-20200326.2207/snippets/python-mode/_delete similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_delete rename to elpa/elpy-20200326.2207/snippets/python-mode/_delete diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_delitem b/elpa/elpy-20200326.2207/snippets/python-mode/_delitem similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_delitem rename to elpa/elpy-20200326.2207/snippets/python-mode/_delitem diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_div b/elpa/elpy-20200326.2207/snippets/python-mode/_div similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_div rename to elpa/elpy-20200326.2207/snippets/python-mode/_div diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_divmod b/elpa/elpy-20200326.2207/snippets/python-mode/_divmod similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_divmod rename to elpa/elpy-20200326.2207/snippets/python-mode/_divmod diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_enter b/elpa/elpy-20200326.2207/snippets/python-mode/_enter similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_enter rename to elpa/elpy-20200326.2207/snippets/python-mode/_enter diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_eq b/elpa/elpy-20200326.2207/snippets/python-mode/_eq similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_eq rename to elpa/elpy-20200326.2207/snippets/python-mode/_eq diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_exit b/elpa/elpy-20200326.2207/snippets/python-mode/_exit similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_exit rename to elpa/elpy-20200326.2207/snippets/python-mode/_exit diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_float b/elpa/elpy-20200326.2207/snippets/python-mode/_float similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_float rename to elpa/elpy-20200326.2207/snippets/python-mode/_float diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_floordiv b/elpa/elpy-20200326.2207/snippets/python-mode/_floordiv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_floordiv rename to elpa/elpy-20200326.2207/snippets/python-mode/_floordiv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ge b/elpa/elpy-20200326.2207/snippets/python-mode/_ge similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ge rename to elpa/elpy-20200326.2207/snippets/python-mode/_ge diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_get b/elpa/elpy-20200326.2207/snippets/python-mode/_get similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_get rename to elpa/elpy-20200326.2207/snippets/python-mode/_get diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_getattr b/elpa/elpy-20200326.2207/snippets/python-mode/_getattr similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_getattr rename to elpa/elpy-20200326.2207/snippets/python-mode/_getattr diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_getattribute b/elpa/elpy-20200326.2207/snippets/python-mode/_getattribute similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_getattribute rename to elpa/elpy-20200326.2207/snippets/python-mode/_getattribute diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_getitem b/elpa/elpy-20200326.2207/snippets/python-mode/_getitem similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_getitem rename to elpa/elpy-20200326.2207/snippets/python-mode/_getitem diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_gt b/elpa/elpy-20200326.2207/snippets/python-mode/_gt similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_gt rename to elpa/elpy-20200326.2207/snippets/python-mode/_gt diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_hash b/elpa/elpy-20200326.2207/snippets/python-mode/_hash similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_hash rename to elpa/elpy-20200326.2207/snippets/python-mode/_hash diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_hex b/elpa/elpy-20200326.2207/snippets/python-mode/_hex similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_hex rename to elpa/elpy-20200326.2207/snippets/python-mode/_hex diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_iadd b/elpa/elpy-20200326.2207/snippets/python-mode/_iadd similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_iadd rename to elpa/elpy-20200326.2207/snippets/python-mode/_iadd diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_iand b/elpa/elpy-20200326.2207/snippets/python-mode/_iand similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_iand rename to elpa/elpy-20200326.2207/snippets/python-mode/_iand diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_idiv b/elpa/elpy-20200326.2207/snippets/python-mode/_idiv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_idiv rename to elpa/elpy-20200326.2207/snippets/python-mode/_idiv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ifloordiv b/elpa/elpy-20200326.2207/snippets/python-mode/_ifloordiv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ifloordiv rename to elpa/elpy-20200326.2207/snippets/python-mode/_ifloordiv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ilshift b/elpa/elpy-20200326.2207/snippets/python-mode/_ilshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ilshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_ilshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_imod b/elpa/elpy-20200326.2207/snippets/python-mode/_imod similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_imod rename to elpa/elpy-20200326.2207/snippets/python-mode/_imod diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_imul b/elpa/elpy-20200326.2207/snippets/python-mode/_imul similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_imul rename to elpa/elpy-20200326.2207/snippets/python-mode/_imul diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_index b/elpa/elpy-20200326.2207/snippets/python-mode/_index similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_index rename to elpa/elpy-20200326.2207/snippets/python-mode/_index diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_init b/elpa/elpy-20200326.2207/snippets/python-mode/_init similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_init rename to elpa/elpy-20200326.2207/snippets/python-mode/_init diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_instancecheck b/elpa/elpy-20200326.2207/snippets/python-mode/_instancecheck similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_instancecheck rename to elpa/elpy-20200326.2207/snippets/python-mode/_instancecheck diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_int b/elpa/elpy-20200326.2207/snippets/python-mode/_int similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_int rename to elpa/elpy-20200326.2207/snippets/python-mode/_int diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_invert b/elpa/elpy-20200326.2207/snippets/python-mode/_invert similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_invert rename to elpa/elpy-20200326.2207/snippets/python-mode/_invert diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ior b/elpa/elpy-20200326.2207/snippets/python-mode/_ior similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ior rename to elpa/elpy-20200326.2207/snippets/python-mode/_ior diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ipow b/elpa/elpy-20200326.2207/snippets/python-mode/_ipow similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ipow rename to elpa/elpy-20200326.2207/snippets/python-mode/_ipow diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_irshift b/elpa/elpy-20200326.2207/snippets/python-mode/_irshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_irshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_irshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_isub b/elpa/elpy-20200326.2207/snippets/python-mode/_isub similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_isub rename to elpa/elpy-20200326.2207/snippets/python-mode/_isub diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_iter b/elpa/elpy-20200326.2207/snippets/python-mode/_iter similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_iter rename to elpa/elpy-20200326.2207/snippets/python-mode/_iter diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_itruediv b/elpa/elpy-20200326.2207/snippets/python-mode/_itruediv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_itruediv rename to elpa/elpy-20200326.2207/snippets/python-mode/_itruediv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ixor b/elpa/elpy-20200326.2207/snippets/python-mode/_ixor similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ixor rename to elpa/elpy-20200326.2207/snippets/python-mode/_ixor diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_le b/elpa/elpy-20200326.2207/snippets/python-mode/_le similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_le rename to elpa/elpy-20200326.2207/snippets/python-mode/_le diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_len b/elpa/elpy-20200326.2207/snippets/python-mode/_len similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_len rename to elpa/elpy-20200326.2207/snippets/python-mode/_len diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_long b/elpa/elpy-20200326.2207/snippets/python-mode/_long similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_long rename to elpa/elpy-20200326.2207/snippets/python-mode/_long diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_lshift b/elpa/elpy-20200326.2207/snippets/python-mode/_lshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_lshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_lshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_lt b/elpa/elpy-20200326.2207/snippets/python-mode/_lt similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_lt rename to elpa/elpy-20200326.2207/snippets/python-mode/_lt diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_mod b/elpa/elpy-20200326.2207/snippets/python-mode/_mod similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_mod rename to elpa/elpy-20200326.2207/snippets/python-mode/_mod diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_mul b/elpa/elpy-20200326.2207/snippets/python-mode/_mul similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_mul rename to elpa/elpy-20200326.2207/snippets/python-mode/_mul diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ne b/elpa/elpy-20200326.2207/snippets/python-mode/_ne similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ne rename to elpa/elpy-20200326.2207/snippets/python-mode/_ne diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_neg b/elpa/elpy-20200326.2207/snippets/python-mode/_neg similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_neg rename to elpa/elpy-20200326.2207/snippets/python-mode/_neg diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_new b/elpa/elpy-20200326.2207/snippets/python-mode/_new similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_new rename to elpa/elpy-20200326.2207/snippets/python-mode/_new diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_nonzero b/elpa/elpy-20200326.2207/snippets/python-mode/_nonzero similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_nonzero rename to elpa/elpy-20200326.2207/snippets/python-mode/_nonzero diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_oct b/elpa/elpy-20200326.2207/snippets/python-mode/_oct similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_oct rename to elpa/elpy-20200326.2207/snippets/python-mode/_oct diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_or b/elpa/elpy-20200326.2207/snippets/python-mode/_or similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_or rename to elpa/elpy-20200326.2207/snippets/python-mode/_or diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_pos b/elpa/elpy-20200326.2207/snippets/python-mode/_pos similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_pos rename to elpa/elpy-20200326.2207/snippets/python-mode/_pos diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_pow b/elpa/elpy-20200326.2207/snippets/python-mode/_pow similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_pow rename to elpa/elpy-20200326.2207/snippets/python-mode/_pow diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_radd b/elpa/elpy-20200326.2207/snippets/python-mode/_radd similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_radd rename to elpa/elpy-20200326.2207/snippets/python-mode/_radd diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rand b/elpa/elpy-20200326.2207/snippets/python-mode/_rand similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rand rename to elpa/elpy-20200326.2207/snippets/python-mode/_rand diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rdivmod b/elpa/elpy-20200326.2207/snippets/python-mode/_rdivmod similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rdivmod rename to elpa/elpy-20200326.2207/snippets/python-mode/_rdivmod diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_repr b/elpa/elpy-20200326.2207/snippets/python-mode/_repr similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_repr rename to elpa/elpy-20200326.2207/snippets/python-mode/_repr diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_reversed b/elpa/elpy-20200326.2207/snippets/python-mode/_reversed similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_reversed rename to elpa/elpy-20200326.2207/snippets/python-mode/_reversed diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rfloordiv b/elpa/elpy-20200326.2207/snippets/python-mode/_rfloordiv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rfloordiv rename to elpa/elpy-20200326.2207/snippets/python-mode/_rfloordiv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rlshift b/elpa/elpy-20200326.2207/snippets/python-mode/_rlshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rlshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_rlshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rmod b/elpa/elpy-20200326.2207/snippets/python-mode/_rmod similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rmod rename to elpa/elpy-20200326.2207/snippets/python-mode/_rmod diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rmul b/elpa/elpy-20200326.2207/snippets/python-mode/_rmul similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rmul rename to elpa/elpy-20200326.2207/snippets/python-mode/_rmul diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_ror b/elpa/elpy-20200326.2207/snippets/python-mode/_ror similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_ror rename to elpa/elpy-20200326.2207/snippets/python-mode/_ror diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rpow b/elpa/elpy-20200326.2207/snippets/python-mode/_rpow similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rpow rename to elpa/elpy-20200326.2207/snippets/python-mode/_rpow diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rrshift b/elpa/elpy-20200326.2207/snippets/python-mode/_rrshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rrshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_rrshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rshift b/elpa/elpy-20200326.2207/snippets/python-mode/_rshift similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rshift rename to elpa/elpy-20200326.2207/snippets/python-mode/_rshift diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rsub b/elpa/elpy-20200326.2207/snippets/python-mode/_rsub similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rsub rename to elpa/elpy-20200326.2207/snippets/python-mode/_rsub diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rtruediv b/elpa/elpy-20200326.2207/snippets/python-mode/_rtruediv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rtruediv rename to elpa/elpy-20200326.2207/snippets/python-mode/_rtruediv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_rxor b/elpa/elpy-20200326.2207/snippets/python-mode/_rxor similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_rxor rename to elpa/elpy-20200326.2207/snippets/python-mode/_rxor diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_set b/elpa/elpy-20200326.2207/snippets/python-mode/_set similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_set rename to elpa/elpy-20200326.2207/snippets/python-mode/_set diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_setattr b/elpa/elpy-20200326.2207/snippets/python-mode/_setattr similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_setattr rename to elpa/elpy-20200326.2207/snippets/python-mode/_setattr diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_setitem b/elpa/elpy-20200326.2207/snippets/python-mode/_setitem similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_setitem rename to elpa/elpy-20200326.2207/snippets/python-mode/_setitem diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_slots b/elpa/elpy-20200326.2207/snippets/python-mode/_slots similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_slots rename to elpa/elpy-20200326.2207/snippets/python-mode/_slots diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_str b/elpa/elpy-20200326.2207/snippets/python-mode/_str similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_str rename to elpa/elpy-20200326.2207/snippets/python-mode/_str diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_sub b/elpa/elpy-20200326.2207/snippets/python-mode/_sub similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_sub rename to elpa/elpy-20200326.2207/snippets/python-mode/_sub diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_subclasscheck b/elpa/elpy-20200326.2207/snippets/python-mode/_subclasscheck similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_subclasscheck rename to elpa/elpy-20200326.2207/snippets/python-mode/_subclasscheck diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_truediv b/elpa/elpy-20200326.2207/snippets/python-mode/_truediv similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_truediv rename to elpa/elpy-20200326.2207/snippets/python-mode/_truediv diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_unicode b/elpa/elpy-20200326.2207/snippets/python-mode/_unicode similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_unicode rename to elpa/elpy-20200326.2207/snippets/python-mode/_unicode diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/_xor b/elpa/elpy-20200326.2207/snippets/python-mode/_xor similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/_xor rename to elpa/elpy-20200326.2207/snippets/python-mode/_xor diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/ase b/elpa/elpy-20200326.2207/snippets/python-mode/ase similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/ase rename to elpa/elpy-20200326.2207/snippets/python-mode/ase diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/asne b/elpa/elpy-20200326.2207/snippets/python-mode/asne similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/asne rename to elpa/elpy-20200326.2207/snippets/python-mode/asne diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/asr b/elpa/elpy-20200326.2207/snippets/python-mode/asr similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/asr rename to elpa/elpy-20200326.2207/snippets/python-mode/asr diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/class b/elpa/elpy-20200326.2207/snippets/python-mode/class similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/class rename to elpa/elpy-20200326.2207/snippets/python-mode/class diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/def b/elpa/elpy-20200326.2207/snippets/python-mode/def similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/def rename to elpa/elpy-20200326.2207/snippets/python-mode/def diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/defs b/elpa/elpy-20200326.2207/snippets/python-mode/defs similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/defs rename to elpa/elpy-20200326.2207/snippets/python-mode/defs diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/enc b/elpa/elpy-20200326.2207/snippets/python-mode/enc similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/enc rename to elpa/elpy-20200326.2207/snippets/python-mode/enc diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/env b/elpa/elpy-20200326.2207/snippets/python-mode/env similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/env rename to elpa/elpy-20200326.2207/snippets/python-mode/env diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/from b/elpa/elpy-20200326.2207/snippets/python-mode/from similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/from rename to elpa/elpy-20200326.2207/snippets/python-mode/from diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/pdb b/elpa/elpy-20200326.2207/snippets/python-mode/pdb similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/pdb rename to elpa/elpy-20200326.2207/snippets/python-mode/pdb diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/py3 b/elpa/elpy-20200326.2207/snippets/python-mode/py3 similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/py3 rename to elpa/elpy-20200326.2207/snippets/python-mode/py3 diff --git a/elpa/elpy-20200323.1647/snippets/python-mode/super b/elpa/elpy-20200326.2207/snippets/python-mode/super similarity index 100% rename from elpa/elpy-20200323.1647/snippets/python-mode/super rename to elpa/elpy-20200326.2207/snippets/python-mode/super diff --git a/elpa/olivetti-20200311.527/olivetti-autoloads.el b/elpa/olivetti-20200311.527/olivetti-autoloads.el deleted file mode 100644 index ee51f9cb..00000000 --- a/elpa/olivetti-20200311.527/olivetti-autoloads.el +++ /dev/null @@ -1,30 +0,0 @@ -;;; olivetti-autoloads.el --- automatically extracted autoloads -;; -;;; Code: - -(add-to-list 'load-path (directory-file-name - (or (file-name-directory #$) (car load-path)))) - - -;;;### (autoloads nil "olivetti" "olivetti.el" (0 0 0 0)) -;;; Generated autoloads from olivetti.el - -(autoload 'olivetti-mode "olivetti" "\ -Olivetti provides a nice writing environment. - -Window margins are set to relative widths to accomodate a text -body width set with `olivetti-body-width'. - -\(fn &optional ARG)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "olivetti" '("olivetti-"))) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; coding: utf-8 -;; End: -;;; olivetti-autoloads.el ends here diff --git a/elpa/olivetti-20200311.527/olivetti-pkg.el b/elpa/olivetti-20200311.527/olivetti-pkg.el deleted file mode 100644 index 9a9959d7..00000000 --- a/elpa/olivetti-20200311.527/olivetti-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "olivetti" "20200311.527" "Minor mode for a nice writing environment" '((emacs "24.5")) :commit "67e32a7754cda4c8d94227e80bfa708abb4e8e6d" :keywords '("wp" "text") :authors '(("William Rankin" . "code@william.bydasein.com")) :maintainer '("William Rankin" . "code@william.bydasein.com") :url "https://gthub.com/rnkn/olivetti") diff --git a/elpa/olivetti-20200311.527/olivetti.el b/elpa/olivetti-20200311.527/olivetti.el deleted file mode 100644 index 6d4a3c6e..00000000 --- a/elpa/olivetti-20200311.527/olivetti.el +++ /dev/null @@ -1,382 +0,0 @@ -;;; olivetti.el --- Minor mode for a nice writing environment -*- lexical-binding: t; -*- - -;; Copyright (c) 2014-2019 Paul Wiliam Rankin -;; Copyright (c) 2019 Free Software Foundation, Inc. -;; Copyright (c) 2019-2020 Paul Wiliam Rankin - -;; Author: William Rankin -;; Keywords: wp, text -;; Package-Version: 20200311.527 -;; Version: 1.9.3 -;; Package-Requires: ((emacs "24.5")) -;; URL: https://gthub.com/rnkn/olivetti - -;; This file is not part of GNU Emacs. - -;; This program is free software; you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; This program is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see . - -;;; Commentary: - -;; # Olivetti # - -;; A simple Emacs minor mode for a nice writing environment. - -;; ## Features ## - -;; - Set a desired text body width to automatically resize window margins to -;; keep the text comfortably in the middle of the window. -;; - Text body width can be the number of characters (an integer) or a fraction -;; of the window width (a float between 0.0 and 1.0). -;; - Interactively change body width with: -;; olivetti-shrink C-c { { { ... -;; olivetti-expand C-c } } } ... -;; olivetti-set-width C-c \ -;; - If olivetti-body-width is an integer, the text body width will scale with -;; use of text-scale-mode, whereas if a fraction (float) then the text body -;; width will remain at that fraction. -;; - Optionally remember the state of visual-line-mode on entry and recall its -;; state on exit. - -;; Olivetti keeps everything it does buffer-local, so you can write prose in one -;; buffer and code in another, side-by-side in the same frame. For those looking -;; for a hardcore distraction-free writing mode with a much larger scope, I -;; recommend writeroom-mode: https://github.com/joostkremers/writeroom-mode. - -;; ## Requirements ## - -;; - Emacs 25.3 - -;; ## Installation ## - -;; The latest stable release of Olivetti is available via [MELPA-stable] -;; and can be installed with: - -;; M-x package-install RET olivetti RET - -;; Alternately, download the [latest release], move this file into your -;; load-path and add to your .emacs/init.el file: - -;; (require 'olivetti) - -;; If you prefer the latest but perhaps unstable version, install via -;; [MELPA], or clone the repository into your load-path and require as -;; above: - -;; git clone https://github.com/rnkn/olivetti.git - -;; [melpa]: https://melpa.org/#/olivetti "MELPA" -;; [melpa-stable]: https://stable.melpa.org/#/olivetti "MELPA-stable" -;; [latest release]: https://github.com/rnkn/olivetti/releases/latest "Olivetti latest release" - -;; ## Contributing ## - -;; Please report bugs and request features at: -;; https://github.com/rnkn/olivetti/issues - -;; ## Hints ## - -;; To always use a different width for a specific file, set a File -;; Variable: - -;; M-x add-file-local-variable RET olivetti-body-width RET 66 RET - -;; See (info "(emacs) File Variables") - - -;;; Code: - -(defgroup olivetti () - "Minor mode for a nice writing environment" - :prefix "olivetti-" - :group 'text) - - -;;; Variables - -(defvar-local olivetti--visual-line-mode - nil - "Non-nil if `visual-line-mode' is active when `olivetti-mode' is turned on.") - - -;;; Options - -(defcustom olivetti-mode-hook - nil - "Hook for `olivetti-mode', run after the mode is activated." - :type 'hook - :safe 'hook) - -(defcustom olivetti-body-width - 70 - "Text body width to which to adjust relative margin width. - -If an integer, set text body width to that integer in columns; if -a floating point between 0.0 and 1.0, set text body width to -that fraction of the total window width. - -An integer is best if you want text body width to remain -constant, while a floating point is best if you want text body -width to change with window width. - -The floating point can anything between 0.0 and 1.0 (exclusive), -but it's better to use a value between about 0.33 and 0.9 for -best effect. - -This option does not affect file contents." - :type '(choice (integer 70) (float 0.5)) - :safe 'numberp) -(make-variable-buffer-local 'olivetti-body-width) - -(defcustom olivetti-minimum-body-width - 40 - "Minimum width in columns that text body width may be set." - :type 'integer - :safe 'integerp) - -(defcustom olivetti-lighter - " Olv" - "Mode-line indicator for `olivetti-mode'." - :type '(choice (const :tag "No lighter" "") string) - :safe 'stringp) - -(defcustom olivetti-recall-visual-line-mode-entry-state - t - "Recall the state of `visual-line-mode' upon exiting. - -When non-nil, if `visual-line-mode' is inactive upon activating -`olivetti-mode', then `visual-line-mode' will be deactivated upon -exiting. The reverse is not true." - :type 'boolean - :safe 'booleanp) - - -;;; Set Environment - -(defun olivetti-set-all-margins () - "Balance window margins in all windows displaying current buffer. - -Cycle through all windows in all frames displaying the current -buffer, and call `olivetti-set-margins'." - (dolist (window (get-buffer-window-list nil nil t)) - (olivetti-set-margins window))) - -(defun olivetti-set-margins (&optional frame-or-window) - "Balance window margins displaying current buffer. - -If FRAME-OR-WINDOW is a frame, cycle through windows displaying -current buffer in that frame, otherwise only work on the selected -window. - -First find the `olivetti-safe-width' to which to set -`olivetti-body-width', then find the appropriate margin size -relative to each window. Finally set the window margins, taking -care that the maximum size is 0." - (if (framep frame-or-window) - (dolist (window (get-buffer-window-list nil nil frame-or-window)) - (olivetti-set-margins window)) - ;; FRAME-OR-WINDOW passed below *must* be a window - (olivetti-reset-window frame-or-window) - (let ((width (olivetti-safe-width olivetti-body-width frame-or-window)) - (frame (window-frame frame-or-window)) - (window-width (window-total-width frame-or-window)) - (fringes (window-fringes frame-or-window)) - left-fringe right-fringe margin-total left-margin right-margin) - (cond ((integerp width) - (setq width (olivetti-scale-width width))) - ((floatp width) - (setq width (* window-width width)))) - (setq left-fringe (/ (car fringes) (float (frame-char-width frame))) - right-fringe (/ (cadr fringes) (float (frame-char-width frame)))) - (setq margin-total (max (/ (- window-width width) 2) 0) - left-margin (max (round (- margin-total left-fringe)) 0) - right-margin (max (round (- margin-total right-fringe)) 0)) - (set-window-parameter frame-or-window 'split-window 'olivetti-split-window) - (set-window-margins frame-or-window left-margin right-margin)))) - -(defun olivetti-reset-all-windows () - "Remove Olivetti's parameters and margins from all windows. - -Cycle through all windows displaying current buffer and call -`olivetti-reset-window'." - (dolist (window (get-buffer-window-list nil nil t)) - (olivetti-reset-window window))) - -(defun olivetti-reset-window (window) - "Remove Olivetti's parameters and margins from WINDOW." - (when (eq (window-parameter window 'split-window) 'olivetti-split-window) - (set-window-parameter window 'split-window nil)) - (set-window-margins window nil)) - -(defun olivetti-split-window (&optional window size side pixelwise) - "Call `split-window' after resetting WINDOW. -Pass SIZE, SIDE and PIXELWISE unchanged." - (olivetti-reset-window window) - (split-window window size side pixelwise)) - -(defun olivetti-split-window-sensibly (&optional window) - "Like `olivetti-split-window' but call `split-window-sensibly'. -Pass WINDOW unchanged." - (olivetti-reset-window window) - (split-window-sensibly window)) - - -;;; Calculate Width - -(defun olivetti-scale-width (n) - "Scale N in accordance with the face height. - -For compatibility with `text-scale-mode', if -`face-remapping-alist' includes a :height property on the default -face, scale N by that factor if it is a fraction, by (height/100) -if it is an integer, and otherwise scale by 1." - (let - ((height (plist-get (cadr (assq 'default face-remapping-alist)) :height))) - (cond - ((integerp height) (* n (/ height 100.0))) - ((floatp height) (* n height)) - (t n)))) - -(defun olivetti-safe-width (width window) - "Parse WIDTH to a safe value for `olivetti-body-width' for WINDOW. - -May return a float with many digits of precision." - (let ((window-width (window-total-width window)) - (fringes (window-fringes window)) - (min-width (+ olivetti-minimum-body-width - (% olivetti-minimum-body-width 2)))) - (setq window-width - (- window-width - (/ (* (max (car fringes) (cadr fringes)) 2) - (float (frame-char-width (window-frame window)))) - (% window-width 2))) - (cond ((integerp width) - (max min-width (min width (floor window-width)))) - ((floatp width) - (max (/ min-width window-width) (min width 1.0))) - ((user-error "`olivetti-body-width' must be an integer or a float") - ;; FIXME: This code is unreachable since we signal an error before - ;; getting here!? - (eval (car (get 'olivetti-body-width 'standard-value)) t))))) - - -;;; Keymap - -(defvar olivetti-mode-map - (let ((map (make-sparse-keymap))) - (define-key map (kbd "C-c }") #'olivetti-expand) - (define-key map (kbd "C-c {") #'olivetti-shrink) - (define-key map (kbd "C-c \\") #'olivetti-set-width) - map) - "Mode map for `olivetti-mode'.") - - -;;; Width Interaction - -(defun olivetti-set-width (n) - "Set text body width to N with relative margins. - -N may be an integer specifying columns or a float specifying a -fraction of the window width." - (interactive - (list (or current-prefix-arg - (read-number "Set text body width (integer or float): " - olivetti-body-width)))) - (setq olivetti-body-width n) - (olivetti-set-all-margins) - (message "Text body width set to %s" olivetti-body-width)) - -(defun olivetti-expand (&optional arg) - "Incrementally increase the value of `olivetti-body-width'. - -If prefixed with ARG, incrementally decrease." - (interactive "P") - (let* ((p (if arg -1 1)) - (n (cond ((integerp olivetti-body-width) - (+ olivetti-body-width (* 2 p))) - ((floatp olivetti-body-width) - (+ olivetti-body-width (* 0.01 p)))))) - (setq olivetti-body-width (olivetti-safe-width n (selected-window)))) - (olivetti-set-all-margins) - (message "Text body width set to %s" olivetti-body-width) - (unless overriding-terminal-local-map - (let ((keys (substring (this-single-command-keys) 0 -1)) - (map (cdr olivetti-mode-map))) - (mapc (lambda (k) (setq map (assq k map))) keys) - (when (consp map) (set-transient-map (cdr map) t))))) - -(defun olivetti-shrink (&optional arg) - "Incrementally decrease the value of `olivetti-body-width'. - -If prefixed with ARG, incrementally increase." - (interactive "P") - (let ((p (unless arg t))) - (olivetti-expand p))) - - -;;; Mode Definition - -(define-obsolete-function-alias 'turn-on-olivetti-mode - #'olivetti-mode "1.7.0") - -;;;###autoload -(define-minor-mode olivetti-mode - "Olivetti provides a nice writing environment. - -Window margins are set to relative widths to accomodate a text -body width set with `olivetti-body-width'." - :init-value nil - :lighter olivetti-lighter - (if olivetti-mode - (progn - (cond ((<= emacs-major-version 24) - (add-hook 'window-configuration-change-hook - #'olivetti-set-all-margins t t)) - ((<= emacs-major-version 26) - (add-hook 'window-configuration-change-hook - #'olivetti-set-all-margins t t) - (add-hook 'window-size-change-functions - #'olivetti-set-margins t t)) - ((<= 27 emacs-major-version) - (add-hook 'window-size-change-functions - #'olivetti-set-margins t t))) - (add-hook 'change-major-mode-hook - #'olivetti-reset-all-windows nil t) - (setq-local split-window-preferred-function - #'olivetti-split-window-sensibly) - (setq olivetti--visual-line-mode visual-line-mode) - (unless olivetti--visual-line-mode (visual-line-mode 1)) - (olivetti-set-all-margins)) - (remove-hook 'window-configuration-change-hook - #'olivetti-set-all-margins t) - (remove-hook 'window-size-change-functions - #'olivetti-set-margins t) - (olivetti-reset-all-windows) - (when (and olivetti-recall-visual-line-mode-entry-state - (not olivetti--visual-line-mode)) - (visual-line-mode 0)) - (kill-local-variable 'split-window-preferred-function) - (kill-local-variable 'olivetti--visual-line-mode))) - - - -(provide 'olivetti) - -;;; olivetti.el ends here - -;; Local Variables: -;; coding: utf-8 -;; fill-column: 80 -;; require-final-newline: t -;; sentence-end-double-space: nil -;; End: diff --git a/elpa/olivetti-20200311.527/olivetti.elc b/elpa/olivetti-20200311.527/olivetti.elc deleted file mode 100644 index 93ebd511..00000000 Binary files a/elpa/olivetti-20200311.527/olivetti.elc and /dev/null differ diff --git a/elpa/olivetti-20200320.1154/olivetti-autoloads.el b/elpa/olivetti-20200320.1154/olivetti-autoloads.el deleted file mode 100644 index afadcee7..00000000 --- a/elpa/olivetti-20200320.1154/olivetti-autoloads.el +++ /dev/null @@ -1,15 +0,0 @@ -;;; olivetti-autoloads.el --- automatically extracted autoloads -;; -;;; Code: - -(add-to-list 'load-path (directory-file-name - (or (file-name-directory #$) (car load-path)))) - - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; coding: utf-8 -;; End: -;;; olivetti-autoloads.el ends here diff --git a/elpa/olivetti-20200320.1154/olivetti-pkg.el b/elpa/olivetti-20200320.1154/olivetti-pkg.el deleted file mode 100644 index d754a189..00000000 --- a/elpa/olivetti-20200320.1154/olivetti-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "olivetti" "20200320.1154" "Minor mode for a nice writing environment" '((emacs "24.5")) :commit "5dc27716c706166e1932f4a0e9f94384b6d17cb0" :keywords '("wp" "text") :authors '(("William Rankin" . "code@william.bydasein.com")) :maintainer '("William Rankin" . "code@william.bydasein.com") :url "https://gthub.com/rnkn/olivetti") diff --git a/elpa/olivetti-20200320.1154/olivetti.el b/elpa/olivetti-20200320.1154/olivetti.el deleted file mode 100644 index e69de29b..00000000 diff --git a/elpa/olivetti-20200320.1154/olivetti.elc b/elpa/olivetti-20200320.1154/olivetti.elc deleted file mode 100644 index 9f0970a6..00000000 Binary files a/elpa/olivetti-20200320.1154/olivetti.elc and /dev/null differ diff --git a/elpa/slime-20200325.1906/contrib/README.md b/elpa/slime-20200326.1453/contrib/README.md similarity index 100% rename from elpa/slime-20200325.1906/contrib/README.md rename to elpa/slime-20200326.1453/contrib/README.md diff --git a/elpa/slime-20200325.1906/contrib/bridge.el b/elpa/slime-20200326.1453/contrib/bridge.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/bridge.el rename to elpa/slime-20200326.1453/contrib/bridge.el diff --git a/elpa/slime-20200325.1906/contrib/bridge.elc b/elpa/slime-20200326.1453/contrib/bridge.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/bridge.elc rename to elpa/slime-20200326.1453/contrib/bridge.elc diff --git a/elpa/slime-20200325.1906/contrib/inferior-slime.el b/elpa/slime-20200326.1453/contrib/inferior-slime.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/inferior-slime.el rename to elpa/slime-20200326.1453/contrib/inferior-slime.el diff --git a/elpa/slime-20200325.1906/contrib/inferior-slime.elc b/elpa/slime-20200326.1453/contrib/inferior-slime.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/inferior-slime.elc rename to elpa/slime-20200326.1453/contrib/inferior-slime.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-asdf.el b/elpa/slime-20200326.1453/contrib/slime-asdf.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-asdf.el rename to elpa/slime-20200326.1453/contrib/slime-asdf.el diff --git a/elpa/slime-20200325.1906/contrib/slime-asdf.elc b/elpa/slime-20200326.1453/contrib/slime-asdf.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-asdf.elc rename to elpa/slime-20200326.1453/contrib/slime-asdf.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-autodoc.el b/elpa/slime-20200326.1453/contrib/slime-autodoc.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-autodoc.el rename to elpa/slime-20200326.1453/contrib/slime-autodoc.el diff --git a/elpa/slime-20200325.1906/contrib/slime-autodoc.elc b/elpa/slime-20200326.1453/contrib/slime-autodoc.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-autodoc.elc rename to elpa/slime-20200326.1453/contrib/slime-autodoc.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-banner.el b/elpa/slime-20200326.1453/contrib/slime-banner.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-banner.el rename to elpa/slime-20200326.1453/contrib/slime-banner.el diff --git a/elpa/slime-20200325.1906/contrib/slime-banner.elc b/elpa/slime-20200326.1453/contrib/slime-banner.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-banner.elc rename to elpa/slime-20200326.1453/contrib/slime-banner.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-buffer-streams.el b/elpa/slime-20200326.1453/contrib/slime-buffer-streams.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-buffer-streams.el rename to elpa/slime-20200326.1453/contrib/slime-buffer-streams.el diff --git a/elpa/slime-20200325.1906/contrib/slime-buffer-streams.elc b/elpa/slime-20200326.1453/contrib/slime-buffer-streams.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-buffer-streams.elc rename to elpa/slime-20200326.1453/contrib/slime-buffer-streams.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-c-p-c.el b/elpa/slime-20200326.1453/contrib/slime-c-p-c.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-c-p-c.el rename to elpa/slime-20200326.1453/contrib/slime-c-p-c.el diff --git a/elpa/slime-20200325.1906/contrib/slime-c-p-c.elc b/elpa/slime-20200326.1453/contrib/slime-c-p-c.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-c-p-c.elc rename to elpa/slime-20200326.1453/contrib/slime-c-p-c.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-cl-indent.el b/elpa/slime-20200326.1453/contrib/slime-cl-indent.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-cl-indent.el rename to elpa/slime-20200326.1453/contrib/slime-cl-indent.el diff --git a/elpa/slime-20200325.1906/contrib/slime-cl-indent.elc b/elpa/slime-20200326.1453/contrib/slime-cl-indent.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-cl-indent.elc rename to elpa/slime-20200326.1453/contrib/slime-cl-indent.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-clipboard.el b/elpa/slime-20200326.1453/contrib/slime-clipboard.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-clipboard.el rename to elpa/slime-20200326.1453/contrib/slime-clipboard.el diff --git a/elpa/slime-20200325.1906/contrib/slime-clipboard.elc b/elpa/slime-20200326.1453/contrib/slime-clipboard.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-clipboard.elc rename to elpa/slime-20200326.1453/contrib/slime-clipboard.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-compiler-notes-tree.el b/elpa/slime-20200326.1453/contrib/slime-compiler-notes-tree.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-compiler-notes-tree.el rename to elpa/slime-20200326.1453/contrib/slime-compiler-notes-tree.el diff --git a/elpa/slime-20200325.1906/contrib/slime-compiler-notes-tree.elc b/elpa/slime-20200326.1453/contrib/slime-compiler-notes-tree.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-compiler-notes-tree.elc rename to elpa/slime-20200326.1453/contrib/slime-compiler-notes-tree.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-editing-commands.el b/elpa/slime-20200326.1453/contrib/slime-editing-commands.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-editing-commands.el rename to elpa/slime-20200326.1453/contrib/slime-editing-commands.el diff --git a/elpa/slime-20200325.1906/contrib/slime-editing-commands.elc b/elpa/slime-20200326.1453/contrib/slime-editing-commands.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-editing-commands.elc rename to elpa/slime-20200326.1453/contrib/slime-editing-commands.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-enclosing-context.el b/elpa/slime-20200326.1453/contrib/slime-enclosing-context.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-enclosing-context.el rename to elpa/slime-20200326.1453/contrib/slime-enclosing-context.el diff --git a/elpa/slime-20200325.1906/contrib/slime-enclosing-context.elc b/elpa/slime-20200326.1453/contrib/slime-enclosing-context.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-enclosing-context.elc rename to elpa/slime-20200326.1453/contrib/slime-enclosing-context.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy-inspector.el b/elpa/slime-20200326.1453/contrib/slime-fancy-inspector.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy-inspector.el rename to elpa/slime-20200326.1453/contrib/slime-fancy-inspector.el diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy-inspector.elc b/elpa/slime-20200326.1453/contrib/slime-fancy-inspector.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy-inspector.elc rename to elpa/slime-20200326.1453/contrib/slime-fancy-inspector.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy-trace.el b/elpa/slime-20200326.1453/contrib/slime-fancy-trace.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy-trace.el rename to elpa/slime-20200326.1453/contrib/slime-fancy-trace.el diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy-trace.elc b/elpa/slime-20200326.1453/contrib/slime-fancy-trace.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy-trace.elc rename to elpa/slime-20200326.1453/contrib/slime-fancy-trace.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy.el b/elpa/slime-20200326.1453/contrib/slime-fancy.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy.el rename to elpa/slime-20200326.1453/contrib/slime-fancy.el diff --git a/elpa/slime-20200325.1906/contrib/slime-fancy.elc b/elpa/slime-20200326.1453/contrib/slime-fancy.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fancy.elc rename to elpa/slime-20200326.1453/contrib/slime-fancy.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-fontifying-fu.el b/elpa/slime-20200326.1453/contrib/slime-fontifying-fu.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fontifying-fu.el rename to elpa/slime-20200326.1453/contrib/slime-fontifying-fu.el diff --git a/elpa/slime-20200325.1906/contrib/slime-fontifying-fu.elc b/elpa/slime-20200326.1453/contrib/slime-fontifying-fu.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fontifying-fu.elc rename to elpa/slime-20200326.1453/contrib/slime-fontifying-fu.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-fuzzy.el b/elpa/slime-20200326.1453/contrib/slime-fuzzy.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fuzzy.el rename to elpa/slime-20200326.1453/contrib/slime-fuzzy.el diff --git a/elpa/slime-20200325.1906/contrib/slime-fuzzy.elc b/elpa/slime-20200326.1453/contrib/slime-fuzzy.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-fuzzy.elc rename to elpa/slime-20200326.1453/contrib/slime-fuzzy.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-highlight-edits.el b/elpa/slime-20200326.1453/contrib/slime-highlight-edits.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-highlight-edits.el rename to elpa/slime-20200326.1453/contrib/slime-highlight-edits.el diff --git a/elpa/slime-20200325.1906/contrib/slime-highlight-edits.elc b/elpa/slime-20200326.1453/contrib/slime-highlight-edits.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-highlight-edits.elc rename to elpa/slime-20200326.1453/contrib/slime-highlight-edits.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-hyperdoc.el b/elpa/slime-20200326.1453/contrib/slime-hyperdoc.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-hyperdoc.el rename to elpa/slime-20200326.1453/contrib/slime-hyperdoc.el diff --git a/elpa/slime-20200325.1906/contrib/slime-hyperdoc.elc b/elpa/slime-20200326.1453/contrib/slime-hyperdoc.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-hyperdoc.elc rename to elpa/slime-20200326.1453/contrib/slime-hyperdoc.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-indentation.el b/elpa/slime-20200326.1453/contrib/slime-indentation.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-indentation.el rename to elpa/slime-20200326.1453/contrib/slime-indentation.el diff --git a/elpa/slime-20200325.1906/contrib/slime-indentation.elc b/elpa/slime-20200326.1453/contrib/slime-indentation.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-indentation.elc rename to elpa/slime-20200326.1453/contrib/slime-indentation.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-listener-hooks.el b/elpa/slime-20200326.1453/contrib/slime-listener-hooks.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-listener-hooks.el rename to elpa/slime-20200326.1453/contrib/slime-listener-hooks.el diff --git a/elpa/slime-20200325.1906/contrib/slime-listener-hooks.elc b/elpa/slime-20200326.1453/contrib/slime-listener-hooks.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-listener-hooks.elc rename to elpa/slime-20200326.1453/contrib/slime-listener-hooks.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-macrostep.el b/elpa/slime-20200326.1453/contrib/slime-macrostep.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-macrostep.el rename to elpa/slime-20200326.1453/contrib/slime-macrostep.el diff --git a/elpa/slime-20200325.1906/contrib/slime-macrostep.elc b/elpa/slime-20200326.1453/contrib/slime-macrostep.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-macrostep.elc rename to elpa/slime-20200326.1453/contrib/slime-macrostep.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-mdot-fu.el b/elpa/slime-20200326.1453/contrib/slime-mdot-fu.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-mdot-fu.el rename to elpa/slime-20200326.1453/contrib/slime-mdot-fu.el diff --git a/elpa/slime-20200325.1906/contrib/slime-mdot-fu.elc b/elpa/slime-20200326.1453/contrib/slime-mdot-fu.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-mdot-fu.elc rename to elpa/slime-20200326.1453/contrib/slime-mdot-fu.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-media.el b/elpa/slime-20200326.1453/contrib/slime-media.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-media.el rename to elpa/slime-20200326.1453/contrib/slime-media.el diff --git a/elpa/slime-20200325.1906/contrib/slime-media.elc b/elpa/slime-20200326.1453/contrib/slime-media.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-media.elc rename to elpa/slime-20200326.1453/contrib/slime-media.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-mrepl.el b/elpa/slime-20200326.1453/contrib/slime-mrepl.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-mrepl.el rename to elpa/slime-20200326.1453/contrib/slime-mrepl.el diff --git a/elpa/slime-20200325.1906/contrib/slime-mrepl.elc b/elpa/slime-20200326.1453/contrib/slime-mrepl.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-mrepl.elc rename to elpa/slime-20200326.1453/contrib/slime-mrepl.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-package-fu.el b/elpa/slime-20200326.1453/contrib/slime-package-fu.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-package-fu.el rename to elpa/slime-20200326.1453/contrib/slime-package-fu.el diff --git a/elpa/slime-20200325.1906/contrib/slime-package-fu.elc b/elpa/slime-20200326.1453/contrib/slime-package-fu.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-package-fu.elc rename to elpa/slime-20200326.1453/contrib/slime-package-fu.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-parse.el b/elpa/slime-20200326.1453/contrib/slime-parse.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-parse.el rename to elpa/slime-20200326.1453/contrib/slime-parse.el diff --git a/elpa/slime-20200325.1906/contrib/slime-parse.elc b/elpa/slime-20200326.1453/contrib/slime-parse.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-parse.elc rename to elpa/slime-20200326.1453/contrib/slime-parse.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-presentation-streams.el b/elpa/slime-20200326.1453/contrib/slime-presentation-streams.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-presentation-streams.el rename to elpa/slime-20200326.1453/contrib/slime-presentation-streams.el diff --git a/elpa/slime-20200325.1906/contrib/slime-presentation-streams.elc b/elpa/slime-20200326.1453/contrib/slime-presentation-streams.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-presentation-streams.elc rename to elpa/slime-20200326.1453/contrib/slime-presentation-streams.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-presentations.el b/elpa/slime-20200326.1453/contrib/slime-presentations.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-presentations.el rename to elpa/slime-20200326.1453/contrib/slime-presentations.el diff --git a/elpa/slime-20200325.1906/contrib/slime-presentations.elc b/elpa/slime-20200326.1453/contrib/slime-presentations.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-presentations.elc rename to elpa/slime-20200326.1453/contrib/slime-presentations.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-quicklisp.el b/elpa/slime-20200326.1453/contrib/slime-quicklisp.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-quicklisp.el rename to elpa/slime-20200326.1453/contrib/slime-quicklisp.el diff --git a/elpa/slime-20200325.1906/contrib/slime-quicklisp.elc b/elpa/slime-20200326.1453/contrib/slime-quicklisp.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-quicklisp.elc rename to elpa/slime-20200326.1453/contrib/slime-quicklisp.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-references.el b/elpa/slime-20200326.1453/contrib/slime-references.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-references.el rename to elpa/slime-20200326.1453/contrib/slime-references.el diff --git a/elpa/slime-20200325.1906/contrib/slime-references.elc b/elpa/slime-20200326.1453/contrib/slime-references.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-references.elc rename to elpa/slime-20200326.1453/contrib/slime-references.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-repl.el b/elpa/slime-20200326.1453/contrib/slime-repl.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-repl.el rename to elpa/slime-20200326.1453/contrib/slime-repl.el diff --git a/elpa/slime-20200325.1906/contrib/slime-repl.elc b/elpa/slime-20200326.1453/contrib/slime-repl.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-repl.elc rename to elpa/slime-20200326.1453/contrib/slime-repl.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-sbcl-exts.el b/elpa/slime-20200326.1453/contrib/slime-sbcl-exts.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-sbcl-exts.el rename to elpa/slime-20200326.1453/contrib/slime-sbcl-exts.el diff --git a/elpa/slime-20200325.1906/contrib/slime-sbcl-exts.elc b/elpa/slime-20200326.1453/contrib/slime-sbcl-exts.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-sbcl-exts.elc rename to elpa/slime-20200326.1453/contrib/slime-sbcl-exts.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-scheme.el b/elpa/slime-20200326.1453/contrib/slime-scheme.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-scheme.el rename to elpa/slime-20200326.1453/contrib/slime-scheme.el diff --git a/elpa/slime-20200325.1906/contrib/slime-scheme.elc b/elpa/slime-20200326.1453/contrib/slime-scheme.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-scheme.elc rename to elpa/slime-20200326.1453/contrib/slime-scheme.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-scratch.el b/elpa/slime-20200326.1453/contrib/slime-scratch.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-scratch.el rename to elpa/slime-20200326.1453/contrib/slime-scratch.el diff --git a/elpa/slime-20200325.1906/contrib/slime-scratch.elc b/elpa/slime-20200326.1453/contrib/slime-scratch.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-scratch.elc rename to elpa/slime-20200326.1453/contrib/slime-scratch.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-snapshot.el b/elpa/slime-20200326.1453/contrib/slime-snapshot.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-snapshot.el rename to elpa/slime-20200326.1453/contrib/slime-snapshot.el diff --git a/elpa/slime-20200325.1906/contrib/slime-snapshot.elc b/elpa/slime-20200326.1453/contrib/slime-snapshot.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-snapshot.elc rename to elpa/slime-20200326.1453/contrib/slime-snapshot.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-sprof.el b/elpa/slime-20200326.1453/contrib/slime-sprof.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-sprof.el rename to elpa/slime-20200326.1453/contrib/slime-sprof.el diff --git a/elpa/slime-20200325.1906/contrib/slime-sprof.elc b/elpa/slime-20200326.1453/contrib/slime-sprof.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-sprof.elc rename to elpa/slime-20200326.1453/contrib/slime-sprof.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-trace-dialog.el b/elpa/slime-20200326.1453/contrib/slime-trace-dialog.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-trace-dialog.el rename to elpa/slime-20200326.1453/contrib/slime-trace-dialog.el diff --git a/elpa/slime-20200325.1906/contrib/slime-trace-dialog.elc b/elpa/slime-20200326.1453/contrib/slime-trace-dialog.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-trace-dialog.elc rename to elpa/slime-20200326.1453/contrib/slime-trace-dialog.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-tramp.el b/elpa/slime-20200326.1453/contrib/slime-tramp.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-tramp.el rename to elpa/slime-20200326.1453/contrib/slime-tramp.el diff --git a/elpa/slime-20200325.1906/contrib/slime-tramp.elc b/elpa/slime-20200326.1453/contrib/slime-tramp.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-tramp.elc rename to elpa/slime-20200326.1453/contrib/slime-tramp.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-typeout-frame.el b/elpa/slime-20200326.1453/contrib/slime-typeout-frame.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-typeout-frame.el rename to elpa/slime-20200326.1453/contrib/slime-typeout-frame.el diff --git a/elpa/slime-20200325.1906/contrib/slime-typeout-frame.elc b/elpa/slime-20200326.1453/contrib/slime-typeout-frame.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-typeout-frame.elc rename to elpa/slime-20200326.1453/contrib/slime-typeout-frame.elc diff --git a/elpa/slime-20200325.1906/contrib/slime-xref-browser.el b/elpa/slime-20200326.1453/contrib/slime-xref-browser.el similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-xref-browser.el rename to elpa/slime-20200326.1453/contrib/slime-xref-browser.el diff --git a/elpa/slime-20200325.1906/contrib/slime-xref-browser.elc b/elpa/slime-20200326.1453/contrib/slime-xref-browser.elc similarity index 100% rename from elpa/slime-20200325.1906/contrib/slime-xref-browser.elc rename to elpa/slime-20200326.1453/contrib/slime-xref-browser.elc diff --git a/elpa/slime-20200325.1906/contrib/swank-arglists.lisp b/elpa/slime-20200326.1453/contrib/swank-arglists.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-arglists.lisp rename to elpa/slime-20200326.1453/contrib/swank-arglists.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-asdf.lisp b/elpa/slime-20200326.1453/contrib/swank-asdf.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-asdf.lisp rename to elpa/slime-20200326.1453/contrib/swank-asdf.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-buffer-streams.lisp b/elpa/slime-20200326.1453/contrib/swank-buffer-streams.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-buffer-streams.lisp rename to elpa/slime-20200326.1453/contrib/swank-buffer-streams.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-c-p-c.lisp b/elpa/slime-20200326.1453/contrib/swank-c-p-c.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-c-p-c.lisp rename to elpa/slime-20200326.1453/contrib/swank-c-p-c.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-clipboard.lisp b/elpa/slime-20200326.1453/contrib/swank-clipboard.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-clipboard.lisp rename to elpa/slime-20200326.1453/contrib/swank-clipboard.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-fancy-inspector.lisp b/elpa/slime-20200326.1453/contrib/swank-fancy-inspector.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-fancy-inspector.lisp rename to elpa/slime-20200326.1453/contrib/swank-fancy-inspector.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-fuzzy.lisp b/elpa/slime-20200326.1453/contrib/swank-fuzzy.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-fuzzy.lisp rename to elpa/slime-20200326.1453/contrib/swank-fuzzy.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-goo.goo b/elpa/slime-20200326.1453/contrib/swank-goo.goo similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-goo.goo rename to elpa/slime-20200326.1453/contrib/swank-goo.goo diff --git a/elpa/slime-20200325.1906/contrib/swank-hyperdoc.lisp b/elpa/slime-20200326.1453/contrib/swank-hyperdoc.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-hyperdoc.lisp rename to elpa/slime-20200326.1453/contrib/swank-hyperdoc.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-ikarus.ss b/elpa/slime-20200326.1453/contrib/swank-ikarus.ss similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-ikarus.ss rename to elpa/slime-20200326.1453/contrib/swank-ikarus.ss diff --git a/elpa/slime-20200325.1906/contrib/swank-indentation.lisp b/elpa/slime-20200326.1453/contrib/swank-indentation.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-indentation.lisp rename to elpa/slime-20200326.1453/contrib/swank-indentation.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-jolt.k b/elpa/slime-20200326.1453/contrib/swank-jolt.k similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-jolt.k rename to elpa/slime-20200326.1453/contrib/swank-jolt.k diff --git a/elpa/slime-20200325.1906/contrib/swank-kawa.scm b/elpa/slime-20200326.1453/contrib/swank-kawa.scm similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-kawa.scm rename to elpa/slime-20200326.1453/contrib/swank-kawa.scm diff --git a/elpa/slime-20200325.1906/contrib/swank-larceny.scm b/elpa/slime-20200326.1453/contrib/swank-larceny.scm similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-larceny.scm rename to elpa/slime-20200326.1453/contrib/swank-larceny.scm diff --git a/elpa/slime-20200325.1906/contrib/swank-listener-hooks.lisp b/elpa/slime-20200326.1453/contrib/swank-listener-hooks.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-listener-hooks.lisp rename to elpa/slime-20200326.1453/contrib/swank-listener-hooks.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-macrostep.lisp b/elpa/slime-20200326.1453/contrib/swank-macrostep.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-macrostep.lisp rename to elpa/slime-20200326.1453/contrib/swank-macrostep.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-media.lisp b/elpa/slime-20200326.1453/contrib/swank-media.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-media.lisp rename to elpa/slime-20200326.1453/contrib/swank-media.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-mit-scheme.scm b/elpa/slime-20200326.1453/contrib/swank-mit-scheme.scm similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-mit-scheme.scm rename to elpa/slime-20200326.1453/contrib/swank-mit-scheme.scm diff --git a/elpa/slime-20200325.1906/contrib/swank-mlworks.sml b/elpa/slime-20200326.1453/contrib/swank-mlworks.sml similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-mlworks.sml rename to elpa/slime-20200326.1453/contrib/swank-mlworks.sml diff --git a/elpa/slime-20200325.1906/contrib/swank-mrepl.lisp b/elpa/slime-20200326.1453/contrib/swank-mrepl.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-mrepl.lisp rename to elpa/slime-20200326.1453/contrib/swank-mrepl.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-package-fu.lisp b/elpa/slime-20200326.1453/contrib/swank-package-fu.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-package-fu.lisp rename to elpa/slime-20200326.1453/contrib/swank-package-fu.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-presentation-streams.lisp b/elpa/slime-20200326.1453/contrib/swank-presentation-streams.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-presentation-streams.lisp rename to elpa/slime-20200326.1453/contrib/swank-presentation-streams.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-presentations.lisp b/elpa/slime-20200326.1453/contrib/swank-presentations.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-presentations.lisp rename to elpa/slime-20200326.1453/contrib/swank-presentations.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-quicklisp.lisp b/elpa/slime-20200326.1453/contrib/swank-quicklisp.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-quicklisp.lisp rename to elpa/slime-20200326.1453/contrib/swank-quicklisp.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-r6rs.scm b/elpa/slime-20200326.1453/contrib/swank-r6rs.scm similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-r6rs.scm rename to elpa/slime-20200326.1453/contrib/swank-r6rs.scm diff --git a/elpa/slime-20200325.1906/contrib/swank-repl.lisp b/elpa/slime-20200326.1453/contrib/swank-repl.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-repl.lisp rename to elpa/slime-20200326.1453/contrib/swank-repl.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-sbcl-exts.lisp b/elpa/slime-20200326.1453/contrib/swank-sbcl-exts.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-sbcl-exts.lisp rename to elpa/slime-20200326.1453/contrib/swank-sbcl-exts.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-snapshot.lisp b/elpa/slime-20200326.1453/contrib/swank-snapshot.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-snapshot.lisp rename to elpa/slime-20200326.1453/contrib/swank-snapshot.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-sprof.lisp b/elpa/slime-20200326.1453/contrib/swank-sprof.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-sprof.lisp rename to elpa/slime-20200326.1453/contrib/swank-sprof.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-trace-dialog.lisp b/elpa/slime-20200326.1453/contrib/swank-trace-dialog.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-trace-dialog.lisp rename to elpa/slime-20200326.1453/contrib/swank-trace-dialog.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank-util.lisp b/elpa/slime-20200326.1453/contrib/swank-util.lisp similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank-util.lisp rename to elpa/slime-20200326.1453/contrib/swank-util.lisp diff --git a/elpa/slime-20200325.1906/contrib/swank.rb b/elpa/slime-20200326.1453/contrib/swank.rb similarity index 100% rename from elpa/slime-20200325.1906/contrib/swank.rb rename to elpa/slime-20200326.1453/contrib/swank.rb diff --git a/elpa/slime-20200325.1906/dir b/elpa/slime-20200326.1453/dir similarity index 100% rename from elpa/slime-20200325.1906/dir rename to elpa/slime-20200326.1453/dir diff --git a/elpa/slime-20200325.1906/lib/hyperspec.el b/elpa/slime-20200326.1453/lib/hyperspec.el similarity index 100% rename from elpa/slime-20200325.1906/lib/hyperspec.el rename to elpa/slime-20200326.1453/lib/hyperspec.el diff --git a/elpa/slime-20200325.1906/lib/hyperspec.elc b/elpa/slime-20200326.1453/lib/hyperspec.elc similarity index 100% rename from elpa/slime-20200325.1906/lib/hyperspec.elc rename to elpa/slime-20200326.1453/lib/hyperspec.elc diff --git a/elpa/slime-20200325.1906/metering.lisp b/elpa/slime-20200326.1453/metering.lisp similarity index 100% rename from elpa/slime-20200325.1906/metering.lisp rename to elpa/slime-20200326.1453/metering.lisp diff --git a/elpa/slime-20200325.1906/nregex.lisp b/elpa/slime-20200326.1453/nregex.lisp similarity index 100% rename from elpa/slime-20200325.1906/nregex.lisp rename to elpa/slime-20200326.1453/nregex.lisp diff --git a/elpa/slime-20200325.1906/packages.lisp b/elpa/slime-20200326.1453/packages.lisp similarity index 100% rename from elpa/slime-20200325.1906/packages.lisp rename to elpa/slime-20200326.1453/packages.lisp diff --git a/elpa/slime-20200325.1906/sbcl-pprint-patch.lisp b/elpa/slime-20200326.1453/sbcl-pprint-patch.lisp similarity index 100% rename from elpa/slime-20200325.1906/sbcl-pprint-patch.lisp rename to elpa/slime-20200326.1453/sbcl-pprint-patch.lisp diff --git a/elpa/slime-20200325.1906/slime-autoloads.el b/elpa/slime-20200326.1453/slime-autoloads.el similarity index 100% rename from elpa/slime-20200325.1906/slime-autoloads.el rename to elpa/slime-20200326.1453/slime-autoloads.el diff --git a/elpa/slime-20200325.1906/slime-pkg.el b/elpa/slime-20200326.1453/slime-pkg.el similarity index 75% rename from elpa/slime-20200325.1906/slime-pkg.el rename to elpa/slime-20200326.1453/slime-pkg.el index af1f7b6f..42187a41 100644 --- a/elpa/slime-20200325.1906/slime-pkg.el +++ b/elpa/slime-20200326.1453/slime-pkg.el @@ -1,4 +1,4 @@ -(define-package "slime" "20200325.1906" "Superior Lisp Interaction Mode for Emacs" +(define-package "slime" "20200326.1453" "Superior Lisp Interaction Mode for Emacs" '((cl-lib "0.5") (macrostep "0.9")) :keywords diff --git a/elpa/slime-20200325.1906/slime-tests.el b/elpa/slime-20200326.1453/slime-tests.el similarity index 100% rename from elpa/slime-20200325.1906/slime-tests.el rename to elpa/slime-20200326.1453/slime-tests.el diff --git a/elpa/slime-20200325.1906/slime-tests.elc b/elpa/slime-20200326.1453/slime-tests.elc similarity index 100% rename from elpa/slime-20200325.1906/slime-tests.elc rename to elpa/slime-20200326.1453/slime-tests.elc diff --git a/elpa/slime-20200325.1906/slime.el b/elpa/slime-20200326.1453/slime.el similarity index 100% rename from elpa/slime-20200325.1906/slime.el rename to elpa/slime-20200326.1453/slime.el diff --git a/elpa/slime-20200325.1906/slime.elc b/elpa/slime-20200326.1453/slime.elc similarity index 100% rename from elpa/slime-20200325.1906/slime.elc rename to elpa/slime-20200326.1453/slime.elc diff --git a/elpa/slime-20200325.1906/slime.info b/elpa/slime-20200326.1453/slime.info similarity index 97% rename from elpa/slime-20200325.1906/slime.info rename to elpa/slime-20200326.1453/slime.info index f804aaf7..922ed440 100644 --- a/elpa/slime-20200325.1906/slime.info +++ b/elpa/slime-20200326.1453/slime.info @@ -15,7 +15,7 @@ SLIME ***** SLIME is the “Superior Lisp Interaction Mode for Emacs”. This is the -manual for version 2.24. (Last updated March 26, 2020) +manual for version 2.24. (Last updated March 27, 2020) Written by Luke Gorrie and others. @@ -374,8 +374,6 @@ SLIME installation with bundled extensions: ;; _Setup load-path, autoloads and your lisp system_ (add-to-list 'load-path "~/dir/to/cloned/slime") (require 'slime-autoloads) - ;; _Also setup the slime-fancy contrib_ - (add-to-list 'slime-contribs 'slime-fancy) See *note Loading Contribs:: for more information on SLIME’s contrib system. @@ -2048,7 +2046,8 @@ File: slime.info, Node: Loading Contribs, Next: REPL, Up: Contributed Package Contrib packages aren’t loaded by default. You have to modify your setup a bit so that Emacs knows where to find them and which of them to load. Generally, you set the variable ‘slime-contribs’ with the list of -package-names that you want to use. For example, a setup to load the +package-names that you want to use. Its default value is ‘slime-fancy’ +which loads almost everything. For example, a setup to load the ‘slime-scratch’ and ‘slime-editing-commands’ packages looks like: ;; _Setup load-path and autoloads_ @@ -2062,17 +2061,6 @@ package-names that you want to use. For example, a setup to load the After starting SLIME, the commands of both packages should be available. - The REPL and ‘slime-fancy’ modules deserve special mention. Many -users consider the REPL (*note REPL::) essential while ‘slime-fancy’ -(*note slime-fancy::) loads the REPL and almost all of the popular -contribs. So, if you aren’t sure what to choose start with: - - (setq slime-contribs '(slime-repl)) ; repl only - - If you like what you see try this: - - (setq slime-contribs '(slime-fancy)) ; almost everything - 8.1.1 Loading and unloading “on the fly” ---------------------------------------- @@ -2894,12 +2882,6 @@ collects and stores them in your lisp environment until, on user’s request, they are fetched into Emacs and displayed in a dialog-like interactive view. - To use this contrib, add it to ‘slime-contribs’ in your ‘~/.emacs’, -either directly by setting up ‘slime-fancy’ (*note slime-fancy::). - - ;; setting up 'slime-fancy would also have worked - (add-to-list 'slime-contribs 'slime-trace-dialog) - After starting up SLIME, SLIME’s Trace Dialog installs a _Trace_ menu in the menu-bar of any ‘slime-mode’ buffer and adds two new commands, with respective key-bindings: @@ -3031,7 +3013,8 @@ File: slime.info, Node: slime-fancy, Next: Quicklisp, Prev: SLIME Enhanced M- ================================ ‘slime-fancy’ is a meta package which loads a combination of the most -popular packages. +popular packages. It is the default value of ‘slime-contribs’, thus it +is loaded by default.  File: slime.info, Node: Quicklisp, Prev: slime-fancy, Up: Contributed Packages @@ -3247,12 +3230,12 @@ Key (Character) Index * C-c M-o: REPL commands. (line 36) * C-c M-p: Recovery. (line 20) * C-c M-q: Editing Commands. (line 11) -* C-c M-t: SLIME Trace Dialog. (line 32) -* C-c T: SLIME Trace Dialog. (line 45) +* C-c M-t: SLIME Trace Dialog. (line 26) +* C-c T: SLIME Trace Dialog. (line 39) * C-c ~: Recovery. (line 15) * C-j: REPL commands. (line 24) * C-j <1>: Scratch Buffer. (line 13) -* C-k: SLIME Trace Dialog. (line 89) +* C-k: SLIME Trace Dialog. (line 83) * C-M-x: Evaluation. (line 19) * C-RET: REPL commands. (line 15) * C-x 4 .: Finding definitions. (line 23) @@ -3274,8 +3257,8 @@ Key (Character) Index (line 17) * g <2>: Multiple connections. (line 61) -* g <3>: SLIME Trace Dialog. (line 82) -* G: SLIME Trace Dialog. (line 85) +* g <3>: SLIME Trace Dialog. (line 76) +* G: SLIME Trace Dialog. (line 79) * i: Examining frames. (line 34) * l: Inspector. (line 41) * M-,: Finding definitions. (line 18) @@ -3529,12 +3512,12 @@ Command and Function Index (line 65) * slime-toggle-profile-fdefinition: Profiling. (line 11) * slime-toggle-trace-fdefinition: Disassembly. (line 12) -* slime-trace-dialog: SLIME Trace Dialog. (line 45) +* slime-trace-dialog: SLIME Trace Dialog. (line 39) * slime-trace-dialog-clear-fetched-traces: SLIME Trace Dialog. - (line 89) -* slime-trace-dialog-fetch-status: SLIME Trace Dialog. (line 82) -* slime-trace-dialog-fetch-traces: SLIME Trace Dialog. (line 85) -* slime-trace-dialog-toggle-trace: SLIME Trace Dialog. (line 32) + (line 83) +* slime-trace-dialog-fetch-status: SLIME Trace Dialog. (line 76) +* slime-trace-dialog-fetch-traces: SLIME Trace Dialog. (line 79) +* slime-trace-dialog-toggle-trace: SLIME Trace Dialog. (line 26) * slime-undefine-function: Evaluation. (line 52) * slime-unprofile-all: Profiling. (line 17) * slime-untrace-all: Disassembly. (line 17) @@ -3635,102 +3618,102 @@ Node: Installation7327 Node: Running8593 Node: Setup Tuning9136 Node: Basic customization9667 -Node: Multiple Lisps10733 -Node: Loading Swank faster13227 -Ref: init-example14320 -Node: SLIME mode14609 -Node: User-interface conventions15207 -Node: Temporary buffers15616 -Node: Inferior-lisp17069 -Node: Multithreading17894 -Node: Key bindings19139 -Ref: describe-key20605 -Ref: describe-bindings20748 -Ref: describe-mode20891 -Ref: view-lossage21075 -Node: Evaluation22270 -Node: Compilation24175 -Node: Completion26934 -Node: Finding definitions27565 -Node: Documentation28705 -Node: Cross-reference30872 -Node: Xref buffer commands32609 -Node: Macro-expansion33168 -Node: Disassembly34189 -Node: Recovery34734 -Node: Inspector35503 -Node: Profiling37741 -Node: Other38538 -Node: Semantic indentation38791 -Ref: Semantic indentation-Footnote-140922 -Node: Reader conditionals41017 -Node: Debugger41368 -Node: Examining frames42008 -Node: Restarts43140 -Ref: sldb-quit43354 -Node: Frame Navigation43781 -Node: Stepping44481 -Node: Miscellaneous45153 -Node: Misc46092 -Node: slime-selector46279 -Node: slime-macroexpansion-minor-mode47661 -Node: Multiple connections48516 -Node: Customization51576 -Node: Emacs-side customization51751 -Ref: slime-completion-at-point-functions52444 -Ref: slime-net-coding-system53335 -Node: Hooks54008 -Ref: slime-connected-hook54373 -Node: Lisp-side54857 -Node: Communication style55267 -Node: Other configurables57829 -Ref: *SLDB-QUIT-RESTART*59227 -Node: Tips and Tricks61818 -Node: Connecting to a remote lisp62043 -Node: Setting up the lisp image62748 -Ref: Setting up the lisp image-Footnote-164636 -Ref: Setting up the lisp image-Footnote-264716 -Node: Setting up Emacs64892 -Ref: Setting up Emacs-Footnote-165728 -Node: Setting up pathname translations65908 -Node: Global IO Redirection67549 -Node: Auto-SLIME68482 -Node: Contributed Packages68903 -Node: Loading Contribs69652 -Node: REPL71974 -Node: REPL commands73389 -Node: Input Navigation74550 -Node: Shortcuts76074 -Node: slime-mrepl77570 -Node: inferior-slime-mode78078 -Node: Compound Completion78783 -Ref: slime-complete-symbol*78960 -Ref: Compound Completion-Footnote-182212 -Node: Fuzzy Completion82336 -Ref: slime-fuzzy-complete-symbol82589 -Node: slime-autodoc-mode85881 -Node: ASDF87299 -Node: Banner89257 -Node: Editing Commands89703 -Node: Fancy Inspector91330 -Node: Presentations92061 -Ref: Presentations-Footnote-198617 -Node: Typeout frames98858 -Node: TRAMP99982 -Node: Documentation Links100258 -Node: Xref and Class Browser100683 -Node: Highlight Edits101275 -Node: Scratch Buffer101747 -Ref: slime-scratch101909 -Node: SLIME Trace Dialog102564 -Node: slime-sprof106814 -Node: SLIME Enhanced M-.107802 -Node: slime-fancy108184 -Node: Quicklisp108460 -Node: Credits108988 -Node: Key Index114592 -Node: Command Index126382 -Node: Variable Index141624 +Node: Multiple Lisps10640 +Node: Loading Swank faster13134 +Ref: init-example14227 +Node: SLIME mode14516 +Node: User-interface conventions15114 +Node: Temporary buffers15523 +Node: Inferior-lisp16976 +Node: Multithreading17801 +Node: Key bindings19046 +Ref: describe-key20512 +Ref: describe-bindings20655 +Ref: describe-mode20798 +Ref: view-lossage20982 +Node: Evaluation22177 +Node: Compilation24082 +Node: Completion26841 +Node: Finding definitions27472 +Node: Documentation28612 +Node: Cross-reference30779 +Node: Xref buffer commands32516 +Node: Macro-expansion33075 +Node: Disassembly34096 +Node: Recovery34641 +Node: Inspector35410 +Node: Profiling37648 +Node: Other38445 +Node: Semantic indentation38698 +Ref: Semantic indentation-Footnote-140829 +Node: Reader conditionals40924 +Node: Debugger41275 +Node: Examining frames41915 +Node: Restarts43047 +Ref: sldb-quit43261 +Node: Frame Navigation43688 +Node: Stepping44388 +Node: Miscellaneous45060 +Node: Misc45999 +Node: slime-selector46186 +Node: slime-macroexpansion-minor-mode47568 +Node: Multiple connections48423 +Node: Customization51483 +Node: Emacs-side customization51658 +Ref: slime-completion-at-point-functions52351 +Ref: slime-net-coding-system53242 +Node: Hooks53915 +Ref: slime-connected-hook54280 +Node: Lisp-side54764 +Node: Communication style55174 +Node: Other configurables57736 +Ref: *SLDB-QUIT-RESTART*59134 +Node: Tips and Tricks61725 +Node: Connecting to a remote lisp61950 +Node: Setting up the lisp image62655 +Ref: Setting up the lisp image-Footnote-164543 +Ref: Setting up the lisp image-Footnote-264623 +Node: Setting up Emacs64799 +Ref: Setting up Emacs-Footnote-165635 +Node: Setting up pathname translations65815 +Node: Global IO Redirection67456 +Node: Auto-SLIME68389 +Node: Contributed Packages68810 +Node: Loading Contribs69559 +Node: REPL71519 +Node: REPL commands72934 +Node: Input Navigation74095 +Node: Shortcuts75619 +Node: slime-mrepl77115 +Node: inferior-slime-mode77623 +Node: Compound Completion78328 +Ref: slime-complete-symbol*78505 +Ref: Compound Completion-Footnote-181757 +Node: Fuzzy Completion81881 +Ref: slime-fuzzy-complete-symbol82134 +Node: slime-autodoc-mode85426 +Node: ASDF86844 +Node: Banner88802 +Node: Editing Commands89248 +Node: Fancy Inspector90875 +Node: Presentations91606 +Ref: Presentations-Footnote-198162 +Node: Typeout frames98403 +Node: TRAMP99527 +Node: Documentation Links99803 +Node: Xref and Class Browser100228 +Node: Highlight Edits100820 +Node: Scratch Buffer101292 +Ref: slime-scratch101454 +Node: SLIME Trace Dialog102109 +Node: slime-sprof106097 +Node: SLIME Enhanced M-.107085 +Node: slime-fancy107467 +Node: Quicklisp107823 +Node: Credits108351 +Node: Key Index113955 +Node: Command Index125745 +Node: Variable Index140987  End Tag Table diff --git a/elpa/slime-20200325.1906/start-swank.lisp b/elpa/slime-20200326.1453/start-swank.lisp similarity index 100% rename from elpa/slime-20200325.1906/start-swank.lisp rename to elpa/slime-20200326.1453/start-swank.lisp diff --git a/elpa/slime-20200325.1906/swank-loader.lisp b/elpa/slime-20200326.1453/swank-loader.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank-loader.lisp rename to elpa/slime-20200326.1453/swank-loader.lisp diff --git a/elpa/slime-20200325.1906/swank.asd b/elpa/slime-20200326.1453/swank.asd similarity index 100% rename from elpa/slime-20200325.1906/swank.asd rename to elpa/slime-20200326.1453/swank.asd diff --git a/elpa/slime-20200325.1906/swank.lisp b/elpa/slime-20200326.1453/swank.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank.lisp rename to elpa/slime-20200326.1453/swank.lisp diff --git a/elpa/slime-20200325.1906/swank/abcl.lisp b/elpa/slime-20200326.1453/swank/abcl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/abcl.lisp rename to elpa/slime-20200326.1453/swank/abcl.lisp diff --git a/elpa/slime-20200325.1906/swank/allegro.lisp b/elpa/slime-20200326.1453/swank/allegro.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/allegro.lisp rename to elpa/slime-20200326.1453/swank/allegro.lisp diff --git a/elpa/slime-20200325.1906/swank/backend.lisp b/elpa/slime-20200326.1453/swank/backend.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/backend.lisp rename to elpa/slime-20200326.1453/swank/backend.lisp diff --git a/elpa/slime-20200325.1906/swank/ccl.lisp b/elpa/slime-20200326.1453/swank/ccl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/ccl.lisp rename to elpa/slime-20200326.1453/swank/ccl.lisp diff --git a/elpa/slime-20200325.1906/swank/clasp.lisp b/elpa/slime-20200326.1453/swank/clasp.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/clasp.lisp rename to elpa/slime-20200326.1453/swank/clasp.lisp diff --git a/elpa/slime-20200325.1906/swank/clisp.lisp b/elpa/slime-20200326.1453/swank/clisp.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/clisp.lisp rename to elpa/slime-20200326.1453/swank/clisp.lisp diff --git a/elpa/slime-20200325.1906/swank/cmucl.lisp b/elpa/slime-20200326.1453/swank/cmucl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/cmucl.lisp rename to elpa/slime-20200326.1453/swank/cmucl.lisp diff --git a/elpa/slime-20200325.1906/swank/corman.lisp b/elpa/slime-20200326.1453/swank/corman.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/corman.lisp rename to elpa/slime-20200326.1453/swank/corman.lisp diff --git a/elpa/slime-20200325.1906/swank/ecl.lisp b/elpa/slime-20200326.1453/swank/ecl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/ecl.lisp rename to elpa/slime-20200326.1453/swank/ecl.lisp diff --git a/elpa/slime-20200325.1906/swank/gray.lisp b/elpa/slime-20200326.1453/swank/gray.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/gray.lisp rename to elpa/slime-20200326.1453/swank/gray.lisp diff --git a/elpa/slime-20200325.1906/swank/lispworks.lisp b/elpa/slime-20200326.1453/swank/lispworks.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/lispworks.lisp rename to elpa/slime-20200326.1453/swank/lispworks.lisp diff --git a/elpa/slime-20200325.1906/swank/match.lisp b/elpa/slime-20200326.1453/swank/match.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/match.lisp rename to elpa/slime-20200326.1453/swank/match.lisp diff --git a/elpa/slime-20200325.1906/swank/mezzano.lisp b/elpa/slime-20200326.1453/swank/mezzano.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/mezzano.lisp rename to elpa/slime-20200326.1453/swank/mezzano.lisp diff --git a/elpa/slime-20200325.1906/swank/mkcl.lisp b/elpa/slime-20200326.1453/swank/mkcl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/mkcl.lisp rename to elpa/slime-20200326.1453/swank/mkcl.lisp diff --git a/elpa/slime-20200325.1906/swank/rpc.lisp b/elpa/slime-20200326.1453/swank/rpc.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/rpc.lisp rename to elpa/slime-20200326.1453/swank/rpc.lisp diff --git a/elpa/slime-20200325.1906/swank/sbcl.lisp b/elpa/slime-20200326.1453/swank/sbcl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/sbcl.lisp rename to elpa/slime-20200326.1453/swank/sbcl.lisp diff --git a/elpa/slime-20200325.1906/swank/scl.lisp b/elpa/slime-20200326.1453/swank/scl.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/scl.lisp rename to elpa/slime-20200326.1453/swank/scl.lisp diff --git a/elpa/slime-20200325.1906/swank/source-file-cache.lisp b/elpa/slime-20200326.1453/swank/source-file-cache.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/source-file-cache.lisp rename to elpa/slime-20200326.1453/swank/source-file-cache.lisp diff --git a/elpa/slime-20200325.1906/swank/source-path-parser.lisp b/elpa/slime-20200326.1453/swank/source-path-parser.lisp similarity index 100% rename from elpa/slime-20200325.1906/swank/source-path-parser.lisp rename to elpa/slime-20200326.1453/swank/source-path-parser.lisp diff --git a/elpa/slime-20200325.1906/xref.lisp b/elpa/slime-20200326.1453/xref.lisp similarity index 100% rename from elpa/slime-20200325.1906/xref.lisp rename to elpa/slime-20200326.1453/xref.lisp