.drone.yml

@@ -1,77 +0,0 @@
-kind: pipeline
-name: Lint package
-
-volumes:
-- name: debian-package-cache
-  host:
-    path: /var/cache/debian-package-cache
-
-trigger:
-  event:
-    exclude:
-    - tag
-
-steps:
-- name: Emacs 26.3
-  image: flycheck/emacs-cask:26.3
-  pull: always
-  environment:
-    DEBIAN_FRONTEND: noninteractive
-    LANG: en_US.UTF-8
-  commands:
-  - rm /etc/apt/apt.conf.d/docker-clean
-  - alias apt-get='rm -f /var/cache/apt/archives/lock && apt-get'
-  - apt-get update -q
-  - apt-get install -qq language-pack-en git aspell-en
-  - ./makem.sh --verbose --sandbox --install-deps --install-linters lint
-  volumes:
-  - name: debian-package-cache
-    path: /var/cache/apt/archives
-
-- name: Emacs master-branch
-  image: flycheck/emacs-cask:master
-  pull: always
-  environment:
-    DEBIAN_FRONTEND: noninteractive
-    LANG: en_US.UTF-8
-  commands:
-  - rm /etc/apt/apt.conf.d/docker-clean
-  - alias apt-get='rm -f /var/cache/apt/archives/lock && apt-get'
-  - apt-get update -q
-  - apt-get install -qq language-pack-en git aspell-en
-  - emacs --version
-  - ./makem.sh --verbose --sandbox --install-deps --install-linters lint
-  volumes:
-  - name: debian-package-cache
-    path: /var/cache/apt/archives
-
-- name: Emacs 25.3
-  image: flycheck/emacs-cask:25.3
-  pull: always
-  environment:
-    DEBIAN_FRONTEND: noninteractive
-    LANG: C
-  commands:
-  - rm /etc/apt/apt.conf.d/docker-clean
-  - alias apt-get='rm -f /var/cache/apt/archives/lock && apt-get'
-  - apt-get update -q
-  - apt-get install -qq git
-  # Some package or its dependency requires Emacs 26.1,
-  # so we just check if it compiles.
-  - ./makem.sh --verbose --sandbox compile
-  volumes:
-  - name: debian-package-cache
-    path: /var/cache/apt/archives
-
-- name: notify
-  image: drillster/drone-email
-  pull: always
-  settings:
-    host: cryptoparty-celle.de
-    from: drone@tzend.de
-    username:
-      from_secret: email_username
-    password:
-      from_secret: email_password
-  when:
-    status: [ changed, failure ]

.gitignore

@@ -1,2 +1,2 @@
+/flycheck*.el*
 *~
-*.elc

README.md

@@ -1,65 +1,55 @@
 # register-quicknav - Quickly jump to next/previous register
 
 *Author:* tastytea <tastytea@tastytea.de><br>
