branch: elpa/magit
commit 28f30e14036f567640f1cbfca94a67e5e2013303
Author: Jonas Bernoulli <[email protected]>
Commit: Jonas Bernoulli <[email protected]>
Use cond-let and cond-let*
I've only recently implemented these forms, but before that I have
been hoping they would be added to Emacs for a decade or so. Even
so, I do not yet have any practice using them, and so my sense of
when to use them, and when not, has yet to evolve.
---
lisp/git-commit.el | 20 ++---
lisp/git-rebase.el | 26 +++---
lisp/magit-base.el | 26 +++---
lisp/magit-blame.el | 16 ++--
lisp/magit-branch.el | 100 ++++++++++-----------
lisp/magit-diff.el | 228 +++++++++++++++++++++++-------------------------
lisp/magit-extras.el | 104 +++++++++++-----------
lisp/magit-git.el | 225 +++++++++++++++++++++++------------------------
lisp/magit-log.el | 36 +++-----
lisp/magit-merge.el | 30 +++----
lisp/magit-mode.el | 100 ++++++++++-----------
lisp/magit-refs.el | 26 +++---
lisp/magit-section.el | 67 +++++++-------
lisp/magit-submodule.el | 15 ++--
lisp/magit-transient.el | 54 ++++++------
lisp/magit-wip.el | 85 +++++++++---------
16 files changed, 573 insertions(+), 585 deletions(-)
diff --git a/lisp/git-commit.el b/lisp/git-commit.el
index b0770588713..0bcad3d3473 100644
--- a/lisp/git-commit.el
+++ b/lisp/git-commit.el
@@ -796,16 +796,16 @@ Save current message first."
(defun git-commit-save-message ()
"Save current message to `log-edit-comment-ring'."
(interactive)
- (if-let ((message (git-commit-buffer-message)))
- (progn
- (when-let ((index (ring-member log-edit-comment-ring message)))
- (ring-remove log-edit-comment-ring index))
- (ring-insert log-edit-comment-ring message)
- (when git-commit-use-local-message-ring
- (magit-repository-local-set 'log-edit-comment-ring
- log-edit-comment-ring))
- (message "Message saved"))
- (message "Only whitespace and/or comments; message not saved")))
+ (cond-let
+ ([message (git-commit-buffer-message)]
+ (when-let ((index (ring-member log-edit-comment-ring message)))
+ (ring-remove log-edit-comment-ring index))
+ (ring-insert log-edit-comment-ring message)
+ (when git-commit-use-local-message-ring
+ (magit-repository-local-set 'log-edit-comment-ring
+ log-edit-comment-ring))
+ (message "Message saved"))
+ ((message "Only whitespace and/or comments; message not saved"))))
(defun git-commit-prepare-message-ring ()
(make-local-variable 'log-edit-comment-ring-index)
diff --git a/lisp/git-rebase.el b/lisp/git-rebase.el
index dc7c6d0ed93..a2c89be5c44 100644
--- a/lisp/git-rebase.el
+++ b/lisp/git-rebase.el
@@ -362,15 +362,15 @@ BATCH is non-nil, in which case nil is returned. Non-nil
BATCH also ignores commented lines."
(save-excursion
(goto-char (line-beginning-position))
- (if-let* ((re-start (if batch
- "^"
- (format "^\\(?99:%s\\)? *"
- (regexp-quote comment-start))))
- (type (seq-some (pcase-lambda (`(,type . ,re))
- (let ((case-fold-search nil))
- (and (looking-at (concat re-start re))
type)))
- git-rebase-line-regexps)))
- (git-rebase-action
+ (cond-let*
+ ([re-start (if batch
+ "^"
+ (format "^\\(?99:%s\\)? *" (regexp-quote comment-start)))]
+ [type (seq-some (pcase-lambda (`(,type . ,re))
+ (let ((case-fold-search nil))
+ (and (looking-at (concat re-start re)) type)))
+ git-rebase-line-regexps)]
+ (git-rebase-action
:action-type type
:action (and-let ((action (match-str 1)))
(or (cdr (assoc action git-rebase-short-options))
@@ -378,10 +378,10 @@ BATCH also ignores commented lines."
:action-options (match-str 2)
:target (match-str 3)
:trailer (match-str 5)
- :comment-p (and (match-str 99) t))
- (and (not batch)
- ;; Use empty object rather than nil to ease handling.
- (git-rebase-action)))))
+ :comment-p (and (match-str 99) t)))
+ ((not batch)
+ ;; Use empty object rather than nil to ease handling.
+ (git-rebase-action)))))
(defun git-rebase-set-action (action)
"Set action of commit line to ACTION.
diff --git a/lisp/magit-base.el b/lisp/magit-base.el
index 7e5a69b9b53..85907f76808 100644
--- a/lisp/magit-base.el
+++ b/lisp/magit-base.el
@@ -1159,19 +1159,19 @@ Like `message', except that `message-log-max' is bound
to nil."
(defun magit--ellipsis (&optional where)
"Build an ellipsis always as string, depending on WHERE."
- (if (stringp magit-ellipsis)
- magit-ellipsis
- (if-let ((pair (car (or
- (alist-get (or where t) magit-ellipsis)
- (alist-get t magit-ellipsis)))))
- (pcase-let* ((`(,fancy . ,universal) pair)
- (ellipsis (if (and fancy (char-displayable-p fancy))
- fancy
- universal)))
- (if (characterp ellipsis)
- (char-to-string ellipsis)
- ellipsis))
- (user-error "Variable magit-ellipsis is invalid"))))
+ (cond-let
+ ((stringp magit-ellipsis)
+ magit-ellipsis)
+ ([pair (car (or (alist-get (or where t) magit-ellipsis)
+ (alist-get t magit-ellipsis)))]
+ (pcase-let* ((`(,fancy . ,universal) pair)
+ (ellipsis (if (and fancy (char-displayable-p fancy))
+ fancy
+ universal)))
+ (if (characterp ellipsis)
+ (char-to-string ellipsis)
+ ellipsis)))
+ ((user-error "Variable magit-ellipsis is invalid"))))
(defun magit--ext-regexp-quote (string)
"Like `reqexp-quote', but for Extended Regular Expressions."
diff --git a/lisp/magit-blame.el b/lisp/magit-blame.el
index 1e5f340cd05..084bae163ed 100644
--- a/lisp/magit-blame.el
+++ b/lisp/magit-blame.el
@@ -747,14 +747,14 @@ modes is toggled, then this mode also gets toggled
automatically.
(delete-overlay ov)))))
(defun magit-blame-maybe-show-message ()
- (when (magit-blame--style-get 'show-message)
- (if-let ((msg (cdr (assoc "summary"
- (gethash (oref (magit-current-blame-chunk)
- orig-rev)
- magit-blame-cache)))))
- (progn (set-text-properties 0 (length msg) nil msg)
- (magit-msg "%S" msg))
- (magit-msg "Commit data not available yet. Still blaming."))))
+ (cond-let
+ ((not (magit-blame--style-get 'show-message)))
+ ([msg (cdr (assoc "summary"
+ (gethash (oref (magit-current-blame-chunk) orig-rev)
+ magit-blame-cache)))]
+ (set-text-properties 0 (length msg) nil msg)
+ (magit-msg "%S" msg))
+ ((magit-msg "Commit data not available yet. Still blaming."))))
;;; Commands
diff --git a/lisp/magit-branch.el b/lisp/magit-branch.el
index 641545515de..3b2b40f9cda 100644
--- a/lisp/magit-branch.el
+++ b/lisp/magit-branch.el
@@ -496,37 +496,38 @@ from the source branch's upstream, then an error is
raised."
(magit-anything-modified-p))
(message "Staying on HEAD due to uncommitted changes")
(setq checkout t))
- (if-let ((current (magit-get-current-branch)))
- (let ((tracked (magit-get-upstream-branch current))
- base)
- (when from
- (unless (magit-rev-ancestor-p from current)
- (user-error "Cannot spin off %s. %s is not reachable from %s"
- branch from current))
- (when (and tracked
- (magit-rev-ancestor-p from tracked))
- (user-error "Cannot spin off %s. %s is ancestor of upstream %s"
- branch from tracked)))
- (let ((magit-process-raise-error t))
- (if checkout
- (magit-call-git "checkout" "-b" branch current)
- (magit-call-git "branch" branch current)))
- (when-let ((upstream (magit-get-indirect-upstream-branch current)))
- (magit-call-git "branch" "--set-upstream-to" upstream branch))
- (when (and tracked
- (setq base
- (if from
- (concat from "^")
- (magit-git-string "merge-base" current tracked)))
- (not (magit-rev-eq base current)))
- (if checkout
- (magit-call-git "update-ref" "-m"
- (format "reset: moving to %s" base)
- (concat "refs/heads/" current) base)
- (magit-call-git "reset" "--hard" base))))
- (if checkout
- (magit-call-git "checkout" "-b" branch)
- (magit-call-git "branch" branch)))
+ (cond-let
+ ([current (magit-get-current-branch)]
+ (let ((tracked (magit-get-upstream-branch current))
+ base)
+ (when from
+ (unless (magit-rev-ancestor-p from current)
+ (user-error "Cannot spin off %s. %s is not reachable from %s"
+ branch from current))
+ (when (and tracked
+ (magit-rev-ancestor-p from tracked))
+ (user-error "Cannot spin off %s. %s is ancestor of upstream %s"
+ branch from tracked)))
+ (let ((magit-process-raise-error t))
+ (if checkout
+ (magit-call-git "checkout" "-b" branch current)
+ (magit-call-git "branch" branch current)))
+ (when-let ((upstream (magit-get-indirect-upstream-branch current)))
+ (magit-call-git "branch" "--set-upstream-to" upstream branch))
+ (when (and tracked
+ (setq base
+ (if from
+ (concat from "^")
+ (magit-git-string "merge-base" current tracked)))
+ (not (magit-rev-eq base current)))
+ (if checkout
+ (magit-call-git "update-ref" "-m"
+ (format "reset: moving to %s" base)
+ (concat "refs/heads/" current) base)
+ (magit-call-git "reset" "--hard" base)))))
+ (checkout
+ (magit-call-git "checkout" "-b" branch))
+ ((magit-call-git "branch" branch)))
(magit-refresh))
;;;###autoload
@@ -728,25 +729,24 @@ prompt is confusing."
(magit-set nil "branch" branch "pushRemote"))
(defun magit-delete-remote-branch-sentinel (remote refs process event)
- (when (memq (process-status process) '(exit signal))
- (if (= (process-exit-status process) 1)
- (if-let* ((on-remote (mapcar (##concat "refs/remotes/" remote "/" %)
- (magit-remote-list-branches remote)))
- (rest (seq-filter (##and (not (member % on-remote))
- (magit-ref-exists-p %))
- refs)))
- (progn
- (process-put process 'inhibit-refresh t)
- (magit-process-sentinel process event)
- (setq magit-this-error nil)
- (message "Some remote branches no longer exist. %s"
- "Deleting just the local tracking refs instead...")
- (dolist (ref rest)
- (magit-call-git "update-ref" "-d" ref))
- (magit-refresh)
- (message "Deleting local remote-tracking refs...done"))
- (magit-process-sentinel process event))
- (magit-process-sentinel process event))))
+ (cond-let*
+ ((not (memq (process-status process) '(exit signal))))
+ ([_(= (process-exit-status process) 1)]
+ [on-remote (mapcar (##concat "refs/remotes/" remote "/" %)
+ (magit-remote-list-branches remote))]
+ [rest (seq-filter (##and (not (member % on-remote))
+ (magit-ref-exists-p %))
+ refs)]
+ (process-put process 'inhibit-refresh t)
+ (magit-process-sentinel process event)
+ (setq magit-this-error nil)
+ (message "Some remote branches no longer exist. %s"
+ "Deleting just the local tracking refs instead...")
+ (dolist (ref rest)
+ (magit-call-git "update-ref" "-d" ref))
+ (magit-refresh)
+ (message "Deleting local remote-tracking refs...done"))
+ ((magit-process-sentinel process event))))
;;;###autoload
(defun magit-branch-rename (old new &optional force)
diff --git a/lisp/magit-diff.el b/lisp/magit-diff.el
index bf676a8ca6e..41ec3e33b01 100644
--- a/lisp/magit-diff.el
+++ b/lisp/magit-diff.el
@@ -851,28 +851,20 @@ and `:slant'."
('nil magit-direct-use-buffer-arguments)
((or 'always 'selected 'current 'never)
use-buffer-args)))
- (let (args files)
- (cond
- ((and (memq use-buffer-args '(always selected current))
- (eq major-mode mode))
- (setq args magit-buffer-diff-args)
- (setq files magit-buffer-diff-files))
- ((when-let ((_(memq use-buffer-args '(always selected)))
- (buffer (magit-get-mode-buffer
- mode nil
- (eq use-buffer-args 'selected))))
- (setq args (buffer-local-value 'magit-buffer-diff-args buffer))
- (setq files (buffer-local-value 'magit-buffer-diff-files buffer))
- t))
- ((plist-member (symbol-plist mode) 'magit-diff-current-arguments)
- (setq args (get mode 'magit-diff-current-arguments)))
- ((when-let ((elt (assq (intern (format "magit-diff:%s" mode))
- transient-values)))
- (setq args (cdr elt))
- t))
- (t
- (setq args (get mode 'magit-diff-default-arguments))))
- (list args files)))
+ (cond-let
+ ((and (memq use-buffer-args '(always selected current))
+ (eq major-mode mode))
+ (list magit-buffer-diff-args
+ magit-buffer-diff-files))
+ ([_(memq use-buffer-args '(always selected))]
+ [buffer (magit-get-mode-buffer mode nil (eq use-buffer-args 'selected))]
+ (list (buffer-local-value 'magit-buffer-diff-args buffer)
+ (buffer-local-value 'magit-buffer-diff-files buffer)))
+ ((plist-member (symbol-plist mode) 'magit-diff-current-arguments)
+ (list (get mode 'magit-diff-current-arguments) nil))
+ ([elt (assq (intern (format "magit-diff:%s" mode)) transient-values)]
+ (list (cdr elt) nil))
+ ((list (get mode 'magit-diff-default-arguments) nil))))
(defun magit-diff--set-value (obj &optional save)
(pcase-let* ((obj (oref obj prototype))
@@ -1174,53 +1166,51 @@ The information can be in three forms:
A string indicating a diff range.
If no DWIM context is found, nil is returned."
- (cond
- ((and-let ((commits (magit-region-values '(commit branch) t)))
- (prog1 (concat (car (last commits)) ".." (car commits))
- (deactivate-mark))))
- (magit-buffer-refname
- (cons 'commit magit-buffer-refname))
- ((derived-mode-p 'magit-stash-mode)
- (cons 'commit
- (magit-section-case
- (commit (oref it value))
- (file (thread-first it
- (oref parent)
- (oref value)))
- (hunk (thread-first it
- (oref parent)
- (oref parent)
- (oref value))))))
- ((derived-mode-p 'magit-revision-mode)
- (cons 'commit magit-buffer-revision))
- ((derived-mode-p 'magit-diff-mode)
- (pcase-exhaustive magit-buffer-diff-type
- ('committed magit-buffer-range)
- ((or 'unstaged 'staged 'undefined) magit-buffer-diff-type)))
- (t
- (magit-section-case
- ([* unstaged] 'unstaged)
- ([* staged] 'staged)
- (unmerged 'unmerged)
- (unpushed (magit-diff--range-to-endpoints (oref it value)))
- (unpulled (magit-diff--range-to-endpoints (oref it value)))
- (branch (let ((current (magit-get-current-branch))
- (atpoint (oref it value)))
- (if (equal atpoint current)
- (if-let ((upstream (magit-get-upstream-branch)))
- (format "%s...%s" upstream current)
- (if (magit-anything-modified-p)
- current
- (cons 'commit current)))
- (format "%s...%s"
- (or current "HEAD")
- atpoint))))
- (commit (cons 'commit (oref it value)))
- ([file commit] (cons 'commit (oref (oref it parent) value)))
- ([hunk file commit]
- (cons 'commit (oref (oref (oref it parent) parent) value)))
- (stash (cons 'stash (oref it value)))
- (pullreq (forge--pullreq-range (oref it value) t))))))
+ (cond-let
+ ([commits (magit-region-values '(commit branch) t)]
+ (deactivate-mark)
+ (concat (car (last commits)) ".." (car commits)))
+ (magit-buffer-refname
+ (cons 'commit magit-buffer-refname))
+ ((derived-mode-p 'magit-stash-mode)
+ (cons 'commit
+ (magit-section-case
+ (commit (oref it value))
+ (file (thread-first it
+ (oref parent)
+ (oref value)))
+ (hunk (thread-first it
+ (oref parent)
+ (oref parent)
+ (oref value))))))
+ ((derived-mode-p 'magit-revision-mode)
+ (cons 'commit magit-buffer-revision))
+ ((derived-mode-p 'magit-diff-mode)
+ (pcase-exhaustive magit-buffer-diff-type
+ ('committed magit-buffer-range)
+ ((or 'unstaged 'staged 'undefined) magit-buffer-diff-type)))
+ ((magit-section-case
+ ([* unstaged] 'unstaged)
+ ([* staged] 'staged)
+ (unmerged 'unmerged)
+ (unpushed (magit-diff--range-to-endpoints (oref it value)))
+ (unpulled (magit-diff--range-to-endpoints (oref it value)))
+ (branch (let ((current (magit-get-current-branch))
+ (atpoint (oref it value)))
+ (cond-let
+ ((not (equal atpoint current))
+ (format "%s...%s" (or current "HEAD") atpoint))
+ ([upstream (magit-get-upstream-branch)]
+ (format "%s...%s" upstream current))
+ ((magit-anything-modified-p)
+ current)
+ ((cons 'commit current)))))
+ (commit (cons 'commit (oref it value)))
+ ([file commit] (cons 'commit (oref (oref it parent) value)))
+ ([hunk file commit]
+ (cons 'commit (oref (oref (oref it parent) parent) value)))
+ (stash (cons 'stash (oref it value)))
+ (pullreq (forge--pullreq-range (oref it value) t))))))
(defun magit-diff--range-to-endpoints (range)
(cond ((string-match "\\.\\.\\." range) (replace-match ".." nil nil range))
@@ -1998,13 +1988,14 @@ like 'magit-jump-to-diffstat-or-diff'."
:inapt-if-not (##cl-find-if (##eq (oref % type) 'file)
(oref magit-root-section children))
(interactive "P")
- (if-let ((section (cl-find-if (##eq (oref % type) 'file)
- (oref magit-root-section children))))
- (progn (goto-char (oref section start))
- (when expand
- (with-local-quit (magit-section-show section))
- (recenter 0)))
- (message (format "No diff sections found"))))
+ (cond-let
+ ([section (cl-find-if (##eq (oref % type) 'file)
+ (oref magit-root-section children))]
+ (goto-char (oref section start))
+ (when expand
+ (with-local-quit (magit-section-show section))
+ (recenter 0)))
+ ((message (format "No diff sections found")))))
;;; Diff Mode
@@ -2778,21 +2769,21 @@ or a ref which is not a branch, then it inserts
nothing."
(magit-insert-section
( commit-message nil nil
:heading-highlight-face 'magit-diff-revision-summary-highlight)
- (if-let* ((rev magit-buffer-revision)
- (msg (with-temp-buffer
- (save-excursion (magit-rev-insert-format "%B" rev))
- (magit-revision--wash-message))))
- (progn
- (save-excursion (insert msg))
- (magit-revision--wash-message-hashes)
- (save-excursion
- (magit--add-face-text-property (point)
- (progn (forward-line) (point))
- 'magit-diff-revision-summary
- t nil t)
- (magit-insert-heading))
- (goto-char (point-max)))
- (insert "(no message)\n"))))
+ (cond-let*
+ ([rev magit-buffer-revision]
+ [msg (with-temp-buffer
+ (save-excursion (magit-rev-insert-format "%B" rev))
+ (magit-revision--wash-message))]
+ (save-excursion (insert msg))
+ (magit-revision--wash-message-hashes)
+ (save-excursion
+ (magit--add-face-text-property (point)
+ (progn (forward-line) (point))
+ 'magit-diff-revision-summary
+ t nil t)
+ (magit-insert-heading))
+ (goto-char (point-max)))
+ ((insert "(no message)\n")))))
(defun magit-insert-revision-notes ()
"Insert commit notes into a revision buffer."
@@ -2999,33 +2990,34 @@ Refer to user option
`magit-revision-insert-related-refs-display-alist'."
align-to column)))))))
(defun magit-insert-revision-gravatar-cb (image size rev marker align-to
column)
- (unless (eq image 'error)
- (when-let ((buffer (marker-buffer marker)))
- (with-current-buffer buffer
- (save-excursion
- (goto-char marker)
- ;; The buffer might display another revision by now or
- ;; it might have been refreshed, in which case another
- ;; process might already have inserted the image.
- (when (and (equal rev magit-buffer-revision)
- (not (eq (car-safe
- (car-safe
- (get-text-property (point) 'display)))
- 'image)))
- (setf (image-property image :ascent) 'center)
- (setf (image-property image :relief) 1)
- (setf (image-property image :scale) 1)
- (setf (image-property image :height) size)
- (let ((top (list image '(slice 0.0 0.0 1.0 0.5)))
- (bot (list image '(slice 0.0 0.5 1.0 1.0)))
- (align `((space :align-to ,align-to))))
- (let ((inhibit-read-only t))
- (insert (propertize " " 'display top))
- (insert (propertize " " 'display align))
- (forward-line)
- (forward-char column)
- (insert (propertize " " 'display bot))
- (insert (propertize " " 'display align))))))))))
+ (cond-let
+ ((eq image 'error))
+ ([buffer (marker-buffer marker)]
+ (with-current-buffer buffer
+ (save-excursion
+ (goto-char marker)
+ ;; The buffer might display another revision by now or
+ ;; it might have been refreshed, in which case another
+ ;; process might already have inserted the image.
+ (when (and (equal rev magit-buffer-revision)
+ (not (eq (car-safe
+ (car-safe
+ (get-text-property (point) 'display)))
+ 'image)))
+ (setf (image-property image :ascent) 'center)
+ (setf (image-property image :relief) 1)
+ (setf (image-property image :scale) 1)
+ (setf (image-property image :height) size)
+ (let ((top (list image '(slice 0.0 0.0 1.0 0.5)))
+ (bot (list image '(slice 0.0 0.5 1.0 1.0)))
+ (align `((space :align-to ,align-to))))
+ (let ((inhibit-read-only t))
+ (insert (propertize " " 'display top))
+ (insert (propertize " " 'display align))
+ (forward-line)
+ (forward-char column)
+ (insert (propertize " " 'display bot))
+ (insert (propertize " " 'display align))))))))))
;;; Merge-Preview Mode
diff --git a/lisp/magit-extras.el b/lisp/magit-extras.el
index 8325c1c01f4..c34c0cfa725 100644
--- a/lisp/magit-extras.el
+++ b/lisp/magit-extras.el
@@ -672,42 +672,41 @@ a hunk, then strip the diff marker column and keep only
either
the added or removed lines, depending on the sign of the prefix
argument."
(interactive "P")
- (cond
- ((and arg
- (magit-section-internal-region-p)
- (magit-section-match 'hunk))
- (kill-new
- (thread-last (buffer-substring-no-properties
- (region-beginning)
- (region-end))
- (replace-regexp-in-string
- (format "^\\%c.*\n?" (if (< (prefix-numeric-value arg) 0) ?+ ?-))
- "")
- (replace-regexp-in-string "^[ +-]" "")))
- (deactivate-mark))
- ((use-region-p)
- (call-interactively #'copy-region-as-kill))
- (t
- (when-let* ((section (magit-current-section))
- (value (oref section value)))
- (magit-section-case
- ((branch commit module-commit tag)
- (let ((default-directory default-directory) ref)
- (magit-section-case
- ((branch tag)
- (setq ref value))
- (module-commit
- (setq default-directory
- (file-name-as-directory
- (expand-file-name (magit-section-parent-value section)
- (magit-toplevel))))))
- (setq value (magit-rev-parse
- (and magit-copy-revision-abbreviated "--short")
- value))
- (push (list value default-directory) magit-revision-stack)
- (kill-new (message "%s" (or (and current-prefix-arg ref)
- value)))))
- (t (kill-new (message "%s" value))))))))
+ (cond-let*
+ ((and arg
+ (magit-section-internal-region-p)
+ (magit-section-match 'hunk))
+ (kill-new
+ (thread-last (buffer-substring-no-properties
+ (region-beginning)
+ (region-end))
+ (replace-regexp-in-string
+ (format "^\\%c.*\n?" (if (< (prefix-numeric-value arg) 0) ?+ ?-))
+ "")
+ (replace-regexp-in-string "^[ +-]" "")))
+ (deactivate-mark))
+ ((use-region-p)
+ (call-interactively #'copy-region-as-kill))
+ ([section (magit-current-section)]
+ [value (oref section value)]
+ (magit-section-case
+ ((branch commit module-commit tag)
+ (let ((default-directory default-directory) ref)
+ (magit-section-case
+ ((branch tag)
+ (setq ref value))
+ (module-commit
+ (setq default-directory
+ (file-name-as-directory
+ (expand-file-name (magit-section-parent-value section)
+ (magit-toplevel))))))
+ (setq value (magit-rev-parse
+ (and magit-copy-revision-abbreviated "--short")
+ value))
+ (push (list value default-directory) magit-revision-stack)
+ (kill-new (message "%s" (or (and current-prefix-arg ref)
+ value)))))
+ (t (kill-new (message "%s" value)))))))
;;;###autoload
(defun magit-copy-buffer-revision ()
@@ -736,22 +735,23 @@ When `magit-copy-revision-abbreviated' is non-nil, save
the
abbreviated revision to the `kill-ring' and the
`magit-revision-stack'."
(interactive)
- (if (use-region-p)
- (call-interactively #'copy-region-as-kill)
- (when-let ((rev (or magit-buffer-revision
- (cl-case major-mode
- (magit-diff-mode
- (if (string-match "\\.\\.\\.?\\(.+\\)"
- magit-buffer-range)
- (match-str 1 magit-buffer-range)
- magit-buffer-range))
- (magit-status-mode "HEAD")))))
- (when (magit-commit-p rev)
- (setq rev (magit-rev-parse
- (and magit-copy-revision-abbreviated "--short")
- rev))
- (push (list rev default-directory) magit-revision-stack)
- (kill-new (message "%s" rev))))))
+ (cond-let*
+ ((use-region-p)
+ (call-interactively #'copy-region-as-kill))
+ ([rev (or magit-buffer-revision
+ (cl-case major-mode
+ (magit-diff-mode
+ (if (string-match "\\.\\.\\.?\\(.+\\)"
+ magit-buffer-range)
+ (match-str 1 magit-buffer-range)
+ magit-buffer-range))
+ (magit-status-mode "HEAD")))]
+ [_(magit-commit-p rev)]
+ (setq rev (magit-rev-parse
+ (and magit-copy-revision-abbreviated "--short")
+ rev))
+ (push (list rev default-directory) magit-revision-stack)
+ (kill-new (message "%s" rev)))))
;;; Buffer Switching
diff --git a/lisp/magit-git.el b/lisp/magit-git.el
index b88648125a5..a2868059c3a 100644
--- a/lisp/magit-git.el
+++ b/lisp/magit-git.el
@@ -883,66 +883,60 @@ returning the truename."
(magit--with-refresh-cache
(cons (or directory default-directory) 'magit-toplevel)
(magit--with-safe-default-directory directory
- (if-let ((topdir (magit-rev-parse-safe "--show-toplevel")))
- (let (updir)
- (setq topdir (magit-expand-git-file-name topdir))
- (cond
- ((and
- ;; Always honor these settings.
- (not find-file-visit-truename)
- (not (getenv "GIT_WORK_TREE"))
- ;; `--show-cdup' is the relative path to the toplevel
- ;; from `(file-truename default-directory)'. Here we
- ;; pretend it is relative to `default-directory', and
- ;; go to that directory. Then we check whether
- ;; `--show-toplevel' still returns the same value and
- ;; whether `--show-cdup' now is the empty string. If
- ;; both is the case, then we are at the toplevel of
- ;; the same working tree, but also avoided needlessly
- ;; following any symlinks.
- (progn
- (setq updir (file-name-as-directory
- (magit-rev-parse-safe "--show-cdup")))
- (setq updir (if (file-name-absolute-p updir)
- (concat (file-remote-p default-directory)
- updir)
- (expand-file-name updir)))
- (and-let*
- ((default-directory updir)
- (top (and (string-equal
- (magit-rev-parse-safe "--show-cdup") "")
- (magit-rev-parse-safe "--show-toplevel"))))
- (string-equal (magit-expand-git-file-name top) topdir))))
- updir)
- ((concat (file-remote-p default-directory)
- (file-name-as-directory topdir)))))
- (and-let* ((gitdir (magit-rev-parse-safe "--git-dir"))
- (gitdir (file-name-as-directory
- (if (file-name-absolute-p gitdir)
- ;; We might have followed a symlink.
- (concat (file-remote-p default-directory)
- (magit-expand-git-file-name gitdir))
- (expand-file-name gitdir)))))
- (if (magit-bare-repo-p)
- gitdir
- (let* ((link (expand-file-name "gitdir" gitdir))
- (wtree (and (file-exists-p link)
- (magit-file-line link))))
- (cond
- ((and wtree
- ;; Ignore .git/gitdir files that result from a
- ;; Git bug. See #2364.
- (not (equal wtree ".git")))
- ;; Return the linked working tree.
- (concat (file-remote-p default-directory)
- (file-name-directory wtree)))
- ;; The working directory may not be the parent
- ;; directory of .git if it was set up with
- ;; "git init --separate-git-dir". See #2955.
- ((car (rassoc gitdir magit--separated-gitdirs)))
- (;; Step outside the control directory to enter the
- ;; working tree.
- (file-name-directory (directory-file-name gitdir)))))))))))
+ (cond-let*
+ ([topdir (magit-rev-parse-safe "--show-toplevel")]
+ [topdir (magit-expand-git-file-name topdir)]
+ (cond-let*
+ (;; Always honor these settings.
+ [_(not find-file-visit-truename)]
+ [_(not (getenv "GIT_WORK_TREE"))]
+ ;; `--show-cdup' is the relative path to the toplevel
+ ;; from `(file-truename default-directory)'. Here we
+ ;; pretend it is relative to `default-directory', and
+ ;; go to that directory. Then we check whether
+ ;; `--show-toplevel' still returns the same value and
+ ;; whether `--show-cdup' now is the empty string. If
+ ;; both is the case, then we are at the toplevel of
+ ;; the same working tree, but also avoided needlessly
+ ;; following any symlinks.
+ [updir (file-name-as-directory
+ (magit-rev-parse-safe "--show-cdup"))]
+ [updir (if (file-name-absolute-p updir)
+ (concat (file-remote-p default-directory) updir)
+ (expand-file-name updir))]
+ [updir->topdir
+ (let ((default-directory updir))
+ (and (string-equal (magit-rev-parse-safe "--show-cdup") "")
+ (magit-rev-parse-safe "--show-toplevel")))]
+ [_(string-equal (magit-expand-git-file-name updir->topdir) topdir)]
+ updir)
+ ((concat (file-remote-p default-directory)
+ (file-name-as-directory topdir)))))
+ ([gitdir (magit-rev-parse-safe "--git-dir")]
+ [gitdir (file-name-as-directory
+ (if (file-name-absolute-p gitdir)
+ ;; We might have followed a symlink.
+ (concat (file-remote-p default-directory)
+ (magit-expand-git-file-name gitdir))
+ (expand-file-name gitdir)))]
+ (cond-let*
+ ((magit-bare-repo-p) gitdir)
+ ;; Return the linked working tree, if any.
+ ([link (expand-file-name "gitdir" gitdir)]
+ [wtree (and (file-exists-p link)
+ (magit-file-line link))]
+ ;; Ignore ".git/gitdir" files that result from a Git bug.
+ ;; This has long been fixed, but old repository may still
+ ;; exist that contain such a file. See #2364.
+ [_(not (equal wtree ".git"))]
+ (concat (file-remote-p default-directory)
+ (file-name-directory wtree)))
+ ;; The working directory may not be the parent
+ ;; directory of .git if it was set up with
+ ;; "git init --separate-git-dir". See #2955.
+ ((car (rassoc gitdir magit--separated-gitdirs)))
+ ;; Step outside the control directory to enter the working tree.
+ ((file-name-directory (directory-file-name gitdir)))))))))
(defun magit--toplevel-safe ()
(or (magit-toplevel)
@@ -1251,15 +1245,16 @@ Sorted from longest to shortest CYGWIN name."
Git does not understand.
2. If it is a remote filename, then remove the remote part.
3. Deal with an `windows-nt' Emacs vs. Cygwin Git incompatibility."
- (if (file-name-absolute-p filename)
- (if-let ((cyg:win (cl-rassoc filename magit-cygwin-mount-points
- :test (##string-prefix-p %2 %1))))
- (concat (car cyg:win)
- (substring filename (length (cdr cyg:win))))
- (let ((expanded (expand-file-name filename)))
- (or (file-remote-p expanded 'localname)
- expanded)))
- filename))
+ (cond-let
+ ((not (file-name-absolute-p filename))
+ filename)
+ ([cyg:win (cl-rassoc filename magit-cygwin-mount-points
+ :test (##string-prefix-p %2 %1))]
+ (concat (car cyg:win)
+ (substring filename (length (cdr cyg:win)))))
+ ([expanded (expand-file-name filename)]
+ (or (file-remote-p expanded 'localname)
+ expanded))))
(defun magit-decode-git-path (path)
(if (eq (aref path 0) ?\")
@@ -1270,14 +1265,15 @@ Sorted from longest to shortest CYGWIN name."
path))
(defun magit-file-at-point (&optional expand assert)
- (if-let ((file (magit-section-case
- (file (oref it value))
- (hunk (magit-section-parent-value it)))))
- (if expand
- (expand-file-name file (magit-toplevel))
- file)
- (when assert
- (user-error "No file at point"))))
+ (cond-let
+ ([file (magit-section-case
+ (file (oref it value))
+ (hunk (magit-section-parent-value it)))]
+ (if expand
+ (expand-file-name file (magit-toplevel))
+ file))
+ (assert
+ (user-error "No file at point"))))
(defun magit-current-file ()
(or (magit-file-relative-name)
@@ -1891,11 +1887,12 @@ as into its upstream."
(magit-get-upstream-branch branch))))
(magit-rev-ancestor-p branch upstream)
t)
- (if (eq target t)
- (delete (magit-name-local-branch branch)
- (magit-list-containing-branches branch))
- (and-let ((target (or target (magit-get-current-branch))))
- (magit-rev-ancestor-p branch target)))))
+ (cond-let
+ ((eq target t)
+ (delete (magit-name-local-branch branch)
+ (magit-list-containing-branches branch)))
+ ([target (or target (magit-get-current-branch))]
+ (magit-rev-ancestor-p branch target)))))
(defun magit-get-tracked (refname)
"Return the remote branch tracked by the remote-tracking branch REFNAME.
@@ -2265,26 +2262,26 @@ If `first-parent' is set, traverse only first parents."
"\t")))
(defun magit-abbrev-length ()
- (let ((abbrev (magit-get "core.abbrev")))
- (if (and abbrev (not (equal abbrev "auto")))
- (string-to-number abbrev)
- ;; Guess the length git will be using based on an example
- ;; abbreviation. Actually HEAD's abbreviation might be an
- ;; outlier, so use the shorter of the abbreviations for two
- ;; commits. See #3034.
- (if-let* ((head (magit-rev-parse "--short" "HEAD"))
- (head-len (length head)))
- (min head-len
- (if-let ((rev (magit-rev-parse "--short" "HEAD~")))
- (length rev)
- head-len))
- ;; We're on an unborn branch, but perhaps the repository has
- ;; other commits. See #4123.
- (if-let ((commits (magit-git-lines "rev-list" "-n2" "--all"
- "--abbrev-commit")))
- (apply #'min (mapcar #'length commits))
- ;; A commit does not exist. Fall back to the default of 7.
- 7)))))
+ (cond-let*
+ ([abbrev (magit-get "core.abbrev")]
+ [_(not (equal abbrev "auto"))]
+ (string-to-number abbrev))
+ ;; Guess the length git will be using based on an example
+ ;; abbreviation. Actually HEAD's abbreviation might be an
+ ;; outlier, so use the shorter of the abbreviations for two
+ ;; commits. See #3034.
+ ([head (magit-rev-parse "--short" "HEAD")]
+ [head-len (length head)]
+ (min head-len
+ (if-let ((rev (magit-rev-parse "--short" "HEAD~")))
+ (length rev)
+ head-len)))
+ ;; We're on an unborn branch, but perhaps the repository has
+ ;; other commits. See #4123.
+ ([commits (magit-git-lines "rev-list" "-n2" "--all" "--abbrev-commit")]
+ (apply #'min (mapcar #'length commits)))
+ ;; A commit does not exist. Fall back to the default of 7.
+ (7)))
(defun magit-abbrev-arg (&optional arg)
(format "--%s=%d" (or arg "abbrev") (magit-abbrev-length)))
@@ -2432,18 +2429,18 @@ and this option only controls what face is used.")
magit-branch-local)))))
(t
(push (concat push name) combined)))))
- (when (and target (not upstream))
- (if (member target remotes)
- (progn
- (magit--add-face-text-property
- 0 (length target) 'magit-branch-upstream nil target)
- (setq upstream target)
- (setq remotes (delete target remotes)))
- (when-let ((target (car (member target combined))))
- (magit--add-face-text-property
- 0 (length target) 'magit-branch-upstream nil target)
- (setq upstream target)
- (setq combined (delete target combined))))))
+ (cond-let
+ ((or upstream (not target)))
+ ((member target remotes)
+ (magit--add-face-text-property
+ 0 (length target) 'magit-branch-upstream nil target)
+ (setq upstream target)
+ (setq remotes (delete target remotes)))
+ ([target (car (member target combined))]
+ (magit--add-face-text-property
+ 0 (length target) 'magit-branch-upstream nil target)
+ (setq upstream target)
+ (setq combined (delete target combined)))))
(string-join (flatten-tree `(,state
,head
,upstream
diff --git a/lisp/magit-log.el b/lisp/magit-log.el
index a342d7d3ed5..bf9c1b2c740 100644
--- a/lisp/magit-log.el
+++ b/lisp/magit-log.el
@@ -413,28 +413,20 @@ commits before and half after."
('nil magit-direct-use-buffer-arguments)
((or 'always 'selected 'current 'never)
use-buffer-args)))
- (let (args files)
- (cond
- ((and (memq use-buffer-args '(always selected current))
- (eq major-mode mode))
- (setq args magit-buffer-log-args)
- (setq files magit-buffer-log-files))
- ((when-let ((_(memq use-buffer-args '(always selected)))
- (buffer (magit-get-mode-buffer
- mode nil
- (eq use-buffer-args 'selected))))
- (setq args (buffer-local-value 'magit-buffer-log-args buffer))
- (setq files (buffer-local-value 'magit-buffer-log-files buffer))
- t))
- ((plist-member (symbol-plist mode) 'magit-log-current-arguments)
- (setq args (get mode 'magit-log-current-arguments)))
- ((when-let ((elt (assq (intern (format "magit-log:%s" mode))
- transient-values)))
- (setq args (cdr elt))
- t))
- (t
- (setq args (get mode 'magit-log-default-arguments))))
- (list args files)))
+ (cond-let
+ ((and (memq use-buffer-args '(always selected current))
+ (eq major-mode mode))
+ (list magit-buffer-log-args
+ magit-buffer-log-files))
+ ([_(memq use-buffer-args '(always selected))]
+ [buffer (magit-get-mode-buffer mode nil (eq use-buffer-args 'selected))]
+ (list (buffer-local-value 'magit-buffer-log-args buffer)
+ (buffer-local-value 'magit-buffer-log-files buffer)))
+ ((plist-member (symbol-plist mode) 'magit-log-current-arguments)
+ (list (get mode 'magit-log-current-arguments) nil))
+ ([elt (assq (intern (format "magit-log:%s" mode)) transient-values)]
+ (list (cdr elt) nil))
+ ((list (get mode 'magit-log-default-arguments) nil))))
(defun magit-log--set-value (obj &optional save)
(pcase-let* ((obj (oref obj prototype))
diff --git a/lisp/magit-merge.el b/lisp/magit-merge.el
index 91cc55f02bb..1c85784b96f 100644
--- a/lisp/magit-merge.el
+++ b/lisp/magit-merge.el
@@ -172,21 +172,21 @@ then also remove the respective remote branch."
(format "Do you really want to merge `%s' into another branch? "
branch))
(user-error "Abort")))
- (if-let ((target (magit-get-push-branch branch t)))
- (progn
- (magit-git-push branch target (list "--force-with-lease"))
- (set-process-sentinel
- magit-this-process
- (lambda (process event)
- (when (memq (process-status process) '(exit signal))
- (if (not (zerop (process-exit-status process)))
- (magit-process-sentinel process event)
- (process-put process 'inhibit-refresh t)
- (magit-process-sentinel process event)
- (magit--merge-absorb-1 branch args))
- (when message
- (message message))))))
- (magit--merge-absorb-1 branch args)))
+ (cond-let
+ ([target (magit-get-push-branch branch t)]
+ (magit-git-push branch target (list "--force-with-lease"))
+ (set-process-sentinel
+ magit-this-process
+ (lambda (process event)
+ (when (memq (process-status process) '(exit signal))
+ (if (not (zerop (process-exit-status process)))
+ (magit-process-sentinel process event)
+ (process-put process 'inhibit-refresh t)
+ (magit-process-sentinel process event)
+ (magit--merge-absorb-1 branch args))
+ (when message
+ (message message))))))
+ ((magit--merge-absorb-1 branch args))))
(defun magit--merge-absorb-1 (branch args)
(if-let ((pr (magit-get "branch" branch "pullRequest")))
diff --git a/lisp/magit-mode.el b/lisp/magit-mode.el
index 7d911924d05..412855fbb71 100644
--- a/lisp/magit-mode.el
+++ b/lisp/magit-mode.el
@@ -445,11 +445,12 @@ Where applicable, other keymaps remap this command to
another,
which actually visits the thing at point."
(declare (completion ignore))
(interactive)
- (if (eq transient-current-command 'magit-dispatch)
- (call-interactively (key-binding (this-command-keys)))
- (if-let ((url (thing-at-point 'url t)))
- (browse-url url)
- (user-error "There is no thing at point that could be visited"))))
+ (cond-let
+ ((eq transient-current-command 'magit-dispatch)
+ (call-interactively (key-binding (this-command-keys))))
+ ([url (thing-at-point 'url t)]
+ (browse-url url))
+ ((user-error "There is no thing at point that could be visited"))))
(defun magit-edit-thing ()
"This is a placeholder command, which may signal an error if called.
@@ -956,32 +957,33 @@ and another unlocked buffer already exists for that mode
and
repository, then the former buffer is instead deleted and the
latter is displayed in its place."
(interactive)
- (if magit-buffer-locked-p
- (if-let ((unlocked (magit-get-mode-buffer major-mode)))
- (let ((locked (current-buffer)))
- (switch-to-buffer unlocked nil t)
- (kill-buffer locked))
- (setq magit-buffer-locked-p nil)
- (let ((name (funcall magit-generate-buffer-name-function major-mode))
- (buffer (current-buffer))
- (mode major-mode))
- (rename-buffer (generate-new-buffer-name name))
- (with-temp-buffer
- (magit--maybe-uniquify-buffer-names buffer name mode))))
- (if-let ((value (magit-buffer-value)))
- (if-let ((locked (magit-get-mode-buffer major-mode value)))
- (let ((unlocked (current-buffer)))
- (switch-to-buffer locked nil t)
- (kill-buffer unlocked))
- (setq magit-buffer-locked-p t)
- (let ((name (funcall magit-generate-buffer-name-function
- major-mode value))
- (buffer (current-buffer))
- (mode major-mode))
- (rename-buffer (generate-new-buffer-name name))
- (with-temp-buffer
- (magit--maybe-uniquify-buffer-names buffer name mode))))
- (user-error "Buffer has no value it could be locked to"))))
+ (cond-let
+ (magit-buffer-locked-p
+ (if-let ((unlocked (magit-get-mode-buffer major-mode)))
+ (let ((locked (current-buffer)))
+ (switch-to-buffer unlocked nil t)
+ (kill-buffer locked))
+ (setq magit-buffer-locked-p nil)
+ (let ((name (funcall magit-generate-buffer-name-function major-mode))
+ (buffer (current-buffer))
+ (mode major-mode))
+ (rename-buffer (generate-new-buffer-name name))
+ (with-temp-buffer
+ (magit--maybe-uniquify-buffer-names buffer name mode)))))
+ ([value (magit-buffer-value)]
+ (if-let ((locked (magit-get-mode-buffer major-mode value)))
+ (let ((unlocked (current-buffer)))
+ (switch-to-buffer locked nil t)
+ (kill-buffer unlocked))
+ (setq magit-buffer-locked-p t)
+ (let ((name (funcall magit-generate-buffer-name-function
+ major-mode value))
+ (buffer (current-buffer))
+ (mode major-mode))
+ (rename-buffer (generate-new-buffer-name name))
+ (with-temp-buffer
+ (magit--maybe-uniquify-buffer-names buffer name mode)))))
+ ((user-error "Buffer has no value it could be locked to"))))
;;; Bury Buffer
@@ -1152,17 +1154,17 @@ The arguments are for internal use."
(if window
(with-selected-window window
(magit-section-goto-successor section line char)
- (cond
- ((derived-mode-p 'magit-log-mode))
- ((or (not window-start)
- (> window-start (point))))
- ((magit-section-equal ws-section (magit-section-at window-start))
- (set-window-start window window-start t))
- ((when-let ((pos (save-excursion
- (and (magit-section-goto-successor--same
- ws-section ws-line 0)
- (point)))))
- (set-window-start window pos t)))))
+ (cond-let
+ ((derived-mode-p 'magit-log-mode))
+ ((or (not window-start)
+ (> window-start (point))))
+ ((magit-section-equal ws-section (magit-section-at window-start))
+ (set-window-start window window-start t))
+ ([pos (save-excursion
+ (and (magit-section-goto-successor--same
+ ws-section ws-line 0)
+ (point)))]
+ (set-window-start window pos t))))
;; We must make sure this does not call `set-window-start',
;; which the HUNK METHOD does by calling `magit-section-goto'
;; because that runs the `magit-section-goto-successor-hook'
@@ -1490,13 +1492,13 @@ Unless specified, REPOSITORY is the current buffer's
repository."
Unless specified, REPOSITORY is the current buffer's repository.
If REPOSITORY is `all', then delete the value for KEY for all
repositories."
- (if (eq repository 'all)
- (dolist (cache magit-repository-local-cache)
- (setf cache (compat-call assoc-delete-all key cache)))
- (when-let ((cache (assoc (or repository
- (magit-repository-local-repository))
- magit-repository-local-cache)))
- (setf cache (compat-call assoc-delete-all key cache)))))
+ (cond-let
+ ((eq repository 'all)
+ (dolist (cache magit-repository-local-cache)
+ (setf cache (compat-call assoc-delete-all key cache))))
+ ([cache (assoc (or repository (magit-repository-local-repository))
+ magit-repository-local-cache)]
+ (setf cache (compat-call assoc-delete-all key cache)))))
(defmacro magit--with-repository-local-cache (key &rest body)
(declare (indent 1) (debug (form body)))
diff --git a/lisp/magit-refs.el b/lisp/magit-refs.el
index fe690f5f2cd..0792da6d785 100644
--- a/lisp/magit-refs.el
+++ b/lisp/magit-refs.el
@@ -356,22 +356,16 @@ Type \\[magit-reset] to reset `HEAD' to the commit at
point.
(defun magit-show-refs-arguments (&optional use-buffer-args)
(unless use-buffer-args
(setq use-buffer-args magit-direct-use-buffer-arguments))
- (let (args)
- (cond
- ((eq transient-current-command 'magit-show-refs)
- (setq args (transient-args 'magit-show-refs)))
- ((eq major-mode 'magit-refs-mode)
- (setq args magit-buffer-arguments))
- ((and (memq use-buffer-args '(always selected))
- (and-let ((buffer (magit-get-mode-buffer
- 'magit-refs-mode nil
- (eq use-buffer-args 'selected))))
- (progn
- (setq args (buffer-local-value 'magit-buffer-arguments buffer))
- t))))
- (t
- (setq args (alist-get 'magit-show-refs transient-values))))
- args))
+ (cond-let*
+ ((eq transient-current-command 'magit-show-refs)
+ (transient-args 'magit-show-refs))
+ ((eq major-mode 'magit-refs-mode)
+ magit-buffer-arguments)
+ ([_(memq use-buffer-args '(always selected))]
+ [buffer (magit-get-mode-buffer 'magit-refs-mode nil
+ (eq use-buffer-args 'selected))]
+ (buffer-local-value 'magit-buffer-arguments buffer))
+ ((alist-get 'magit-show-refs transient-values))))
(transient-define-argument magit-for-each-ref:--contains ()
:description "Contains"
diff --git a/lisp/magit-section.el b/lisp/magit-section.el
index 84a8a5b7eab..d030c3c35a8 100644
--- a/lisp/magit-section.el
+++ b/lisp/magit-section.el
@@ -678,14 +678,15 @@ then return nil."
(defun magit-menu-highlight-point-section ()
(setq magit-section-highlight-force-update t)
- (if (eq (current-buffer) magit--context-menu-buffer)
- (setq magit--context-menu-section nil)
- (if-let ((window (get-buffer-window magit--context-menu-buffer)))
- (with-selected-window window
- (setq magit--context-menu-section nil)
- (magit-section-update-highlight))
- (with-current-buffer magit--context-menu-buffer
- (setq magit--context-menu-section nil))))
+ (cond-let
+ ((eq (current-buffer) magit--context-menu-buffer)
+ (setq magit--context-menu-section nil))
+ ([window (get-buffer-window magit--context-menu-buffer)]
+ (with-selected-window window
+ (setq magit--context-menu-section nil)
+ (magit-section-update-highlight)))
+ ((with-current-buffer magit--context-menu-buffer
+ (setq magit--context-menu-section nil))))
(setq magit--context-menu-buffer nil))
(defvar magit--plural-append-es '(branch))
@@ -809,22 +810,24 @@ the beginning of the current section."
If there is no next sibling section, then move to the parent."
(interactive)
(let ((current (magit-current-section)))
- (if (oref current parent)
- (if-let ((next (car (magit-section-siblings current 'next))))
- (magit-section-goto next)
- (magit-section-forward))
- (magit-section-goto 1))))
+ (cond-let
+ ((not (oref current parent))
+ (magit-section-goto 1))
+ ([next (car (magit-section-siblings current 'next))]
+ (magit-section-goto next))
+ ((magit-section-forward)))))
(defun magit-section-backward-sibling ()
"Move to the beginning of the previous sibling section.
If there is no previous sibling section, then move to the parent."
(interactive)
(let ((current (magit-current-section)))
- (if (oref current parent)
- (if-let ((previous (car (magit-section-siblings current 'prev))))
- (magit-section-goto previous)
- (magit-section-backward))
- (magit-section-goto -1))))
+ (cond-let
+ ((not (oref current parent))
+ (magit-section-goto -1))
+ ([previous (car (magit-section-siblings current 'prev))]
+ (magit-section-goto previous))
+ ((magit-section-backward)))))
(defun magit-mouse-set-point (event &optional promote-to-region)
"Like `mouse-set-point' but also call `magit-section-movement-hook'."
@@ -868,14 +871,15 @@ With a prefix argument also expand it." heading)
(cons (cons ',type ,value)
(magit-section-ident magit-root-section)))
(interactive "P")
- (if-let ((section (magit-get-section
- (cons (cons ',type ,value)
- (magit-section-ident magit-root-section)))))
- (progn (goto-char (oref section start))
- (when expand
- (with-local-quit (magit-section-show section))
- (recenter 0)))
- (message ,(format "Section \"%s\" wasn't found" heading)))))
+ (cond-let
+ ([section (magit-get-section
+ (cons (cons ',type ,value)
+ (magit-section-ident magit-root-section)))]
+ (goto-char (oref section start))
+ (when expand
+ (with-local-quit (magit-section-show section))
+ (recenter 0)))
+ ((message ,(format "Section \"%s\" wasn't found" heading))))))
;;;; Visibility
@@ -1247,11 +1251,12 @@ of course you want to be that precise."
(and-let ((parent (oref section parent)))
(magit-section-match-2 condition parent)))
(and (let ((c (car condition)))
- (if (class-p c)
- (cl-typep section c)
- (if-let ((class (cdr (assq c magit--section-type-alist))))
- (cl-typep section class)
- (eq (oref section type) c))))
+ (cond-let
+ ((class-p c)
+ (cl-typep section c))
+ ([class (cdr (assq c magit--section-type-alist))]
+ (cl-typep section class))
+ ((eq (oref section type) c))))
(or (not (setq condition (cdr condition)))
(and-let ((parent (oref section parent)))
(magit-section-match-2 condition parent))))))
diff --git a/lisp/magit-submodule.el b/lisp/magit-submodule.el
index 589e81b66c9..0c0a4d6a10b 100644
--- a/lisp/magit-submodule.el
+++ b/lisp/magit-submodule.el
@@ -498,13 +498,14 @@ or, failing that, the abbreviated HEAD commit hash."
(if-let ((branch (magit-get-current-branch)))
(propertize branch 'font-lock-face 'magit-branch-local)
(propertize "(detached)" 'font-lock-face 'warning))))
- (if-let ((desc (magit-git-string "describe" "--tags")))
- (progn (when (and magit-modules-overview-align-numbers
- (string-match-p "\\`[0-9]" desc))
- (insert ?\s))
- (insert (propertize desc 'font-lock-face 'magit-tag)))
- (when-let ((abbrev (magit-rev-format "%h")))
- (insert (propertize abbrev 'font-lock-face 'magit-hash)))))
+ (cond-let
+ ([desc (magit-git-string "describe" "--tags")]
+ (when (and magit-modules-overview-align-numbers
+ (string-match-p "\\`[0-9]" desc))
+ (insert ?\s))
+ (insert (propertize desc 'font-lock-face 'magit-tag)))
+ ([abbrev (magit-rev-format "%h")]
+ (insert (propertize abbrev 'font-lock-face 'magit-hash)))))
(insert ?\n))))))
(insert ?\n))
diff --git a/lisp/magit-transient.el b/lisp/magit-transient.el
index 8d5ecd60cbf..8fa9d5c0058 100644
--- a/lisp/magit-transient.el
+++ b/lisp/magit-transient.el
@@ -93,18 +93,19 @@
(let ((choices (oref obj choices)))
(when (functionp choices)
(setq choices (funcall choices)))
- (if current-prefix-arg
- (pcase-let*
- ((`(,fallback . ,choices)
- (magit--git-variable-list-choices obj))
- (choice (magit-completing-read
- (format "Set `%s' to" (oref obj variable))
- (if fallback (nconc choices (list fallback)) choices)
- nil t)))
- (if (equal choice fallback) nil choice))
- (if-let ((value (oref obj value)))
- (cadr (member value choices))
- (car choices)))))
+ (cond-let
+ (current-prefix-arg
+ (pcase-let*
+ ((`(,fallback . ,choices)
+ (magit--git-variable-list-choices obj))
+ (choice (magit-completing-read
+ (format "Set `%s' to" (oref obj variable))
+ (if fallback (nconc choices (list fallback)) choices)
+ nil t)))
+ (if (equal choice fallback) nil choice)))
+ ([value (oref obj value)]
+ (cadr (member value choices)))
+ ((car choices)))))
;;;; Readers
@@ -155,20 +156,21 @@
(oref obj variable)))
(cl-defmethod transient-format-value ((obj magit--git-variable))
- (if-let ((value (oref obj value)))
- (if (oref obj multi-value)
- (if (cdr value)
- (mapconcat (##concat "\n "
- (propertize % 'face 'transient-value))
- value "")
- (propertize (car value) 'face 'transient-value))
- (propertize (car (split-string value "\n"))
- 'face 'transient-value))
- (if-let* ((default (oref obj default))
- (default (if (functionp default) (funcall default) default)))
- (concat (propertize "default:" 'face 'transient-inactive-value)
- (propertize default 'face 'transient-value))
- (propertize "unset" 'face 'transient-inactive-value))))
+ (cond-let*
+ ([value (oref obj value)]
+ (if (oref obj multi-value)
+ (if (cdr value)
+ (mapconcat (##concat "\n "
+ (propertize % 'face 'transient-value))
+ value "")
+ (propertize (car value) 'face 'transient-value))
+ (propertize (car (split-string value "\n"))
+ 'face 'transient-value)))
+ ([default (oref obj default)]
+ [default (if (functionp default) (funcall default) default)]
+ (concat (propertize "default:" 'face 'transient-inactive-value)
+ (propertize default 'face 'transient-value)))
+ ((propertize "unset" 'face 'transient-inactive-value))))
(cl-defmethod transient-format-value ((obj magit--git-variable:choices))
(pcase-let ((`(,fallback . ,choices) (magit--git-variable-list-choices obj)))
diff --git a/lisp/magit-wip.el b/lisp/magit-wip.el
index 8cccc512048..eb9e0fcfe95 100644
--- a/lisp/magit-wip.el
+++ b/lisp/magit-wip.el
@@ -117,30 +117,33 @@ variant `magit-wip-after-save-mode'."
(remove-hook 'after-save-hook #'magit-wip-commit-buffer-file t)))
(defun magit-wip-after-save-local-mode-turn-on ()
- (when (and buffer-file-name
- (if magit--wip-activation-cache
- (if-let ((elt (assoc default-directory
- magit--wip-activation-cache)))
- (and-let ((top (cadr elt)))
- (member (file-relative-name buffer-file-name top)
- (cddr elt)))
- (if-let ((top (magit-toplevel)))
- (let (files)
- (if-let ((elt (assoc top
magit--wip-activation-cache)))
- (setq files (cddr elt))
- (setq files (let ((default-directory top))
- (magit-tracked-files)))
- (push `(,top ,top ,@files)
- magit--wip-activation-cache)
- (unless (eq default-directory top)
- (push `(,default-directory ,top ,@files)
- magit--wip-activation-cache)))
- (member (file-relative-name buffer-file-name) files))
- (push (list default-directory nil)
- magit--wip-activation-cache)
- nil))
- (and (magit-inside-worktree-p t)
- (magit-file-tracked-p buffer-file-name))))
+ (when (cond-let
+ ((not buffer-file-name)
+ nil)
+ ((not magit--wip-activation-cache)
+ (and (magit-inside-worktree-p t)
+ (magit-file-tracked-p buffer-file-name)))
+ ([elt (assoc default-directory
+ magit--wip-activation-cache)]
+ (and-let ((top (cadr elt)))
+ (member (file-relative-name buffer-file-name top)
+ (cddr elt))))
+ ([top (magit-toplevel)]
+ (let (files)
+ (if-let ((elt (assoc top magit--wip-activation-cache)))
+ (setq files (cddr elt))
+ (setq files (let ((default-directory top))
+ (magit-tracked-files)))
+ (push `(,top ,top ,@files)
+ magit--wip-activation-cache)
+ (unless (eq default-directory top)
+ (push `(,default-directory ,top ,@files)
+ magit--wip-activation-cache)))
+ (member (file-relative-name buffer-file-name) files)))
+ (t
+ (push (list default-directory nil)
+ magit--wip-activation-cache)
+ nil))
(magit-wip-after-save-local-mode)))
;;;###autoload
@@ -438,23 +441,23 @@ many \"branches\" of each wip ref are shown."
(defun magit-wip-purge ()
"Ask to delete all wip-refs that no longer have a corresponding ref."
(interactive)
- (if-let ((wiprefs (thread-last
- (cl-set-difference (magit-list-refs "refs/wip/")
- (magit-list-refs)
- :test (##equal (substring %1 15) %2))
- (delete "refs/wip/index/HEAD")
- (delete "refs/wip/wtree/HEAD"))))
- (progn
- (magit-confirm 'purge-dangling-wiprefs
- "Delete wip-ref %s without corresponding ref"
- "Delete %d wip-refs without corresponding ref"
- nil wiprefs)
- (message "Deleting wip-refs...")
- (dolist (wipref wiprefs)
- (magit-call-git "update-ref" "-d" wipref))
- (message "Deleting wip-refs...done")
- (magit-refresh))
- (message "All wip-refs have a corresponding ref")))
+ (cond-let
+ ([wiprefs (thread-last
+ (cl-set-difference (magit-list-refs "refs/wip/")
+ (magit-list-refs)
+ :test (##equal (substring %1 15) %2))
+ (delete "refs/wip/index/HEAD")
+ (delete "refs/wip/wtree/HEAD"))]
+ (magit-confirm 'purge-dangling-wiprefs
+ "Delete wip-ref %s without corresponding ref"
+ "Delete %d wip-refs without corresponding ref"
+ nil wiprefs)
+ (message "Deleting wip-refs...")
+ (dolist (wipref wiprefs)
+ (magit-call-git "update-ref" "-d" wipref))
+ (message "Deleting wip-refs...done")
+ (magit-refresh))
+ ((message "All wip-refs have a corresponding ref"))))
;;; _
(provide 'magit-wip)
