[nongnu] elpa/hyperdrive 3edc7cc2ea 05/31: Chore: Begin pcase-let*'s BINDINGS on a new line

[ELPA Syncer]

branch: elpa/hyperdrive
commit 3edc7cc2ead7a070af0c5a0cd3b593a2c8c417dc
Author: Jonas Bernoulli <jonas@bernoul.li>
Commit: Joseph Turner <joseph@ushin.org>

    Chore: Begin pcase-let*'s BINDINGS on a new line
    
    Often this is enough to shorten long lines inside BINDINGS, and tends
    to look much cleaner than having to split long lines within BINDINGS
    or having to live with long lines.  It's not always enough, but even
    in those cases it might help avoiding at least some forced newlines.
---
 hyperdrive-dir.el     |  30 +++++-----
 hyperdrive-history.el |  78 ++++++++++++------------
 hyperdrive-lib.el     | 162 ++++++++++++++++++++++++++------------------------
 hyperdrive-org.el     |  13 ++--
 4 files changed, 148 insertions(+), 135 deletions(-)

diff --git a/hyperdrive-dir.el b/hyperdrive-dir.el
index 51dd426797..ca3f82c5d5 100644
--- a/hyperdrive-dir.el
+++ b/hyperdrive-dir.el
@@ -156,12 +156,13 @@ Columns are suffixed with up/down arrows according to
 
 (defun h/dir-complete-sort ()
   "Return a value for `hyperdrive-directory-sort' selected with completion."
-  (pcase-let* ((read-answer-short t)
-               (choices (mapcar (lambda (field)
-                                  (let ((desc (symbol-name (car field))))
-                                    (list desc (aref desc 0) (format "sort by 
%s" desc))))
-                                h/dir-sort-fields))
-               (column (intern (read-answer "Sort by column: " choices))))
+  (pcase-let*
+      ((read-answer-short t)
+       (choices (mapcar (lambda (field)
+                          (let ((desc (symbol-name (car field))))
+                            (list desc (aref desc 0) (format "sort by %s" 
desc))))
+                        h/dir-sort-fields))
+       (column (intern (read-answer "Sort by column: " choices))))
     (h/dir-toggle-sort-direction column h/directory-sort)))
 
 (defun h/dir-toggle-sort-direction (column sort)
@@ -184,14 +185,15 @@ To be used as the pretty-printer for `ewoc-create'."
 
 (defun h/dir--format-entry (entry)
   "Return ENTRY formatted as a string."
-  (pcase-let* (((cl-struct hyperdrive-entry size mtime) entry)
-               (size (when size
-                       (file-size-human-readable size)))
-               (directoryp (h//entry-directory-p entry))
-               (face (if directoryp 'h/directory 'default))
-               (timestamp (if mtime
-                              (format-time-string h/timestamp-format mtime)
-                            (propertize " " 'display '(space :width 
h/timestamp-width)))))
+  (pcase-let*
+      (((cl-struct hyperdrive-entry size mtime) entry)
+       (size (when size
+               (file-size-human-readable size)))
+       (directoryp (h//entry-directory-p entry))
+       (face (if directoryp 'h/directory 'default))
+       (timestamp (if mtime
+                      (format-time-string h/timestamp-format mtime)
+                    (propertize " " 'display '(space :width 
h/timestamp-width)))))
     (format "%6s  %s  %s"
             (propertize (or size "")
                         'face 'h/size)
diff --git a/hyperdrive-history.el b/hyperdrive-history.el
index f3f9d8ab7d..37db1206c8 100644
--- a/hyperdrive-history.el
+++ b/hyperdrive-history.el
@@ -50,21 +50,22 @@ To be used as the pretty-printer for `ewoc-create'."
 RANGE-ENTRY is a cons cell whose car is a range according to
 `hyperdrive-version-ranges', except that \\+`:existsp' may have the
 value \\+`unknown', and whose cdr is a hyperdrive entry."
-  (pcase-let* ((`(,range . ,entry) range-entry)
-               (`(,range-start . ,(map (:range-end range-end) (:existsp 
existsp))) range)
-               ((cl-struct hyperdrive-entry size mtime) entry)
-               (formatted-range (if (eq range-start range-end)
-                                    (format "%d" range-start)
-                                  (format "%d-%d" range-start range-end)))
-               (exists-marker (format "%7s" (pcase-exhaustive existsp
-                                              ('t "Yes")
-                                              ('nil "No")
-                                              ('unknown "Unknown"))))
-               (size (when size
-                       (file-size-human-readable size)))
-               (timestamp (if mtime
-                              (format-time-string h/timestamp-format mtime)
-                            (propertize " " 'display '(space :width 
h/timestamp-width)))))
+  (pcase-let*
+      ((`(,range . ,entry) range-entry)
+       (`(,range-start . ,(map (:range-end range-end) (:existsp existsp))) 
range)
+       ((cl-struct hyperdrive-entry size mtime) entry)
+       (formatted-range (if (eq range-start range-end)
+                            (format "%d" range-start)
+                          (format "%d-%d" range-start range-end)))
+       (exists-marker (format "%7s" (pcase-exhaustive existsp
+                                      ('t "Yes")
+                                      ('nil "No")
+                                      ('unknown "Unknown"))))
+       (size (when size
+               (file-size-human-readable size)))
+       (timestamp (if mtime
+                      (format-time-string h/timestamp-format mtime)
+                    (propertize " " 'display '(space :width 
h/timestamp-width)))))
     ;; FIXME: Use dynamic width of range column equal to 2N+1, where N
     ;; is the width of the hyperdrive's latest version
     (format "%7s  %19s  %6s  %s"
@@ -165,29 +166,30 @@ prefix argument \\[universal-argument], prompt for ENTRY."
   ;; TODO: Highlight range for ENTRY
   (when (h//entry-directory-p entry)
     (h/user-error "Directory history not implemented"))
-  (pcase-let* (((cl-struct hyperdrive-entry hyperdrive path) entry)
-               (range-entries
-                (mapcar (lambda (range)
-                          ;; Some entries may not exist at `range-start',
-                          ;; as in the version before it was created, see:
-                          ;; (info "(hyperdrive)Versioning")
-                          (cons range
-                                (he/create
-                                 :hyperdrive hyperdrive
-                                 :path path
-                                 ;; Set version to range-start
-                                 :version (car range))))
-                        ;; Display in reverse chronological order
-                        (nreverse (he/version-ranges-no-gaps entry))))
-               (main-header (h//format-entry entry "[%H] %p"))
-               (header (concat main-header "\n"
-                               (format "%7s  %19s  %6s  %s"
-                                       (propertize "Exists" 'face 
'h/column-header)
-                                       (propertize "Drive Version Range" 'face 
'h/column-header)
-                                       (propertize "Size" 'face 
'h/column-header)
-                                       (format (format "%%%ds" 
h/timestamp-width)
-                                               (propertize "Last Modified" 
'face 'h/column-header)))))
-               (queue) (ewoc))
+  (pcase-let*
+      (((cl-struct hyperdrive-entry hyperdrive path) entry)
+       (range-entries
+        (mapcar (lambda (range)
+                  ;; Some entries may not exist at `range-start',
+                  ;; as in the version before it was created, see:
+                  ;; (info "(hyperdrive)Versioning")
+                  (cons range
+                        (he/create
+                         :hyperdrive hyperdrive
+                         :path path
+                         ;; Set version to range-start
+                         :version (car range))))
+                ;; Display in reverse chronological order
+                (nreverse (he/version-ranges-no-gaps entry))))
+       (main-header (h//format-entry entry "[%H] %p"))
+       (header (concat main-header "\n"
+                       (format "%7s  %19s  %6s  %s"
+                               (propertize "Exists" 'face 'h/column-header)
+                               (propertize "Drive Version Range" 'face 
'h/column-header)
+                               (propertize "Size" 'face 'h/column-header)
+                               (format (format "%%%ds" h/timestamp-width)
+                                       (propertize "Last Modified" 'face 
'h/column-header)))))
+       (queue) (ewoc))
     (with-current-buffer (get-buffer-create
                           (format "*Hyperdrive-history: %s*"
                                   (h//format-entry entry "[%H] %p")))
diff --git a/hyperdrive-lib.el b/hyperdrive-lib.el
index 3d8900a17c..f29f3cf50f 100644
--- a/hyperdrive-lib.el
+++ b/hyperdrive-lib.el
@@ -258,31 +258,34 @@ If URL does not begin with \"hyper://\" prefix, it will 
be added
 before making the entry struct."
   (unless (string-prefix-p "hyper://" url)
     (setf url (concat "hyper://" url)))
-  (pcase-let* (((cl-struct url host (filename path) target)
-                (url-generic-parse-url url))
-               ;; TODO: For now, no other function besides `h/url-entry' calls
-               ;; `h/create', but perhaps it would be good to add a function 
which wraps
-               ;; `h/create' and returns either an existing hyperdrive or a 
new one?
-               (hyperdrive (pcase host
-                             ;; FIXME: Duplicate hyperdrive (one has domain 
and nothing else)
-                             ((rx ".") ; Assume host is a DNSLink domain. See 
code for <https://github.com/RangerMauve/hyper-sdk#sdkget>.
-                              (when (and (>= emacs-major-version 29)
-                                         (textsec-suspicious-p host 'domain))
-                                ;; Check DNSLink domains for suspicious 
characters; don't bother
-                                ;; checking public keys since they're not 
recognizable anyway.
-                                (unless (y-or-n-p
-                                        (format "Suspicious domain: %s; 
continue anyway?" host))
-                                  (user-error "Suspicious domain %s" host)))
-                              (h/create :domains (list host)))
-                             (_  ;; Assume host is a public-key
-                              (or (gethash host h/hyperdrives)
-                                  (h/create :public-key host)))))
-               (etc (when target
-                      `((target . ,(substring (url-unhex-string target) 
(length "::"))))))
-               (version (pcase path
-                          ((rx "/$/version/" (let v (1+ num)) (let p (0+ 
anything)))
-                           (setf path p)
-                           (string-to-number v)))))
+  (pcase-let*
+      (((cl-struct url host (filename path) target)
+        (url-generic-parse-url url))
+       ;; TODO: For now, no other function besides `h/url-entry' calls
+       ;; `h/create', but perhaps it would be good to add a function which 
wraps
+       ;; `h/create' and returns either an existing hyperdrive or a new one?
+       (hyperdrive (pcase host
+                     ;; FIXME: Duplicate hyperdrive (one has domain and 
nothing else)
+                     ((rx ".") ; Assume host is a DNSLink domain.
+                      ;; See code for 
<https://github.com/RangerMauve/hyper-sdk#sdkget>.
+                      (when (and (>= emacs-major-version 29)
+                                 (textsec-suspicious-p host 'domain))
+                        ;; Check DNSLink domains for suspicious characters;
+                        ;; don't bother checking public keys since they're
+                        ;; not recognizable anyway.
+                        (unless (y-or-n-p
+                                 (format "Suspicious domain: %s; continue 
anyway?" host))
+                          (user-error "Suspicious domain %s" host)))
+                      (h/create :domains (list host)))
+                     (_  ;; Assume host is a public-key
+                      (or (gethash host h/hyperdrives)
+                          (h/create :public-key host)))))
+       (etc (when target
+              `((target . ,(substring (url-unhex-string target) (length 
"::"))))))
+       (version (pcase path
+                  ((rx "/$/version/" (let v (1+ num)) (let p (0+ anything)))
+                   (setf path p)
+                   (string-to-number v)))))
     ;; e.g. for hyper://PUBLIC-KEY/path/to/basename, we do:
     ;; :path "/path/to/basename" :name "basename"
     (he/create :hyperdrive hyperdrive :path (url-unhex-string path)
@@ -330,9 +333,10 @@ Returns nil when ENTRY is not known to exist at its 
version.
 
 With non-nil VERSION, use it instead of ENTRY's version."
   (declare (indent defun))
-  (pcase-let* (((cl-struct hyperdrive-entry hyperdrive (version 
entry-version)) entry)
-               (version (or version entry-version (h/latest-version 
hyperdrive)))
-               (ranges (he/version-ranges entry)))
+  (pcase-let*
+      (((cl-struct hyperdrive-entry hyperdrive (version entry-version)) entry)
+       (version (or version entry-version (h/latest-version hyperdrive)))
+       (ranges (he/version-ranges entry)))
     (when ranges
       (cl-find-if (pcase-lambda (`(,range-start . ,(map (:range-end 
range-end))))
                     (<= range-start version range-end))
@@ -634,15 +638,16 @@ The following ENTRY hyperdrive slots are filled:
 - \\+`domains' (merged with current persisted value)
 
 Returns filled ENTRY."
-  (pcase-let* (((cl-struct hyperdrive-entry hyperdrive) entry)
-               ((cl-struct hyperdrive writablep domains) hyperdrive)
-               ((map link content-length content-type etag last-modified 
allow) headers)
-               ;; If URL hostname was a DNSLink domain, entry doesn't yet have 
a public-key slot.
-               (public-key (progn
-                             (string-match h//public-key-re link)
-                             (match-string 1 link)))
-               (persisted-hyperdrive (gethash public-key h/hyperdrives))
-               (domain (car domains)))
+  (pcase-let*
+      (((cl-struct hyperdrive-entry hyperdrive) entry)
+       ((cl-struct hyperdrive writablep domains) hyperdrive)
+       ((map link content-length content-type etag last-modified allow) 
headers)
+       ;; If URL hostname was a DNSLink domain,
+       ;; entry doesn't yet have a public-key slot.
+       (public-key (progn (string-match h//public-key-re link)
+                          (match-string 1 link)))
+       (persisted-hyperdrive (gethash public-key h/hyperdrives))
+       (domain (car domains)))
     (when last-modified
       (setf last-modified (encode-time (parse-time-string last-modified))))
     (when (and allow (eq 'unknown writablep))
@@ -741,23 +746,24 @@ Returns the ranges cons cell for ENTRY."
               (he/version-range entry)
               ;; Don't store ranges for entries which have never existed.
               (not (he/version-ranges entry)))
-    (pcase-let* ((ranges (he/version-ranges entry))
-                 ((cl-struct hyperdrive-entry hyperdrive path version) entry)
-                 (version (or version (h/latest-version hyperdrive)))
-                 (previous-range (he/version-range
-                                   (he/create :hyperdrive hyperdrive :path 
path :version (1- version))))
-                 (`(,previous-range-start . ,(map (:existsp 
previous-exists-p))) previous-range)
-                 (next-range (he/version-range
-                               (he/create :hyperdrive hyperdrive :path path 
:version (1+ version))))
-                 (`(,next-range-start . ,(map (:existsp next-exists-p) 
(:range-end next-range-end))) next-range)
-                 (range-start (if (and previous-range (null previous-exists-p))
-                                  ;; Extend previous nonexistent range
-                                  previous-range-start
-                                version))
-                 (range-end (if (and next-range (null next-exists-p))
-                                ;; Extend next nonexistent range
-                                next-range-end
-                              version)))
+    (pcase-let*
+        ((ranges (he/version-ranges entry))
+         ((cl-struct hyperdrive-entry hyperdrive path version) entry)
+         (version (or version (h/latest-version hyperdrive)))
+         (previous-range (he/version-range
+                           (he/create :hyperdrive hyperdrive :path path 
:version (1- version))))
+         (`(,previous-range-start . ,(map (:existsp previous-exists-p))) 
previous-range)
+         (next-range (he/version-range
+                       (he/create :hyperdrive hyperdrive :path path :version 
(1+ version))))
+         (`(,next-range-start . ,(map (:existsp next-exists-p) (:range-end 
next-range-end))) next-range)
+         (range-start (if (and previous-range (null previous-exists-p))
+                          ;; Extend previous nonexistent range
+                          previous-range-start
+                        version))
+         (range-end (if (and next-range (null next-exists-p))
+                        ;; Extend next nonexistent range
+                        next-range-end
+                      version)))
       ;; Delete next range if it's contiguous with current range.
       (when (and next-range (null next-exists-p))
         (setf ranges (map-delete ranges next-range-start)))
@@ -867,26 +873,27 @@ Once all requests return, call FINALLY with no arguments."
 Sends a synchronous request to get the latest contents of
 HYPERDRIVE's public metadata file."
   (declare (indent defun))
-  (pcase-let* ((entry (he/create
-                       :hyperdrive hyperdrive
-                       :path "/.well-known/host-meta.json"
-                       ;; NOTE: Don't attempt to fill hyperdrive struct with 
old metadata
-                       :version nil))
-               (metadata (condition-case err
-                             (h/api 'get (he/url entry)
-                               :as (lambda ()
-                                     (condition-case err
-                                         (json-read)
-                                       (json-error
-                                        (h/message "Error parsing JSON 
metadata file: %s"
-                                                   (he/url entry)))
-                                       (_ (signal (car err) (cdr err)))))
-                               :noquery t)
-                           (plz-error
-                            (pcase (plz-response-status (plz-error-response 
(caddr err)))
-                              ;; FIXME: If plz-error is a curl-error, this 
block will fail.
-                              (404 nil)
-                              (_ (signal (car err) (cdr err))))))))
+  (pcase-let*
+      ((entry (he/create
+               :hyperdrive hyperdrive
+               :path "/.well-known/host-meta.json"
+               ;; NOTE: Don't attempt to fill hyperdrive struct with old 
metadata
+               :version nil))
+       (metadata (condition-case err
+                     (h/api 'get (he/url entry)
+                       :as (lambda ()
+                             (condition-case err
+                                 (json-read)
+                               (json-error
+                                (h/message "Error parsing JSON metadata file: 
%s"
+                                           (he/url entry)))
+                               (_ (signal (car err) (cdr err)))))
+                       :noquery t)
+                   (plz-error
+                    (pcase (plz-response-status (plz-error-response (caddr 
err)))
+                      ;; FIXME: If plz-error is a curl-error, this block will 
fail.
+                      (404 nil)
+                      (_ (signal (car err) (cdr err))))))))
     (setf (h/metadata hyperdrive) metadata)
     (h/persist hyperdrive)
     hyperdrive))
@@ -1249,9 +1256,10 @@ If then, then call THEN with no arguments.  Default 
handler."
   (h/api 'get (he/url entry)
     :noquery t
     :as (lambda ()
-          (pcase-let* (((cl-struct hyperdrive-entry hyperdrive version etc) 
entry)
-                       ((map target) etc)
-                       (response-buffer (current-buffer)))
+          (pcase-let*
+              (((cl-struct hyperdrive-entry hyperdrive version etc) entry)
+               ((map target) etc)
+               (response-buffer (current-buffer)))
             (with-current-buffer (h//get-buffer-create entry)
               ;; TODO: Don't reload if we're jumping to a link on the
               ;; same page (but ensure that reverting still works).
diff --git a/hyperdrive-org.el b/hyperdrive-org.el
index 73ec0e62c1..c5a2efe4c2 100644
--- a/hyperdrive-org.el
+++ b/hyperdrive-org.el
@@ -145,12 +145,13 @@ the logic for handling links of \"file\" type."
                ;; Don't treat link as a relative/absolute path in the
                ;; hyperdrive if "file:" protocol prefix is explicit.
                (not (string-prefix-p "file:" raw-link-type)))
-      (pcase-let* (((cl-struct hyperdrive-entry hyperdrive path) 
h/current-entry)
-                   (entry (he/create
-                           :hyperdrive hyperdrive
-                           :path (expand-file-name (org-element-property :path 
context)
-                                                   (file-name-directory path))
-                           :etc `((target . ,(org-element-property 
:search-option context))))))
+      (pcase-let*
+          (((cl-struct hyperdrive-entry hyperdrive path) h/current-entry)
+           (entry (he/create
+                   :hyperdrive hyperdrive
+                   :path (expand-file-name (org-element-property :path context)
+                                           (file-name-directory path))
+                   :etc `((target . ,(org-element-property :search-option 
context))))))
         entry))))
 
 (defun h/org--insert-link-after-advice (&rest _)