-*Version:* 0.4.3<br>
+*Version:* 0.1.2<br>
 *URL:* [https://schlomp.space/tastytea/register-quicknav](https://schlomp.space/tastytea/register-quicknav)<br>
 
 This package is built on top of `register.el` and allows you to quickly jump
 to the next/previous position register.  If you reach the end, the search
-wraps around and continues with the first (or last) register.  It can be used
-across all files or individually for each buffer.
+wraps around and continues with the first (or last) register.
 
 ## Features
 
 * Cycle through all position registers in both directions.
 * Clear current register.
-* Store point in unused register (range configurable).
-* Clear all registers in the unused registers range.
+
+## Known limitations
+
+Works only for as long as the buffer containing the registers is open.  If
+you close and reopen it, it won't work anymore.
 
 ## Installation
 
-To use `register-quicknav.el`, get it from
-[MELPA](https://melpa.org/#/register-quicknav) or put it in your load-path
-and add the following to your init.el:
+**Note:** The function and variable names were previously separated by “/”
+from the namespace.  To conform with MELPA rules the separator has been
+changed to “-”.
+
+To use `register-quicknav.el`, put it in your load-path and add the following
+to your init.el:
 
     (require 'register-quicknav)
     (global-set-key (kbd "<C-f5>") #'register-quicknav-prev-register)
     (global-set-key (kbd "<C-f6>") #'register-quicknav-next-register)
-    (global-set-key (kbd "<C-f7>") #'register-quicknav-point-to-unused-register)
-    (global-set-key (kbd "<C-S-<f7>") #'register-quicknav-clear-current-register)
+    (global-set-key (kbd "M-r")    #'register-quicknav-clear-current-register)
 
 Or, with use-package:
 
     (use-package register-quicknav
-      :bind (("C-<f5>"   . register-quicknav-prev-register)
-             ("C-<f6>"   . register-quicknav-next-register)
-             ("C-<f7>"   . register-quicknav-point-to-unused-register)
-             ("C-S-<f7>" . register-quicknav-clear-current-register)))
+      :bind (("C-<f5>" . register-quicknav-prev-register)
+             ("C-<f6>" . register-quicknav-next-register)
+             ("M-r"    . register-quicknav-clear-current-register)))
+
+Instead of manually copying `register-quicknav.el` into your load-path, you
+can use [quelpa](https://github.com/quelpa/quelpa):
+
+    (quelpa '(register-quicknav
+              :fetcher git
+              :url "https://schlomp.space/tastytea/register-quicknav.git"))
 
 ## Variables
 
 * `register-quicknav-buffer-only`: Cycle only through position registers in
-  current buffer.  Can be safely set as file- and/or dir-local variable.
-* `register-quicknav-unused-registers-begin`: Beginning of the range that is
-  used to search for unused registers.  Defaults to `?A`.
-* `register-quicknav-unused-registers-end`: End of the range that is used to
-  search for unused registers.  Defaults to `?Z`.
-
-## Differences to similar packages
-
-[iregister](https://github.com/atykhonov/iregister.el):
-
-* Opens a minibuffer on each jump (thereby requiring an extra keystroke).
-* Doesn't work with file-query registers
-* Can't be restricted to the current buffer.
-* Doesn't look like it's still maintained.
-
-[register-channel](https://github.com/YangZhao11/register-channel):
-
-* Is limited to 5 position registers by default, needs an extra keybinding
-  for each additional register.
-* Can't be restricted to the current buffer.
-* Has no ability to jump to the next/previous register.
+  current buffer.
 
 
 ---

register-quicknav.el

@@ -3,8 +3,8 @@
 ;; Copyright (C) 2020  tastytea
 
 ;; Author: tastytea <tastytea@tastytea.de>
-;; Version: 0.4.3
-;; Package-Requires: ((emacs "25.3"))
+;; Version: 0.1.2
+;; Package-Requires: ((emacs "24"))
 ;; Keywords: convenience
 ;; URL: https://schlomp.space/tastytea/register-quicknav
 
@@ -25,231 +25,131 @@
 
 ;; This package is built on top of `register.el' and allows you to quickly jump
 ;; to the next/previous position register.  If you reach the end, the search
-;; wraps around and continues with the first (or last) register.  It can be used
-;; across all files or individually for each buffer.
+;; wraps around and continues with the first (or last) register.
 
 ;; Features:
 ;;
 ;; * Cycle through all position registers in both directions.
 ;; * Clear current register.
-;; * Store point in unused register (range configurable).
-;; * Clear all registers in the unused registers range.
+
+;; Known limitations:
+;;
+;; Works only for as long as the buffer containing the registers is open.  If
+;; you close and reopen it, it won't work anymore.
 
 ;; Installation:
 ;;
-;; To use `register-quicknav.el', get it from
-;; [MELPA](https://melpa.org/#/register-quicknav) or put it in your load-path
-;; and add the following to your init.el:
+;; **Note:** The function and variable names were previously separated by “/”
+;; from the namespace.  To conform with MELPA rules the separator has been
+;; changed to “-”.
+;;
+;; To use `register-quicknav.el', put it in your load-path and add the following
+;; to your init.el:
 ;;
 ;; (require 'register-quicknav)
 ;; (global-set-key (kbd "<C-f5>") #'register-quicknav-prev-register)
 ;; (global-set-key (kbd "<C-f6>") #'register-quicknav-next-register)
-;; (global-set-key (kbd "<C-f7>") #'register-quicknav-point-to-unused-register)
-;; (global-set-key (kbd "<C-S-<f7>") #'register-quicknav-clear-current-register)
+;; (global-set-key (kbd "M-r")    #'register-quicknav-clear-current-register)
 ;;
 ;; Or, with use-package:
 ;;
 ;; (use-package register-quicknav
-;;   :bind (("C-<f5>"   . register-quicknav-prev-register)
-;;          ("C-<f6>"   . register-quicknav-next-register)
-;;          ("C-<f7>"   . register-quicknav-point-to-unused-register)
-;;          ("C-S-<f7>" . register-quicknav-clear-current-register)))
+;;   :bind (("C-<f5>" . register-quicknav-prev-register)
+;;          ("C-<f6>" . register-quicknav-next-register)
+;;          ("M-r"    . register-quicknav-clear-current-register)))
+;;
+;; Instead of manually copying `register-quicknav.el' into your load-path, you
+;; can use [quelpa](https://github.com/quelpa/quelpa):
+;;
+;; (quelpa '(register-quicknav
+;;           :fetcher git
+;;           :url "https://schlomp.space/tastytea/register-quicknav.git"))
 
 ;; Variables:
 ;;
 ;; * `register-quicknav-buffer-only': Cycle only through position registers in
-;;   current buffer.  Can be safely set as file- and/or dir-local variable.
-;; * `register-quicknav-unused-registers-begin': Beginning of the range that is
-;;   used to search for unused registers.  Defaults to `?A'.
-;; * `register-quicknav-unused-registers-end': End of the range that is used to
-;;   search for unused registers.  Defaults to `?Z'.
-
-;; Differences to similar packages:
-;;
-;; [iregister](https://github.com/atykhonov/iregister.el):
-;;
-;; * Opens a minibuffer on each jump (thereby requiring an extra keystroke).
-;; * Doesn't work with file-query registers
-;; * Can't be restricted to the current buffer.
-;; * Doesn't look like it's still maintained.
-;;
-;; [register-channel](https://github.com/YangZhao11/register-channel):
-;;
-;; * Is limited to 5 position registers by default, needs an extra keybinding
-;;   for each additional register.
-;; * Can't be restricted to the current buffer.
-;; * Has no ability to jump to the next/previous register.
+;;   current buffer.
 
 ;;; Code:
 
-(require 'cl-lib)
+(define-obsolete-variable-alias 'register-quicknav/buffer-only
+  'register-quicknav-buffer-only "0.1.1")
+(define-obsolete-function-alias 'register-quicknav/next-register
+  #'register-quicknav-next-register "0.1.1")
+(define-obsolete-function-alias 'register-quicknav/prev-register
+  #'register-quicknav-prev-register "0.1.1")
+(define-obsolete-function-alias 'register-quicknav/clear-current-register
+  #'register-quicknav-clear-current-register "0.1.1")
 
 (defgroup register-quicknav nil
   "Variables for register-quicknav."
   :group 'editing)
 
-;;;###autoload
 (defcustom register-quicknav-buffer-only nil
   "Cycle only through position registers in current buffer."
   :type 'boolean
-  :group 'register-quicknav
-  :safe #'booleanp)
-
-(defcustom register-quicknav-unused-registers-begin ?A
-  "Begin looking for unused register at this register."
-  :type 'character
   :group 'register-quicknav)
 
-(defcustom register-quicknav-unused-registers-end ?Z
-  "End looking for unused register at this register."
-  :type 'character
-  :group 'register-quicknav)
+(defvar register-quicknav--current-position-register 0
+  "An index to the current position register.")
 
-(defvar register-quicknav--last-register-v nil
-  "The last jumped-to position register.")
-
-(defun register-quicknav--last-register (&optional val)
-  "Return `register-quicknav--last-register-v' or set it if VAL is non-nil.
-Use the local value if `register-quicknav-buffer-only' is set and
-the global value otherwise."
-  (if val
-      (if register-quicknav-buffer-only
-          (setq register-quicknav--last-register-v val)
-        (setq-default register-quicknav--last-register-v val))
-    (if register-quicknav-buffer-only
-        register-quicknav--last-register-v
-      (default-value 'register-quicknav--last-register-v))))
-
-(defun register-quicknav--file-name (register)
-  "Return file-name of REGISTER.
-Works on markers and file-queries."
-  (if (markerp (cdr register))
-      (buffer-file-name (marker-buffer (cdr register)))
-    (nth 2 register)))
-
-(defun register-quicknav--is-current-buffer? (register)
-  "Return t if REGISTER is in current buffer.
-Works on markers and file-queries."
-  (if (markerp (cdr register))
-      (eq (current-buffer) (marker-buffer (cdr register)))
-    (string= (buffer-file-name (current-buffer))
-             (register-quicknav--file-name register))))
-
-(defun register-quicknav--position (register)
-  "Return position of REGISTER.
-Works on markers and file-queries."
-  (if (markerp (cdr register))
-      (marker-position (cdr register))
-    (nth 3 register)))
+(defun register-quicknav--sort-position-register-elements (a b)
+  "Return t if the file name is the same and A < B."
+  (let ((marker-a (cdr a))
+        (marker-b (cdr b)))
+    (and (string= (buffer-file-name (marker-buffer marker-a))
+                  (buffer-file-name (marker-buffer marker-b)))
+         (< (marker-position marker-a)
+            (marker-position marker-b)))))
 
 (defun register-quicknav--registers ()
   "Return all position registers, sorted by file name and position.
 If `register-quicknav-buffer-only' is t, return only registers in
 current buffer."
-  (cl-flet ((sort-registers
-             (lambda (a b)
-               "Return t if position of A is < B.
-Works on markers and file-queries."
-               (and (string= (register-quicknav--file-name a)
-                             (register-quicknav--file-name b))
-                    (< (register-quicknav--position a)
-                       (register-quicknav--position b))))))
-    (let ((result))
-      (dolist (register register-alist)
-        (if (or (markerp (cdr register))
-                (ignore-errors (eq (nth 1 register) 'file-query)))
-            (if register-quicknav-buffer-only
-                (when (register-quicknav--is-current-buffer? register)
-                  (push register result))
-              (push register result))))
-      (sort result #'sort-registers))))
-
-(defun register-quicknav--jump-to-register (next)
-  "Jump to next position register if NEXT is t, to previous otherwise."
-  (let* ((register-list (register-quicknav--registers))
-         (index (cl-position (register-quicknav--last-register) register-list))
-         (stop-searching))
-    (when index
-      (if next
-          (cl-incf index)
-        (cl-decf index)))
-    ;; Try to find the position register closest to point.
-    (dolist (register register-list)
-      (when (register-quicknav--is-current-buffer? register)
-        (let ((register-pos (register-quicknav--position register)))
-          (if next
-              (when (and (not stop-searching)
-                         (> register-pos (point)))
-                (setq index (cl-position register register-list)
-                      stop-searching t))
-            (when (< register-pos (point))
-              (setq index (cl-position register register-list)))))))
-    (if index
-        (progn          ; If index is invalid, set it to first or last register.
-          (when (or (>= index (length register-list))
-                    (< index 0))
-            (if next
-                (setq index 0)
-              (setq index (- (length register-list) 1))))
-          (register-to-point (car (nth index register-list)))
-          (register-quicknav--last-register (nth index register-list)))
-      ;; No suitable register found, jump to first register.
-      (register-to-point (car (car register-list)))
-      (register-quicknav--last-register (car register-list)))))
+  (let (result)
+    (dolist (item register-alist)
+      (when (markerp (cdr item))
+        (if register-quicknav-buffer-only
+            (when (eq (current-buffer) (marker-buffer (cdr item)))
+              (setq result (cons item result)))
+          (setq result (cons item result)))))
+    (sort result #'register-quicknav--sort-position-register-elements)))
 
 ;;;###autoload
 (defun register-quicknav-next-register ()
   "Jump to next position register."
   (interactive)
-  (register-quicknav--jump-to-register t))
+  (let ((pos register-quicknav--current-position-register)
+        (registers (register-quicknav--registers)))
+    (setq pos (+ pos 1))
+    (when (>= pos (length registers))
+      (setq pos 0))
+    (setq register-quicknav--current-position-register pos)
+    (register-to-point (car (nth pos registers)))))
 
 ;;;###autoload
 (defun register-quicknav-prev-register ()
   "Jump to previous position register."
   (interactive)
-  (register-quicknav--jump-to-register nil))
+  (let ((pos register-quicknav--current-position-register)
+        (registers (register-quicknav--registers)))
+    (setq pos (- pos 1))
+    (when (< pos 0)
+      (setq pos (- (length registers) 1)))
+    (setq register-quicknav--current-position-register pos)
+    (register-to-point (car (nth pos registers)))))
 
 ;;;###autoload
 (defun register-quicknav-clear-current-register ()
-  "Clear last jumped-to position register from `register-alist'.
-Deletes the value of `register-quicknav--last-register' from `register-alist'."
+  "Clear currently selected position register.
+To be more precise, it deletes the
+`register-quicknav--current-position-register'th position
+register, as reported by `register-quicknav--registers', from
+`register-alist'."
   (interactive)
-  (setq register-alist
-        (delq (register-quicknav--last-register) register-alist))
-  (message "Cleared register %c." (car (register-quicknav--last-register))))
-
-;;;###autoload
-(defun register-quicknav-point-to-unused-register ()
-  "Store current location of point in next unused register.
-Searches the range between
-`register-quicknav-unused-registers-begin' and
-`register-quicknav-unused-registers-end'."
-  (interactive)
-  (let* ((begin register-quicknav-unused-registers-begin)
-         (end register-quicknav-unused-registers-end)
-         (char begin))
-    (while (and (get-register char)
-                (not (> char end)))
-      (cl-incf char))
-    (if (<= char end)
-        (progn
-          (point-to-register char)
-          (register-quicknav--last-register (assoc char register-alist))
-          (message "Position stored in register %c." char))
-      (message "No unused register in the range %c - %c found." begin end))))
-
-;;;###autoload
-(defun register-quicknav-clear-unused-registers-range ()
-  "Clear all registers in the range used by `register-quicknav-point-to-unused-register'."
-  (interactive)
-  (let ((begin register-quicknav-unused-registers-begin)
-        (end register-quicknav-unused-registers-end))
-    (dolist (register register-alist)
-      (when (and (>= (car register) begin)
-                 (<= (car register) end))
-        (setq register-alist
-              (delq register register-alist))))
-    (message "Cleared unused registers in the range %c - %c." begin end)))
+  (let ((pos register-quicknav--current-position-register)
+        (registers (register-quicknav--registers)))
+    (setq register-alist (delq (nth pos registers) register-alist))))
 
 (provide 'register-quicknav)
 ;;; register-quicknav.el ends here