daniel/emacs-conf
1
2
Fork 0
Code Issues 7 Pull Requests Projects Releases Wiki Activity

update packages

Browse Source
This commit is contained in:
Daniel Weschke
2025-07-13 14:06:54 +02:00
parent 373aa8226e
commit fc97ce061b
28 changed files with 508 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
lisp/magit/git-rebase.el
View File

@@ -321,6 +321,10 @@ region is active, act on all lines touched by the region."
(abbrev)))
(defvar git-rebase-line-regexps
;; 1: action, 2: option, 3: target, 4: "#", 5: description.
;;
;; <action> <commit> [[# ] <oneline>]
;; fixup [-C|-c] <commit> [[# ] <oneline>]
`((commit . ,(concat
(regexp-opt '("d" "drop"
"e" "edit"
@@ -331,7 +335,8 @@ region is active, act on all lines touched by the region."
"r" "reword"
"s" "squash")
"\\(?1:")
" \\(?3:[^ \n]+\\) ?\\(?4:.*\\)"))
" \\(?3:[^ \n]+\\)"
"\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))
(exec . "\\(?1:x\\|exec\\) \\(?3:.*\\)")
(bare . ,(concat (regexp-opt '("b" "break" "noop") "\\(?1:")
" *$"))
@@ -339,11 +344,14 @@ region is active, act on all lines touched by the region."
"t" "reset"
"u" "update-ref")
"\\(?1:")
" \\(?3:[^ \n]+\\) ?\\(?4:.*\\)"))
" \\(?3:[^ \n]+\\)"
"\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))
;; merge [-C <commit> | -c <commit>] <label> [# <oneline>]
;; <commit> is matched by group 22 (part of group 2), not group 3
(merge . ,(concat "\\(?1:m\\|merge\\) "
"\\(?:\\(?2:-[cC] [^ \n]+\\) \\)?"
"\\(?:\\(?2:\\(?21:-[cC]\\) \\(?22:[^ \n]+\\)\\) \\)?"
"\\(?3:[^ \n]+\\)"
" ?\\(?4:.*\\)"))))
"\\(?: \\(?4:# \\)?\\(?5:.*\\)\\)?"))))
;;;###autoload
(defun git-rebase-current-line (&optional batch)
@@ -356,7 +364,7 @@ BATCH also ignores commented lines."
(goto-char (line-beginning-position))
(if-let ((re-start (if batch
"^"
(format "^\\(?5:%s\\)? *"
(format "^\\(?99:%s\\)? *"
(regexp-quote comment-start))))
(type (seq-some (pcase-lambda (`(,type . ,re))
(let ((case-fold-search nil))
@@ -369,8 +377,8 @@ BATCH also ignores commented lines."
action))
:action-options (match-string-no-properties 2)
:target (match-string-no-properties 3)
:trailer (match-string-no-properties 4)
:comment-p (and (match-string 5) t))
:trailer (match-string-no-properties 5)
:comment-p (and (match-string 99) t))
(and (not batch)
;; Use empty object rather than nil to ease handling.
(git-rebase-action)))))
@@ -394,7 +402,10 @@ of its action type."
((and action (eq action-type 'commit))
(let ((inhibit-read-only t))
(magit-delete-line)
(insert (concat action " " target " " trailer "\n"))))
(insert (concat action " " target " "))
(when (magit-git-version>= "2.50.0")
(insert "# "))
(insert (concat trailer "\n"))))
((and (not action) action-type)
(let ((inhibit-read-only t))
(if comment-p
@@ -804,7 +815,8 @@ running \"man git-rebase\" at the command line) for details."
`((,(concat "^" (cdr (assq 'commit git-rebase-line-regexps)))
(1 'git-rebase-action)
(3 'git-rebase-hash)
(4 'git-rebase-description))
(4 'font-lock-comment-face nil t)
(5 'git-rebase-description nil t))
(,(concat "^" (cdr (assq 'exec git-rebase-line-regexps)))
(1 'git-rebase-action)
(3 'git-rebase-description))
@@ -813,32 +825,33 @@ running \"man git-rebase\" at the command line) for details."
(,(concat "^" (cdr (assq 'label git-rebase-line-regexps)))
(1 'git-rebase-action)
(3 'git-rebase-label)
(4 'font-lock-comment-face))
("^\\(m\\(?:erge\\)?\\) -[Cc] \\([^ \n]+\\) \\([^ \n]+\\)\\( #.*\\)?"
(1 'git-rebase-action)
(2 'git-rebase-hash)
(3 'git-rebase-label)
(4 'font-lock-comment-face))
("^\\(m\\(?:erge\\)?\\) \\([^ \n]+\\)"
(1 'git-rebase-action)
(2 'git-rebase-label))
(4 'font-lock-comment-face nil t)
(5 'git-rebase-description nil t))
(,(concat "^" (cdr (assq 'merge git-rebase-line-regexps)))
(1 'git-rebase-action)
(21 'git-rebase-action nil t)
(22 'git-rebase-hash t t)
(3 'magit-branch-local)
(4 'font-lock-comment-face nil t)
(5 'git-rebase-description nil t))
(,(format "^%s Branch \\(.*\\)" comment-start)
(1 'magit-branch-local t))
("^drop \\(.+\\)"
1 'git-rebase-killed-action t)
(1 'git-rebase-killed-action t))
(,(concat git-rebase-comment-re " *"
(cdr (assq 'commit git-rebase-line-regexps)))
0 'git-rebase-killed-action t)
(git-rebase-match-comment-line 0 'font-lock-comment-face)
(0 'git-rebase-killed-action t))
(git-rebase-match-comment-line
(0 'font-lock-comment-face))
("\\[[^[]*\\]"
0 'magit-keyword t)
(0 'magit-keyword t))
("\\(?:fixup!\\|squash!\\|amend!\\)"
0 'magit-keyword-squash t)
(0 'magit-keyword-squash t))
(,(format "^%s Rebase \\([^ ]*\\) onto \\([^ ]*\\)" comment-start)
(1 'git-rebase-comment-hash t)
(2 'git-rebase-comment-hash t))
(,(format "^%s \\(Commands:\\)" comment-start)
(1 'git-rebase-comment-heading t))
(,(format "^%s Branch \\(.*\\)" comment-start)
(1 'git-rebase-label t))))
(1 'git-rebase-comment-heading t))))
(defun git-rebase-mode-show-keybindings ()
"Modify the \"Commands:\" section of the comment Git generates.

6
lisp/magit/magit-blame.el
View File

@@ -432,14 +432,14 @@ modes is toggled, then this mode also gets toggled automatically.
(set-process-sentinel magit-this-process
#'magit-blame-process-quickstart-sentinel)))
(defun magit-blame-run-process (revision file args &optional lines)
(defun magit-blame-run-process (rev file args &optional lines)
(let ((process (magit-parse-git-async
"blame" "--incremental" args
(and lines (list "-L" (apply #'format "%s,%s" lines)))
revision "--" file)))
rev "--" file)))
(set-process-filter process #'magit-blame-process-filter)
(set-process-sentinel process #'magit-blame-process-sentinel)
(process-put process 'arguments (list revision file args))
(process-put process 'arguments (list rev file args))
(setq magit-blame-cache (make-hash-table :test #'equal))
(setq magit-blame-process process)))

22
lisp/magit/magit-branch.el
View File

@@ -252,24 +252,24 @@ has to be used to view and change branch related variables."
(transient-args 'magit-branch))
;;;###autoload
(defun magit-checkout (revision &optional args)
"Checkout REVISION, updating the index and the working tree.
If REVISION is a local branch, then that becomes the current
(defun magit-checkout (commit &optional args)
"Checkout COMMIT, updating the index and the working tree.
If COMMIT is a local branch, then that becomes the current
branch. If it is something else, then `HEAD' becomes detached.
Checkout fails if the working tree or the staging area contain
changes.
\n(git checkout REVISION)."
\n(git checkout COMMIT)."
(declare (interactive-only magit--checkout))
(interactive (list (magit-read-other-branch-or-commit "Checkout")
(magit-branch-arguments)))
(when (string-match "\\`heads/\\(.+\\)" revision)
(setq revision (match-string 1 revision)))
(magit-run-git-async "checkout" args revision))
(when (string-match "\\`heads/\\(.+\\)" commit)
(setq commit (match-string 1 commit)))
(magit-run-git-async "checkout" args commit))
(defun magit--checkout (revision &optional args)
(when (string-match "\\`heads/\\(.+\\)" revision)
(setq revision (match-string 1 revision)))
(magit-call-git "checkout" args revision))
(defun magit--checkout (rev &optional args)
(when (string-match "\\`heads/\\(.+\\)" rev)
(setq rev (match-string 1 rev)))
(magit-call-git "checkout" args rev))
;;;###autoload
(defun magit-branch-create (branch start-point)

8
lisp/magit/magit-extras.el
View File

@@ -431,8 +431,8 @@ Otherwise the author dates are also changed."
:type 'boolean)
;;;###autoload
(defun magit-reshelve-since (rev keyid)
"Change the author and committer dates of the commits since REV.
(defun magit-reshelve-since (commit keyid)
"Change the author and committer dates of the commits since COMMIT.
Ask the user for the first reachable commit whose dates should
be changed. Then read the new date for that commit. The initial
@@ -453,7 +453,7 @@ list returned by `magit-rebase-arguments'."
(user-error "Refusing to reshelve detached head")))
(backup (concat "refs/original/refs/heads/" current)))
(cond
((not rev)
((not commit)
(when (and (magit-ref-p backup)
(not (magit-y-or-n-p
(format "Backup ref %s already exists. Override? "
@@ -470,7 +470,7 @@ list returned by `magit-rebase-arguments'."
(+ (floor time)
(* offset 60)
(- (car (decode-time time)))))))
(let* ((start (concat rev "^"))
(let* ((start (concat commit "^"))
(range (concat start ".." current))
(time-rev (adjust (float-time (string-to-number
(magit-rev-format "%at" start)))

38
lisp/magit/magit-git.el
View File

@@ -1999,32 +1999,32 @@ SORTBY is a key or list of keys to pass to the `--sort' flag of
(defun magit-list-remote-branches (&optional remote)
(magit-list-refs (concat "refs/remotes/" remote)))
(defun magit-list-related-branches (relation &optional commit &rest args)
(defun magit-list-related-branches (relation &optional rev &rest args)
(seq-remove (##string-match-p "\\(\\`(HEAD\\|HEAD -> \\)" %)
(mapcar (##substring % 2)
(magit-git-lines "branch" args relation commit))))
(magit-git-lines "branch" args relation rev))))
(defun magit-list-containing-branches (&optional commit &rest args)
(magit-list-related-branches "--contains" commit args))
(defun magit-list-containing-branches (&optional rev &rest args)
(magit-list-related-branches "--contains" rev args))
(defun magit-list-publishing-branches (&optional commit)
(seq-filter (##magit-rev-ancestor-p (or commit "HEAD") %)
(defun magit-list-publishing-branches (&optional rev)
(seq-filter (##magit-rev-ancestor-p (or rev "HEAD") %)
magit-published-branches))
(defun magit-list-merged-branches (&optional commit &rest args)
(magit-list-related-branches "--merged" commit args))
(defun magit-list-merged-branches (&optional rev &rest args)
(magit-list-related-branches "--merged" rev args))
(defun magit-list-unmerged-branches (&optional commit &rest args)
(magit-list-related-branches "--no-merged" commit args))
(defun magit-list-unmerged-branches (&optional rev &rest args)
(magit-list-related-branches "--no-merged" rev args))
(defun magit-list-unmerged-to-upstream-branches ()
(seq-filter (##and-let* ((upstream (magit-get-upstream-branch %)))
(member % (magit-list-unmerged-branches upstream)))
(magit-list-local-branch-names)))
(defun magit-list-branches-pointing-at (commit)
(defun magit-list-branches-pointing-at (rev)
(let ((re (format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'"
(magit-rev-verify commit))))
(magit-rev-verify rev))))
(seq-keep (##and (string-match re %)
(let ((name (match-string 2 %)))
(and (not (string-suffix-p "HEAD" name))
@@ -2285,16 +2285,16 @@ If `first-parent' is set, traverse only first parents."
(defun magit-rev-abbrev (rev)
(magit-rev-parse (magit-abbrev-arg "short") rev))
(defun magit-commit-children (commit &optional args)
(defun magit-commit-children (rev &optional args)
(seq-keep (lambda (line)
(pcase-let ((`(,child . ,parents) (split-string line " ")))
(and (member commit parents) child)))
(and (member rev parents) child)))
(magit-git-lines "log" "--format=%H %P"
(or args (list "--branches" "--tags" "--remotes"))
"--not" commit)))
"--not" rev)))
(defun magit-commit-parents (commit)
(and-let* ((str (magit-git-string "rev-list" "-1" "--parents" commit)))
(defun magit-commit-parents (rev)
(and-let* ((str (magit-git-string "rev-list" "-1" "--parents" rev)))
(cdr (split-string str))))
(defun magit-patch-id (rev)
@@ -2444,14 +2444,14 @@ and this option only controls what face is used.")
(defun magit-object-type (object)
(magit-git-string "cat-file" "-t" object))
(defmacro magit-with-blob (commit file &rest body)
(defmacro magit-with-blob (rev file &rest body)
(declare (indent 2)
(debug (form form body)))
`(magit--with-temp-process-buffer
(let ((buffer-file-name ,file))
(save-excursion
(magit-git-insert "cat-file" "-p"
(concat ,commit ":" buffer-file-name)))
(concat ,rev ":" buffer-file-name)))
(decode-coding-inserted-region
(point-min) (point-max) buffer-file-name t nil nil t)
,@body)))

18
lisp/magit/magit-log.el
View File

@@ -780,7 +780,7 @@ restrict the log to the lines that the region touches."
(user-error "Buffer isn't visiting a file")))
;;;###autoload
(defun magit-log-trace-definition (file fn rev)
(defun magit-log-trace-definition (file fn commit)
"Show log for the definition at point."
(interactive (list (or (magit-file-relative-name)
(user-error "Buffer isn't visiting a file"))
@@ -791,7 +791,7 @@ restrict the log to the lines that the region touches."
"HEAD")))
(require 'magit)
(magit-log-setup-buffer
(list rev)
(list commit)
(cons (format "-L:%s%s:%s"
(string-replace ":" "\\:" (regexp-quote fn))
(if (derived-mode-p 'lisp-mode 'emacs-lisp-mode)
@@ -937,10 +937,10 @@ is displayed in the current frame."
"\\[magit-log-double-commit-limit] first"))))
(user-error "Parent %s does not exist" parent-rev)))))
(defun magit-log-move-to-revision (rev)
"Read a revision and move to it in current log buffer.
(defun magit-log-move-to-revision (commit)
"Read a commit and move to it in current log buffer.
If the chosen reference or revision isn't being displayed in
If the chosen reference or commit isn't being displayed in
the current log buffer, then inform the user about that and do
nothing else.
@@ -962,8 +962,8 @@ of the current repository first; creating it if necessary."
(pop-to-buffer-same-window buf)))
(t
(apply #'magit-log-all-branches (magit-log-arguments))))
(unless (magit-log-goto-commit-section (magit-rev-abbrev rev))
(user-error "%s isn't visible in the current log buffer" rev))))
(unless (magit-log-goto-commit-section (magit-rev-abbrev commit))
(user-error "%s isn't visible in the current log buffer" commit))))
;;;; Shortlog Commands
@@ -996,12 +996,12 @@ of the current repository first; creating it if necessary."
(switch-to-buffer-other-window (current-buffer))))))
;;;###autoload
(defun magit-shortlog-since (rev args)
(defun magit-shortlog-since (commit args)
"Show a history summary for commits since REV."
(interactive
(list (magit-read-branch-or-commit "Shortlog since" (magit-get-current-tag))
(transient-args 'magit-shortlog)))
(magit-git-shortlog (concat rev "..") args))
(magit-git-shortlog (concat commit "..") args))
;;;###autoload
(defun magit-shortlog-range (rev-or-range args)

6
lisp/magit/magit-pkg.el
View File

@@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; lexical-binding: nil -*-
(define-package "magit" "20250704.2300"
(define-package "magit" "20250711.1903"
"A Git porcelain inside Emacs."
'((emacs "27.1")
(compat "30.1")
@@ -9,8 +9,8 @@
(transient "0.9.3")
(with-editor "3.4.4"))
:url "https://github.com/magit/magit"
:commit "5b820a1d1e94649e0f218362286d520d9f29ac2c"
:revdesc "5b820a1d1e94"
:commit "d8b4690900a00bc32e9f4dd0fb71b96614a96b51"
:revdesc "d8b4690900a0"
:keywords '("git" "tools" "vc")
:authors '(("Marius Vollmer" . "marius.vollmer@gmail.com")
("Jonas Bernoulli" . "emacs.magit@jonas.bernoulli.dev"))

13
lisp/magit/magit-process.el
View File

@@ -464,7 +464,7 @@ After Git returns, the current buffer (if it is a Magit buffer)
as well as the current repository's status buffer are refreshed.
Process output goes into a new section in the buffer returned by
`magit-process-buffer'."
`magit-process-buffer'. Return the exit code."
(let ((magit--refresh-cache (list (cons 0 0))))
(prog1 (magit-call-git args)
(when (member (car args) '("init" "clone"))
@@ -483,7 +483,7 @@ The arguments ARGS specify arguments to Git, they are flattened
before use.
Process output goes into a new section in the buffer returned by
`magit-process-buffer'."
`magit-process-buffer'. Return the exit code."
(run-hooks 'magit-pre-call-git-hook)
(let ((default-process-coding-system (magit--process-coding-system)))
(apply #'magit-call-process
@@ -493,7 +493,7 @@ Process output goes into a new section in the buffer returned by
(defun magit-call-process (program &rest args)
"Call PROGRAM synchronously in a separate process.
Process output goes into a new section in the buffer returned by
`magit-process-buffer'."
`magit-process-buffer'. Return the exit code."
(pcase-let ((`(,process-buf . ,section)
(magit-process-setup program args)))
(magit-process-finish
@@ -514,8 +514,9 @@ ensure unix eol conversion."
(defun magit-process-file (process &optional infile buffer display &rest args)
"Process files synchronously in a separate process.
Similar to `process-file' but temporarily enable Cygwin's
\"noglob\" option during the call and ensure unix eol conversion."
Return the exit code. Similar to `process-file' but temporarily
enable Cygwin's \"noglob\" option during the call and ensure unix
eol conversion."
(when magit-process-record-invocations
(let ((messages-buffer-name magit-process-record-buffer-name)
(inhibit-message t))
@@ -552,7 +553,7 @@ ARGS is flattened and then used as arguments to Git.
The current buffer's content is used as the process's standard
input. The buffer is assumed to be temporary and thus OK to
modify.
modify. Return the exit code.
Function `magit-git-executable' specifies the Git executable and
option `magit-git-global-arguments' specifies constant arguments.

6
lisp/magit/magit-refs.el
View File

@@ -804,9 +804,9 @@ line is inserted at all."
(message "No cherries for %s" ref)
(magit-make-margin-overlay)))))
(defun magit-refs--format-margin (commit)
(if-let ((line (magit-rev-format "%cN%x00%ct" commit)))
(apply #'magit-log-format-margin commit (split-string line "\0"))
(defun magit-refs--format-margin (rev)
(if-let ((line (magit-rev-format "%cN%x00%ct" rev)))
(apply #'magit-log-format-margin rev (split-string line "\0"))
(magit-make-margin-overlay)))
;;; _

6
lisp/magit/magit-reset.el
View File

@@ -55,14 +55,14 @@
;;;###autoload
(defun magit-reset-soft (commit)
"Reset the `HEAD' to COMMIT, but not the index and working tree.
\n(git reset --soft REVISION)"
\n(git reset --soft COMMIT)"
(interactive (list (magit-reset-read-branch-or-commit "Soft reset %s to")))
(magit-reset-internal "--soft" commit))
;;;###autoload
(defun magit-reset-hard (commit)
"Reset the `HEAD', index, and working tree to COMMIT.
\n(git reset --hard REVISION)"
\n(git reset --hard COMMIT)"
(interactive (list (magit-reset-read-branch-or-commit
(concat (magit--propertize-face "Hard" 'bold)
" reset %s to"))))
@@ -71,7 +71,7 @@
;;;###autoload
(defun magit-reset-keep (commit)
"Reset the `HEAD' and index to COMMIT, while keeping uncommitted changes.
\n(git reset --keep REVISION)"
\n(git reset --keep COMMIT)"
(interactive (list (magit-reset-read-branch-or-commit "Reset %s to")))
(magit-reset-internal "--keep" commit))

8
lisp/magit/magit-stash.el
View File

@@ -450,8 +450,8 @@ Then apply STASH, dropping it if it applies cleanly."
((not worktree) "staged")
(t "local"))))))
(defun magit-stash-store (message ref commit)
(magit-update-ref ref message commit))
(defun magit-stash-store (message ref rev)
(magit-update-ref ref message rev))
(defun magit-stash-create (message index worktree untracked)
(unless (magit-rev-parse "--verify" "HEAD")
@@ -637,8 +637,8 @@ See also info node `(magit)Section Movement'."
(cl-defmethod magit-buffer-value (&context (major-mode magit-stash-mode))
magit-buffer-revision)
(defun magit-stash-insert-section (commit range message &optional files)
(magit-insert-section (commit commit)
(defun magit-stash-insert-section (rev range message &optional files)
(magit-insert-section (commit rev)
(magit-insert-heading message)
(magit--insert-diff nil
"diff" range "-p" "--no-prefix" magit-buffer-diff-args

6
lisp/magit/magit-tag.el
View File

@@ -62,8 +62,8 @@
:history-key 'magit:--gpg-sign)
;;;###autoload
(defun magit-tag-create (name rev &optional args)
"Create a new tag with the given NAME at REV.
(defun magit-tag-create (name commit &optional args)
"Create a new tag with the given NAME at COMMIT.
With a prefix argument annotate the tag.
\n(git tag [--annotate] NAME REV)"
(interactive (list (magit-read-tag "Tag name")
@@ -72,7 +72,7 @@ With a prefix argument annotate the tag.
(when current-prefix-arg
(cl-pushnew "--annotate" args :test #'equal))
args)))
(magit-run-git-with-editor "tag" args name rev))
(magit-run-git-with-editor "tag" args name commit))
;;;###autoload
(defun magit-tag-delete (tags)

4
lisp/magit/magit.el
View File

@@ -17,8 +17,8 @@
;; Homepage: https://github.com/magit/magit
;; Keywords: git tools vc
;; Package-Version: 20250704.2300
;; Package-Revision: 5b820a1d1e94
;; Package-Version: 20250711.1903
;; Package-Revision: d8b4690900a0
;; Package-Requires: (
;; (emacs "27.1")
;; (compat "30.1")

93
lisp/magit/magit.info
View File

@@ -8474,6 +8474,9 @@ for git to complete before letting the user do something else. For
example after staging a change it is useful to wait until after the
refresh because that also automatically moves to the next change.
The synchronous functions return the exit code, while the
asynchronous functions return the process object.
-- Function: magit-call-git &rest args
Calls git synchronously with ARGS.
@@ -10099,8 +10102,8 @@ Appendix D Function and Command Index
* magit-builtin-completing-read: Completion Confirmation and the Selection.
(line 358)
* magit-bundle: Bundle. (line 8)
* magit-call-git: Calling Git. (line 135)
* magit-call-process: Calling Git. (line 138)
* magit-call-git: Calling Git. (line 138)
* magit-call-process: Calling Git. (line 141)
* magit-cancel-section: Section Plumbing. (line 72)
* magit-checkout: Branching. (line 97)
* magit-cherry: Logging. (line 382)
@@ -10272,7 +10275,7 @@ Appendix D Function and Command Index
* magit-generate-buffer-name-default-function: Modes and Buffers.
(line 141)
* magit-get-section: Section Plumbing. (line 130)
* magit-git: Calling Git. (line 153)
* magit-git: Calling Git. (line 156)
* magit-git-command: Running Git. (line 97)
* magit-git-command-topdir: Running Git. (line 89)
* magit-git-exit-code: Calling Git. (line 37)
@@ -10287,7 +10290,7 @@ Appendix D Function and Command Index
* magit-git-string: Calling Git. (line 59)
* magit-git-success: Calling Git. (line 40)
* magit-git-true: Calling Git. (line 48)
* magit-git-wash: Calling Git. (line 157)
* magit-git-wash: Calling Git. (line 160)
* magit-go-backward: Logging. (line 116)
* magit-go-backward <1>: Diffing. (line 173)
* magit-go-forward: Logging. (line 119)
@@ -10506,11 +10509,11 @@ Appendix D Function and Command Index
* magit-revert-and-commit: Cherry Picking. (line 106)
* magit-revert-no-commit: Cherry Picking. (line 111)
* magit-run: Running Git. (line 85)
* magit-run-git: Calling Git. (line 141)
* magit-run-git-async: Calling Git. (line 166)
* magit-run-git: Calling Git. (line 144)
* magit-run-git-async: Calling Git. (line 169)
* magit-run-git-gui: Running Git. (line 131)
* magit-run-git-with-editor: Calling Git. (line 178)
* magit-run-git-with-input: Calling Git. (line 144)
* magit-run-git-with-editor: Calling Git. (line 181)
* magit-run-git-with-input: Calling Git. (line 147)
* magit-run-gitk: Running Git. (line 122)
* magit-run-gitk-all: Running Git. (line 125)
* magit-run-gitk-branches: Running Git. (line 128)
@@ -10580,8 +10583,8 @@ Appendix D Function and Command Index
(line 63)
* magit-stage-modified: Staging and Unstaging.
(line 36)
* magit-start-git: Calling Git. (line 189)
* magit-start-process: Calling Git. (line 207)
* magit-start-git: Calling Git. (line 192)
* magit-start-process: Calling Git. (line 210)
* magit-stash: Stashing. (line 9)
* magit-stash-apply: Stashing. (line 52)
* magit-stash-both: Stashing. (line 14)
@@ -10800,7 +10803,7 @@ Appendix E Variable Index
* magit-prefer-remote-upstream: Branching. (line 431)
* magit-prefix-use-buffer-arguments: Transient Arguments and Buffer Variables.
(line 65)
* magit-process-raise-error: Calling Git. (line 232)
* magit-process-raise-error: Calling Git. (line 235)
* magit-pull-or-fetch: Fetching. (line 52)
* magit-reflog-margin: Logging. (line 344)
* magit-refresh-args: Refreshing Buffers. (line 52)
@@ -10841,7 +10844,7 @@ Appendix E Variable Index
* magit-status-sections-hook: Status Buffer. (line 122)
* magit-status-show-untracked-files: Status Buffer. (line 197)
* magit-submodule-list-columns: Submodules. (line 25)
* magit-this-process: Calling Git. (line 228)
* magit-this-process: Calling Git. (line 231)
* magit-uniquify-buffer-names: Modes and Buffers. (line 190)
* magit-unstage-committed: Staging and Unstaging.
(line 52)
@@ -11016,39 +11019,39 @@ Node: Plumbing361017
Node: Calling Git361842
Ref: Getting a Value from Git363301
Ref: Calling Git for Effect366913
Node: Section Plumbing372699
Ref: Creating Sections372851
Ref: Section Selection376644
Ref: Matching Sections378317
Node: Refreshing Buffers384131
Node: Conventions387271
Ref: Theming Faces387435
Node: FAQ395468
Node: FAQ - How to ...?395904
Ref: How to pronounce Magit?396037
Ref: How to show git's output?396729
Ref: How to install the gitman info manual?397346
Ref: How to show diffs for gpg-encrypted files?398151
Ref: How does branching and pushing work?398560
Ref: Should I disable VC?398724
Node: FAQ - Issues and Errors399207
Ref: Magit is slow399352
Ref: I changed several thousand files at once and now Magit is unusable399498
Ref: I am having problems committing400037
Ref: I am using MS Windows and cannot push with Magit400302
Ref: I am using macOS and SOMETHING works in shell but not in Magit400700
Ref: Expanding a file to show the diff causes it to disappear401287
Ref: Point is wrong in the COMMIT_EDITMSG buffer401637
Ref: The mode-line information isn't always up-to-date402461
Ref: A branch and tag sharing the same name breaks SOMETHING403292
Ref: My Git hooks work on the command-line but not inside Magit403940
Ref: git-commit-mode isn't used when committing from the command-line404532
Ref: Point ends up inside invisible text when jumping to a file-visiting buffer406520
Ref: I am no longer able to save popup defaults407112
Node: Debugging Tools407907
Node: Keystroke Index411842
Node: Function and Command Index449938
Node: Variable Index501594
Node: Section Plumbing372811
Ref: Creating Sections372963
Ref: Section Selection376756
Ref: Matching Sections378429
Node: Refreshing Buffers384243
Node: Conventions387383
Ref: Theming Faces387547
Node: FAQ395580
Node: FAQ - How to ...?396016
Ref: How to pronounce Magit?396149
Ref: How to show git's output?396841
Ref: How to install the gitman info manual?397458
Ref: How to show diffs for gpg-encrypted files?398263
Ref: How does branching and pushing work?398672
Ref: Should I disable VC?398836
Node: FAQ - Issues and Errors399319
Ref: Magit is slow399464
Ref: I changed several thousand files at once and now Magit is unusable399610
Ref: I am having problems committing400149
Ref: I am using MS Windows and cannot push with Magit400414
Ref: I am using macOS and SOMETHING works in shell but not in Magit400812
Ref: Expanding a file to show the diff causes it to disappear401399
Ref: Point is wrong in the COMMIT_EDITMSG buffer401749
Ref: The mode-line information isn't always up-to-date402573
Ref: A branch and tag sharing the same name breaks SOMETHING403404
Ref: My Git hooks work on the command-line but not inside Magit404052
Ref: git-commit-mode isn't used when committing from the command-line404644
Ref: Point ends up inside invisible text when jumping to a file-visiting buffer406632
Ref: I am no longer able to save popup defaults407224
Node: Debugging Tools408019
Node: Keystroke Index411954
Node: Function and Command Index450050
Node: Variable Index501706

End Tag Table