diff options
Diffstat (limited to 'elpa/magit-20200728.45/magit.info-2')
| -rw-r--r-- | elpa/magit-20200728.45/magit.info-2 | 3526 |
1 files changed, 0 insertions, 3526 deletions
diff --git a/elpa/magit-20200728.45/magit.info-2 b/elpa/magit-20200728.45/magit.info-2 deleted file mode 100644 index 8df6f30..0000000 --- a/elpa/magit-20200728.45/magit.info-2 +++ /dev/null @@ -1,3526 +0,0 @@ -This is magit.info, produced by makeinfo version 6.5 from magit.texi. - - Copyright (C) 2015-2020 Jonas Bernoulli <jonas@bernoul.li> - - You can redistribute this document and/or modify it under the terms - of the GNU General Public License as published by the Free Software - Foundation, either version 3 of the License, or (at your option) - any later version. - - This document is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - -INFO-DIR-SECTION Emacs -START-INFO-DIR-ENTRY -* Magit: (magit). Using Git from Emacs with Magit. -END-INFO-DIR-ENTRY - - -File: magit.info, Node: Wip Modes, Next: Minor Mode for Buffers Visiting Files, Prev: Common Commands, Up: Miscellaneous - -8.7 Wip Modes -============= - -Git keeps *committed* changes around long enough for users to recover -changes they have accidentally deleted. It does so by not garbage -collecting any committed but no longer referenced objects for a certain -period of time, by default 30 days. - - But Git does *not* keep track of *uncommitted* changes in the working -tree and not even the index (the staging area). Because Magit makes it -so convenient to modify uncommitted changes, it also makes it easy to -shoot yourself in the foot in the process. - - For that reason Magit provides a global mode that saves *tracked* -files to work-in-progress references after or before certain actions. -(At present untracked files are never saved and for technical reasons -nothing is saved before the first commit has been created). - - Two separate work-in-progress references are used to track the state -of the index and of the working tree: ‘refs/wip/index/<branchref>’ and -‘refs/wip/wtree/<branchref>’, where ‘<branchref>’ is the full ref of the -current branch, e.g. ‘refs/heads/master’. When the ‘HEAD’ is detached -then ‘HEAD’ is used in place of ‘<branchref>’. - - Checking out another branch (or detaching ‘HEAD’) causes the use of -different wip refs for subsequent changes. - - -- User Option: magit-wip-mode - - When this mode is enabled, then uncommitted changes are committed - to dedicated work-in-progress refs whenever appropriate (i.e. when - dataloss would be a possibility otherwise). - - Setting this variable directly does not take effect; either use the - Custom interface to do so or call the respective mode function. - - For historic reasons this mode is implemented on top of four other - ‘magit-wip-*’ modes, which can also be used individually, if you - want finer control over when the wip refs are updated; but that is - discouraged. See *note Legacy Wip Modes::. - - To view the log for a branch and its wip refs use the commands -‘magit-wip-log’ and ‘magit-wip-log-current’. You should use ‘--graph’ -when using these commands. - - -- Command: magit-wip-log - - This command shows the log for a branch and its wip refs. With a - negative prefix argument only the worktree wip ref is shown. - - The absolute numeric value of the prefix argument controls how many - "branches" of each wip ref are shown. This is only relevant if the - value of ‘magit-wip-merge-branch’ is ‘nil’. - - -- Command: magit-wip-log-current - - This command shows the log for the current branch and its wip refs. - With a negative prefix argument only the worktree wip ref is shown. - - The absolute numeric value of the prefix argument controls how many - "branches" of each wip ref are shown. This is only relevant if the - value of ‘magit-wip-merge-branch’ is ‘nil’. - -‘X w’ (‘magit-reset-worktree’) - - This command resets the working tree to some commit read from the - user and defaulting to the commit at point, while keeping the - ‘HEAD’ and index as-is. - - This can be used to restore files to the state committed to a wip - ref. Note that this will discard any unstaged changes that might - have existed before invoking this command (but of course only after - committing that to the working tree wip ref). - - Note that even if you enable ‘magit-wip-mode’ this won’t give you -perfect protection. The most likely scenario for losing changes despite -the use of ‘magit-wip-mode’ is making a change outside Emacs and then -destroying it also outside Emacs. In some such a scenario, Magit, being -an Emacs package, didn’t get the opportunity to keep you from shooting -yourself in the foot. - - When you are unsure whether Magit did commit a change to the wip -refs, then you can explicitly request that all changes to all tracked -files are being committed. - -‘M-x magit-wip-commit’ (‘magit-wip-commit’) - - This command commits all changes to all tracked files to the index - and working tree work-in-progress refs. Like the modes described - above, it does not commit untracked files, but it does check all - tracked files for changes. Use this command when you suspect that - the modes might have overlooked a change made outside Emacs/Magit. - - -- User Option: magit-wip-namespace - - The namespace used for work-in-progress refs. It has to end with a - slash. The wip refs are named ‘<namespace>index/<branchref>’ and - ‘<namespace>wtree/<branchref>’. When snapshots are created while - the ‘HEAD’ is detached then ‘HEAD’ is used in place of - ‘<branchref>’. - - -- User Option: magit-wip-mode-lighter - - Mode-line lighter for ‘magit-wip--mode’. - -* Menu: - -* Wip Graph:: -* Legacy Wip Modes:: - - -File: magit.info, Node: Wip Graph, Next: Legacy Wip Modes, Up: Wip Modes - -8.7.1 Wip Graph ---------------- - - -- User Option: magit-wip-merge-branch - - This option controls whether the current branch is merged into the - wip refs after a new commit was created on the branch. - - If non-nil and the current branch has new commits, then it is - merged into the wip ref before creating a new wip commit. This - makes it easier to inspect wip history and the wip commits are - never garbage collected. - - If nil and the current branch has new commits, then the wip ref is - reset to the tip of the branch before creating a new wip commit. - With this setting wip commits are eventually garbage collected. - - When ‘magit-wip-merge-branch’ is ‘t’, then the history looks like -this: - - *--*--*--*--*--* refs/wip/index/refs/heads/master - / / / - A-----B-----C refs/heads/master - - When ‘magit-wip-merge-branch’ is ‘nil’, then creating a commit on the -real branch and then making a change causes the wip refs to be recreated -to fork from the new commit. But the old commits on the wip refs are -not lost. They are still available from the reflog. To make it easier -to see when the fork point of a wip ref was changed, an additional -commit with the message "restart autosaving" is created on it (‘xxO’ -commits below are such boundary commits). - - Starting with - - BI0---BI1 refs/wip/index/refs/heads/master - / - A---B refs/heads/master - \ - BW0---BW1 refs/wip/wtree/refs/heads/master - - and committing the staged changes and editing and saving a file would -result in - - BI0---BI1 refs/wip/index/refs/heads/master - / - A---B---C refs/heads/master - \ \ - \ CW0---CW1 refs/wip/wtree/refs/heads/master - \ - BW0---BW1 refs/wip/wtree/refs/heads/master@{2} - - The fork-point of the index wip ref is not changed until some change -is being staged. Likewise just checking out a branch or creating a -commit does not change the fork-point of the working tree wip ref. The -fork-points are not adjusted until there actually is a change that -should be committed to the respective wip ref. - - -File: magit.info, Node: Legacy Wip Modes, Prev: Wip Graph, Up: Wip Modes - -8.7.2 Legacy Wip Modes ----------------------- - -It is recommended that you use the mode ‘magit-wip-mode’ (which see) and -ignore the existence of the following modes, which are preserved for -historic reasons. - - Setting the following variables directly does not take effect; either -use the Custom interface to do so or call the respective mode functions. - - -- User Option: magit-wip-after-save-mode - - When this mode is enabled, then saving a buffer that visits a file - tracked in a Git repository causes its current state to be - committed to the working tree wip ref for the current branch. - - -- User Option: magit-wip-after-apply-mode - - When this mode is enabled, then applying (i.e. staging, unstaging, - discarding, reversing, and regularly applying) a change to a file - tracked in a Git repository causes its current state to be - committed to the index and/or working tree wip refs for the current - branch. - - If you only ever edit files using Emacs and only ever interact with -Git using Magit, then the above two modes should be enough to protect -each and every change from accidental loss. In practice nobody does -that. Two additional modes exists that do commit to the wip refs before -making changes that could cause the loss of earlier changes. - - -- User Option: magit-wip-before-change-mode - - When this mode is enabled, then certain commands commit the - existing changes to the files they are about to make changes to. - - -- User Option: magit-wip-initial-backup-mode - - When this mode is enabled, then the current version of a file is - committed to the worktree wip ref before the buffer visiting that - file is saved for the first time since the buffer was created. - - This backs up the same version of the file that ‘backup-buffer’ - would save. While ‘backup-buffer’ uses a backup file, this mode - uses the same worktree wip ref as used by the other Magit Wip - modes. Like ‘backup-buffer’, it only does this once; unless you - kill the buffer and visit the file again only one backup will be - created per Emacs session. - - This mode ignores the variables that affect ‘backup-buffer’ and can - be used along-side that function, which is recommended because it - only backs up files that are tracked in a Git repository. - - -- User Option: magit-wip-after-save-local-mode-lighter - - Mode-line lighter for ‘magit-wip-after-save-local-mode’. - - -- User Option: magit-wip-after-apply-mode-lighter - - Mode-line lighter for ‘magit-wip-after-apply-mode’. - - -- User Option: magit-wip-before-change-mode-lighter - - Mode-line lighter for ‘magit-wip-before-change-mode’. - - -- User Option: magit-wip-initial-backup-mode-lighter - - Mode-line lighter for ‘magit-wip-initial-backup-mode’. - - -File: magit.info, Node: Minor Mode for Buffers Visiting Files, Next: Minor Mode for Buffers Visiting Blobs, Prev: Wip Modes, Up: Miscellaneous - -8.8 Minor Mode for Buffers Visiting Files -========================================= - -The minor-mode ‘magit-file-mode’ enables certain Magit features in -file-visiting buffers belonging to a Git repository. The globalized -variant ‘global-magit-file-mode’ enables the local mode in all such -buffers. It is enabled by default. Currently the local mode only -establishes a few key bindings, but this might be extended in the -future. - - -- User Option: global-magit-file-mode - - Whether to establish certain Magit key bindings in all - file-visiting buffers belonging to any Git repository. This is - enabled by default. This globalized mode turns on the local - minor-mode ‘magit-file-mode’ in all suitable buffers. - - -- Variable: magit-file-mode-map - - This keymap is used by the local minor-mode ‘magit-file-mode’ and - establishes the key bindings described below. - - Note that the default binding for ‘magit-file-dispatch’ is very - cumbersome to use and that we recommend that you add a better - binding. - - Instead of ‘C-c M-g’ I would have preferred to use ‘C-c g’ because - (1) it is similar to ‘C-x g’ (the recommended global binding for - ‘~magit-status’), (2) we cannot use ‘C-c C-g’ because we have been - recommending that that be bound to ‘magit-dispatch’ for a long - time, (3) we cannot use ‘C-x C-g’ because that is a convenient way - of aborting the incomplete key sequence ‘C-x’, and most importantly - (4) it would make it much easier to type the next key (a suffix - binding) because most of those are letters. - - For example ‘C-c g b’ is much easier to type than ‘C-c M-g b’. For - suffix bindings that use uppercase letters, the default is just - horrible—having to use e.g. ‘C-c M-g B’ (‘Control+c Meta+g - Shift+b’) would drive anyone up the walls (or to Vim). - - However ‘C-c LETTER’ bindings are reserved for users (see *note - (elisp)Key Binding Conventions::). Packages are forbidden from - using those. Doing so anyway is considered heresy. Therefore if - you want a better binding, you have to add it yourself: - - (define-key magit-file-mode-map - (kbd "C-c g") 'magit-file-dispatch) - - The key bindings shown below assume that you have not improved the -binding for ‘magit-file-dispatch’. - -‘C-c M-g’ (‘magit-file-dispatch’) - - This transient prefix command binds the following suffix commands - and displays them in a temporary buffer until a suffix is invoked. - -‘C-c M-g s’ (‘magit-stage-file’) - - Stage all changes to the file being visited in the current buffer. - -‘C-c M-g u’ (‘magit-unstage-file’) - - Unstage all changes to the file being visited in the current - buffer. - -‘C-c M-g c’ (‘magit-commit’) - - This transient prefix command binds the following suffix commands - along with the appropriate infix arguments and displays them in a - temporary buffer until a suffix is invoked. See *note Initiating a - Commit::. - -‘C-c M-g D’ (‘magit-diff’) - - This transient prefix command binds several diff suffix commands - and infix arguments and displays them in a temporary buffer until a - suffix is invoked. See *note Diffing::. - - This is the same command that ‘d’ is bound to in Magit buffers. If - this command is invoked from a file-visiting buffer, then the - initial value of the option (‘--’) that limits the diff to certain - file(s) is set to the visited file. - -‘C-c M-g d’ (‘magit-diff-buffer-file’) - - This command shows the diff for the file of blob that the current - buffer visits. - - -- User Option: magit-diff-buffer-file-locked - - This option controls whether ‘magit-diff-buffer-file’ uses a - dedicated buffer. See *note Modes and Buffers::. - -‘C-c M-g L’ (‘magit-log’) - - This transient prefix command binds several log suffix commands and - infix arguments and displays them in a temporary buffer until a - suffix is invoked. See *note Logging::. - - This is the same command that ‘l’ is bound to in Magit buffers. If - this command is invoked from a file-visiting buffer, then the - initial value of the option (‘--’) that limits the log to certain - file(s) is set to the visited file. - -‘C-c M-g l’ (‘magit-log-buffer-file’) - - This command shows the log for the file of blob that the current - buffer visits. Renames are followed when a prefix argument is used - or when ‘--follow’ is an active log argument. When the region is - active, the log is restricted to the selected line range. - -‘C-c M-g t’ (‘magit-log-trace-definition’) - - This command shows the log for the definition at point. - - -- User Option: magit-log-buffer-file-locked - - This option controls whether ‘magit-log-buffer-file’ uses a - dedicated buffer. See *note Modes and Buffers::. - -‘C-c M-g B’ (‘magit-blame’) - - This transient prefix command binds all blaming suffix commands - along with the appropriate infix arguments and displays them in a - temporary buffer until a suffix is invoked. - - For more information about this and the following commands also see - *note Blaming::. - - In addition to the ‘magit-blame’ sub-transient, the dispatch -transient also binds several blaming suffix commands directly. See -*note Blaming:: for information about those commands and bindings. - -‘C-c M-g e’ (‘magit-edit-line-commit’) - - This command makes the commit editable that added the current line. - - With a prefix argument it makes the commit editable that removes - the line, if any. The commit is determined using ‘git blame’ and - made editable using ‘git rebase --interactive’ if it is reachable - from ‘HEAD’, or by checking out the commit (or a branch that points - at it) otherwise. - -‘C-c M-g p’ (‘magit-blob-previous’) - - Visit the previous blob which modified the current file. - - There are a few additional commands that operate on a single file but -are not enabled in the file transient command by default: - - -- Command: magit-file-rename - - This command renames a file read from the user. - - -- Command: magit-file-delete - - This command deletes a file read from the user. - - -- Command: magit-file-untrack - - This command untracks a file read from the user. - - -- Command: magit-file-checkout - - This command updates a file in the working tree and index to the - contents from a revision. Both the revision and file are read from - the user. - - To enable them invoke the transient (‘C-c M-g’), enter "edit mode" -(‘C-x l’), set the "transient level" (‘C-x l’ again), enter ‘5’, and -leave edit mode (‘C-g’). Also see *note (transient)Enabling and -Disabling Suffixes::. - - -File: magit.info, Node: Minor Mode for Buffers Visiting Blobs, Prev: Minor Mode for Buffers Visiting Files, Up: Miscellaneous - -8.9 Minor Mode for Buffers Visiting Blobs -========================================= - -The ‘magit-blob-mode’ enables certain Magit features in blob-visiting -buffers. Such buffers can be created using ‘magit-find-file’ and some -of the commands mentioned below, which also take care of turning on this -minor mode. Currently this mode only establishes a few key bindings, -but this might be extended. - -‘p’ (‘magit-blob-previous’) - - Visit the previous blob which modified the current file. - -‘n’ (‘magit-blob-next’) - - Visit the next blob which modified the current file. - -‘q’ (‘magit-kill-this-buffer’) - - Kill the current buffer. - - -File: magit.info, Node: Customizing, Next: Plumbing, Prev: Miscellaneous, Up: Top - -9 Customizing -************* - -Both Git and Emacs are highly customizable. Magit is both a Git -porcelain as well as an Emacs package, so it makes sense to customize it -using both Git variables as well as Emacs options. However this -flexibility doesn’t come without problems, including but not limited to -the following. - - • Some Git variables automatically have an effect in Magit without - requiring any explicit support. Sometimes that is desirable - in - other cases, it breaks Magit. - - When a certain Git setting breaks Magit but you want to keep using - that setting on the command line, then that can be accomplished by - overriding the value for Magit only by appending something like - ‘("-c" "some.variable=compatible-value")’ to - ‘magit-git-global-arguments’. - - • Certain settings like ‘fetch.prune=true’ are respected by Magit - commands (because they simply call the respective Git command) but - their value is not reflected in the respective transient buffers. - In this case the ‘--prune’ argument in ‘magit-fetch’ might be - active or inactive, but that doesn’t keep the Git variable from - being honored by the suffix commands anyway. So pruning might - happen despite the ‘--prune’ arguments being displayed in a way - that seems to indicate that no pruning will happen. - - I intend to address these and similar issues in a future release. - -* Menu: - -* Per-Repository Configuration:: -* Essential Settings:: - - -File: magit.info, Node: Per-Repository Configuration, Next: Essential Settings, Up: Customizing - -9.1 Per-Repository Configuration -================================ - -Magit can be configured on a per-repository level using both Git -variables as well as Emacs options. - - To set a Git variable for one repository only, simply set it in -‘/path/to/repo/.git/config’ instead of ‘$HOME/.gitconfig’ or -‘/etc/gitconfig’. See *note (gitman)git-config::. - - Similarly, Emacs options can be set for one repository only by -editing ‘/path/to/repo/.dir-locals.el’. See *note (emacs)Directory -Variables::. For example to disable automatic refreshes of -file-visiting buffers in just one huge repository use this: - - • ‘/path/to/huge/repo/.dir-locals.el’ - - ((nil . ((magit-refresh-buffers . nil)))) - - It might only be costly to insert certain information into Magit -buffers for repositories that are exceptionally large, in which case you -can disable the respective section inserters just for that repository: - - • ‘/path/to/tag/invested/repo/.dir-locals.el’ - - ((magit-status-mode - . ((eval . (magit-disable-section-inserter 'magit-insert-tags-header))))) - - -- Function: magit-disable-section-inserter fn - - This function disables the section inserter FN in the current - repository. It is only intended for use in ‘.dir-locals.el’ and - ‘.dir-locals-2.el’. - - If you want to apply the same settings to several, but not all, -repositories then keeping the repository-local config files in sync -would quickly become annoying. To avoid that you can create config -files for certain classes of repositories (e.g. "huge repositories") -and then include those files in the per-repository config files. For -example: - - • ‘/path/to/huge/repo/.git/config’ - - [include] - path = /path/to/huge-gitconfig - - • ‘/path/to/huge-gitconfig’ - - [status] - showUntrackedFiles = no - - • ‘$HOME/.emacs.d/init.el’ - - (dir-locals-set-class-variables 'huge-git-repository - '((nil . ((magit-refresh-buffers . nil))))) - - (dir-locals-set-directory-class - "/path/to/huge/repo/" 'huge-git-repository) - - -File: magit.info, Node: Essential Settings, Prev: Per-Repository Configuration, Up: Customizing - -9.2 Essential Settings -====================== - -The next two sections list and discuss several variables that many users -might want to customize, for safety and/or performance reasons. - -* Menu: - -* Safety:: -* Performance:: - - -File: magit.info, Node: Safety, Next: Performance, Up: Essential Settings - -9.2.1 Safety ------------- - -This section discusses various variables that you might want to change -(or *not* change) for safety reasons. - - Git keeps *committed* changes around long enough for users to recover -changes they have accidentally been deleted. It does not do the same -for *uncommitted* changes in the working tree and not even the index -(the staging area). Because Magit makes it so easy to modify -uncommitted changes, it also makes it easy to shoot yourself in the foot -in the process. For that reason Magit provides three global modes that -save *tracked* files to work-in-progress references after or before -certain actions. See *note Wip Modes::. - - These modes are not enabled by default because of performance -concerns. Instead a lot of potentially destructive commands require -confirmation every time they are used. In many cases this can be -disabled by adding a symbol to ‘magit-no-confirm’ (see *note Completion -and Confirmation::). If you enable the various wip modes then you -should add ‘safe-with-wip’ to this list. - - Similarly it isn’t necessary to require confirmation before moving a -file to the system trash - if you trashed a file by mistake then you can -recover it from there. Option ‘magit-delete-by-moving-to-trash’ -controls whether the system trash is used, which is the case by default. -Nevertheless, ‘trash’ isn’t a member of ‘magit-no-confirm’ - you might -want to change that. - - By default buffers visiting files are automatically reverted when the -visited file changes on disk. This isn’t as risky as it might seem, but -to make an informed decision you should see *note Risk of Reverting -Automatically::. - - -File: magit.info, Node: Performance, Prev: Safety, Up: Essential Settings - -9.2.2 Performance ------------------ - -After Magit has run ‘git’ for side-effects, it also refreshes the -current Magit buffer and the respective status buffer. This is -necessary because otherwise outdated information might be displayed -without the user noticing. Magit buffers are updated by recreating -their content from scratch, which makes updating simpler and less -error-prone, but also more costly. Keeping it simple and just -re-creating everything from scratch is an old design decision and -departing from that will require major refactoring. - - I plan to do that in time for the next major release. I also intend -to create logs and diffs asynchronously, which should also help a lot -but also requires major refactoring. - - Meanwhile you can tell Magit to only automatically refresh the -current Magit buffer, but not the status buffer. If you do that, then -the status buffer is only refreshed automatically if it is the current -buffer. - - (setq magit-refresh-status-buffer nil) - - You should also check whether any third-party packages have added -anything to ‘magit-refresh-buffer-hook’, ‘magit-status-refresh-hook’, -‘magit-pre-refresh-hook’, and ‘magit-post-refresh-hook’. If so, then -check whether those additions impact performance significantly. - - Magit can be told to refresh buffers verbosely using ‘M-x -magit-toggle-verbose-refresh’. Enabling this helps figuring out which -sections are bottlenecks. The additional output can be found in the -‘*Messages*’ buffer. - - Magit also reverts buffers for visited files located inside the -current repository when the visited file changes on disk. That is -implemented on top of ‘auto-revert-mode’ from the built-in library -‘autorevert’. To figure out whether that impacts performance, check -whether performance is significantly worse, when many buffers exist -and/or when some buffers visit files using TRAMP. If so, then this -should help. - - (setq auto-revert-buffer-list-filter - 'magit-auto-revert-repository-buffer-p) - - For alternative approaches see *note Automatic Reverting of -File-Visiting Buffers::. - - If you have enabled any features that are disabled by default, then -you should check whether they impact performance significantly. It’s -likely that they were not enabled by default because it is known that -they reduce performance at least in large repositories. - - If performance is only slow inside certain unusually large -repositories, then you might want to disable certain features on a -per-repository or per-repository-class basis only. See *note -Per-Repository Configuration::. For example it takes a long time to -determine the next and current tag in repository with exceptional -numbers of tags. It would therefore be a good idea to disable -‘magit-insert-tags-headers’, as explained at the mentioned node. - -* Menu: - -* Microsoft Windows Performance:: -* MacOS Performance:: - -Log Performance -............... - -When showing logs, Magit limits the number of commits initially shown in -the hope that this avoids unnecessary work. When using ‘--graph’ is -used, then this unfortunately does not have the desired effect for large -histories. Junio, Git’s maintainer, said on the git mailing list -(<http://www.spinics.net/lists/git/msg232230.html>): "‘--graph’ wants to -compute the whole history and the max-count only affects the output -phase after ‘--graph’ does its computation". - - In other words, it’s not that Git is slow at outputting the -differences, or that Magit is slow at parsing the output - the problem -is that Git first goes outside and has a smoke. - - We actually work around this issue by limiting the number of commits -not only by using ‘-<N>’ but by also using a range. But unfortunately -that’s not always possible. - - When more than a few thousand commits are shown, then the use of -‘--graph’ can slow things down. - - Using ‘--color --graph’ is even slower. Magit uses code that is part -of Emacs to turn control characters into faces. That code is pretty -slow and this is quite noticeable when showing a log with many branches -and merges. For that reason ‘--color’ is not enabled by default -anymore. Consider leaving it at that. - -Diff Performance -................ - -If diffs are slow, then consider turning off some optional diff features -by setting all or some of the following variables to ‘nil’: -‘magit-diff-highlight-indentation’, ‘magit-diff-highlight-trailing’, -‘magit-diff-paint-whitespace’, ‘magit-diff-highlight-hunk-body’, and -‘magit-diff-refine-hunk’. - - When showing a commit instead of some arbitrary diff, then some -additional information is displayed. Calculating this information can -be quite expensive given certain circumstances. If looking at a commit -using ‘magit-revision-mode’ takes considerably more time than looking at -the same commit in ‘magit-diff-mode’, then consider setting -‘magit-revision-insert-related-refs’ to ‘nil’. - - When you are often confronted with diffs that contain deleted files, -then you might want to enable the ‘--irreversible-delete’ argument. If -you do that then diffs still show that a file was deleted but without -also showing the complete deleted content of the file. This argument is -not available by default, see *note (transient)Enabling and Disabling -Suffixes::. Once you have done that you should enable it and save that -setting, see *note (transient)Saving Values::. You should do this in -both the diff (‘d’) and the diff refresh (‘D’) transient popups. - -Refs Buffer Performance -....................... - -When refreshing the "references buffer" is slow, then that’s usually -because several hundred refs are being displayed. The best way to -address that is to display fewer refs, obviously. - - If you are not, or only mildly, interested in seeing the list of -tags, then start by not displaying them: - - (remove-hook 'magit-refs-sections-hook 'magit-insert-tags) - - Then you should also make sure that the listed remote branches -actually all exist. You can do so by pruning branches which no longer -exist using ‘f-pa’. - -Committing Performance -...................... - -When you initiate a commit, then Magit by default automatically shows a -diff of the changes you are about to commit. For large commits this can -take a long time, which is especially distracting when you are -committing large amounts of generated data which you don’t actually -intend to inspect before committing. This behavior can be turned off -using: - - (remove-hook 'server-switch-hook 'magit-commit-diff) - - Then you can type ‘C-c C-d’ to show the diff when you actually want -to see it, but only then. Alternatively you can leave the hook alone -and just type ‘C-g’ in those cases when it takes too long to generate -the diff. If you do that, then you will end up with a broken diff -buffer, but doing it this way has the advantage that you usually get to -see the diff, which is useful because it increases the odds that you -spot potential issues. - - -File: magit.info, Node: Microsoft Windows Performance, Next: MacOS Performance, Up: Performance - -Microsoft Windows Performance -............................. - -In order to update the status buffer, ‘git’ has to be run a few dozen -times. That is problematic on Microsoft Windows, because that operating -system is exceptionally slow at starting processes. Sadly this is an -issue that can only be fixed by Microsoft itself, and they don’t appear -to be particularly interested in doing so. - - Beside the subprocess issue, there are also other Windows-specific -performance issues. Some of these have workarounds. The maintainers of -"Git for Windows" try to improve performance on Windows. Always use the -latest release in order to benefit from the latest performance tweaks. -Magit too tries to work around some Windows-specific issues. - - According to some sources, setting the following Git variables can -also help. - - git config --global core.preloadindex true # default since v2.1 - git config --global core.fscache true # default since v2.8 - git config --global gc.auto 256 - - You should also check whether an anti-virus program is affecting -performance. - - -File: magit.info, Node: MacOS Performance, Prev: Microsoft Windows Performance, Up: Performance - -MacOS Performance -................. - -Before Emacs 26.1 child processes were created using ‘fork’ on macOS. -That needlessly copied GUI resources, which is expensive. The result -was that forking took about 30 times as long on Darwin than on Linux, -and because Magit starts many ‘git’ processes that made quite a -difference. - - So make sure that you are using at least Emacs 26.1, in which case -the faster ‘vfork’ will be used. (The creation of child processes still -takes about twice as long on Darwin compared to Linux.) See (1) for -more information. - - On Catalina, and potentially other macOS releases, there may be a -performance problem where any action takes 20 times longer on Darwin -than on Linux. This can be fixed by setting ‘magit-git-executable’ to -the absolute path of the ‘git’ executable, instead of relying on -resolving the ‘$PATH’. - - ---------- Footnotes ---------- - - (1) -<https://lists.gnu.org/archive/html/bug-gnu-emacs/2017-04/msg00201.html> - - -File: magit.info, Node: Plumbing, Next: FAQ, Prev: Customizing, Up: Top - -10 Plumbing -*********** - -The following sections describe how to use several of Magit’s core -abstractions to extend Magit itself or implement a separate extension. - - A few of the low-level features used by Magit have been factored out -into separate libraries/packages, so that they can be used by other -packages, without having to depend on Magit. See *note -(with-editor)Top:: for information about ‘with-editor’. ‘transient’ -doesn’t have a manual yet. - - If you are trying to find an unused key that you can bind to a -command provided by your own Magit extension, then checkout -<https://github.com/magit/magit/wiki/Plugin-Dispatch-Key-Registry>. - -* Menu: - -* Calling Git:: -* Section Plumbing:: -* Refreshing Buffers:: -* Conventions:: - - -File: magit.info, Node: Calling Git, Next: Section Plumbing, Up: Plumbing - -10.1 Calling Git -================ - -Magit provides many specialized functions for calling Git. All of these -functions are defined in either ‘magit-git.el’ or ‘magit-process.el’ and -have one of the prefixes ‘magit-run-’, ‘magit-call-’, ‘magit-start-’, or -‘magit-git-’ (which is also used for other things). - - All of these functions accept an indefinite number of arguments, -which are strings that specify command line arguments for Git (or in -some cases an arbitrary executable). These arguments are flattened -before being passed on to the executable; so instead of strings they can -also be lists of strings and arguments that are ‘nil’ are silently -dropped. Some of these functions also require a single mandatory -argument before these command line arguments. - - Roughly speaking, these functions run Git either to get some value or -for side-effects. The functions that return a value are useful to -collect the information necessary to populate a Magit buffer, while the -others are used to implement Magit commands. - - The functions in the value-only group always run synchronously, and -they never trigger a refresh. The function in the side-effect group can -be further divided into subgroups depending on whether they run Git -synchronously or asynchronously, and depending on whether they trigger a -refresh when the executable has finished. - -* Menu: - -* Getting a Value from Git:: -* Calling Git for Effect:: - - -File: magit.info, Node: Getting a Value from Git, Next: Calling Git for Effect, Up: Calling Git - -10.1.1 Getting a Value from Git -------------------------------- - -These functions run Git in order to get a value, an exit status, or -output. Of course you could also use them to run Git commands that have -side-effects, but that should be avoided. - - -- Function: magit-git-exit-code &rest args - - Executes git with ARGS and returns its exit code. - - -- Function: magit-git-success &rest args - - Executes git with ARGS and returns ‘t’ if the exit code is ‘0’, - ‘nil’ otherwise. - - -- Function: magit-git-failure &rest args - - Executes git with ARGS and returns ‘t’ if the exit code is ‘1’, - ‘nil’ otherwise. - - -- Function: magit-git-true &rest args - - Executes git with ARGS and returns ‘t’ if the first line printed by - git is the string "true", ‘nil’ otherwise. - - -- Function: magit-git-false &rest args - - Executes git with ARGS and returns ‘t’ if the first line printed by - git is the string "false", ‘nil’ otherwise. - - -- Function: magit-git-insert &rest args - - Executes git with ARGS and inserts its output at point. - - -- Function: magit-git-string &rest args - - Executes git with ARGS and returns the first line of its output. - If there is no output or if it begins with a newline character, - then this returns ‘nil’. - - -- Function: magit-git-lines &rest args - - Executes git with ARGS and returns its output as a list of lines. - Empty lines anywhere in the output are omitted. - - -- Function: magit-git-items &rest args - - Executes git with ARGS and returns its null-separated output as a - list. Empty items anywhere in the output are omitted. - - If the value of option ‘magit-git-debug’ is non-nil and git exits - with a non-zero exit status, then warn about that in the echo area - and add a section containing git’s standard error in the current - repository’s process buffer. - - If an error occurs when using one of the above functions, then that -is usually due to a bug, i.e. using an argument which is not actually -supported. Such errors are usually not reported, but when they occur we -need to be able to debug them. - - -- User Option: magit-git-debug - - Whether to report errors that occur when using ‘magit-git-insert’, - ‘magit-git-string’, ‘magit-git-lines’, or ‘magit-git-items’. This - does not actually raise an error. Instead a message is shown in - the echo area, and git’s standard error is insert into a new - section in the current repository’s process buffer. - - -- Function: magit-git-str &rest args - - This is a variant of ‘magit-git-string’ that ignores the option - ‘magit-git-debug’. It is mainly intended to be used while handling - errors in functions that do respect that option. Using such a - function while handing an error could cause yet another error and - therefore lead to an infinite recursion. You probably won’t ever - need to use this function. - - -File: magit.info, Node: Calling Git for Effect, Prev: Getting a Value from Git, Up: Calling Git - -10.1.2 Calling Git for Effect ------------------------------ - -These functions are used to run git to produce some effect. Most Magit -commands that actually run git do so by using such a function. - - Because we do not need to consume git’s output when using these -functions, their output is instead logged into a per-repository buffer, -which can be shown using ‘$’ from a Magit buffer or ‘M-x magit-process’ -elsewhere. - - These functions can have an effect in two distinct ways. Firstly, -running git may change something, i.e. create or push a new commit. -Secondly, that change may require that Magit buffers are refreshed to -reflect the changed state of the repository. But refreshing isn’t -always desirable, so only some of these functions do perform such a -refresh after git has returned. - - Sometimes it is useful to run git asynchronously. For example, when -the user has just initiated a push, then there is no reason to make her -wait until that has completed. In other cases it makes sense to wait -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. - - -- Function: magit-call-git &rest args - - Calls git synchronously with ARGS. - - -- Function: magit-call-process program &rest args - - Calls PROGRAM synchronously with ARGS. - - -- Function: magit-run-git &rest args - - Calls git synchronously with ARGS and then refreshes. - - -- Function: magit-run-git-with-input input &rest args - - Calls git synchronously with ARGS and sends it INPUT on standard - input. - - INPUT should be a buffer or the name of an existing buffer. The - content of that buffer is used as the process’s standard input. - After the process returns a refresh is performed. - - As a special case, INPUT may also be nil. In that case the content - of the current buffer is used as standard input and *no* refresh is - performed. - - This function actually runs git asynchronously. But then it waits - for the process to return, so the function itself is synchronous. - - -- Function: magit-run-git-with-logfile file &rest args - - Calls git synchronously with ARGS. The process’s output is saved - in FILE. This is rarely useful and so this function might be - removed in the future. - - This function actually runs git asynchronously. But then it waits - for the process to return, so the function itself is synchronous. - - -- Function: magit-git &rest args - - Calls git synchronously with ARGS for side-effects only. This - function does not refresh the buffer. - - -- Function: magit-git-wash washer &rest args - - Execute Git with ARGS, inserting washed output at point. Actually - first insert the raw output at point. If there is no output call - ‘magit-cancel-section’. Otherwise temporarily narrow the buffer to - the inserted text, move to its beginning, and then call function - WASHER with ARGS as its sole argument. - - And now for the asynchronous variants. - - -- Function: magit-run-git-async &rest args - - Start Git, prepare for refresh, and return the process object. - ARGS is flattened and then used as arguments to Git. - - Display the command line arguments in the echo area. - - After Git returns some buffers are refreshed: the buffer that was - current when this function was called (if it is a Magit buffer and - still alive), as well as the respective Magit status buffer. - Unmodified buffers visiting files that are tracked in the current - repository are reverted if ‘magit-revert-buffers’ is non-nil. - - -- Function: magit-run-git-with-editor &rest args - - Export GIT_EDITOR and start Git. Also prepare for refresh and - return the process object. ARGS is flattened and then used as - arguments to Git. - - Display the command line arguments in the echo area. - - After Git returns some buffers are refreshed: the buffer that was - current when this function was called (if it is a Magit buffer and - still alive), as well as the respective Magit status buffer. - - -- Function: magit-start-git &rest args - - Start Git, prepare for refresh, and return the process object. - - If INPUT is non-nil, it has to be a buffer or the name of an - existing buffer. The buffer content becomes the processes standard - input. - - Option ‘magit-git-executable’ specifies the Git executable and - option ‘magit-git-global-arguments’ specifies constant arguments. - The remaining arguments ARGS specify arguments to Git. They are - flattened before use. - - After Git returns, some buffers are refreshed: the buffer that was - current when this function was called (if it is a Magit buffer and - still alive), as well as the respective Magit status buffer. - Unmodified buffers visiting files that are tracked in the current - repository are reverted if ‘magit-revert-buffers’ is non-nil. - - -- Function: magit-start-process &rest args - - Start PROGRAM, prepare for refresh, and return the process object. - - If optional argument INPUT is non-nil, it has to be a buffer or the - name of an existing buffer. The buffer content becomes the - processes standard input. - - The process is started using ‘start-file-process’ and then setup to - use the sentinel ‘magit-process-sentinel’ and the filter - ‘magit-process-filter’. Information required by these functions is - stored in the process object. When this function returns the - process has not started to run yet so it is possible to override - the sentinel and filter. - - After the process returns, ‘magit-process-sentinel’ refreshes the - buffer that was current when ‘magit-start-process’ was called (if - it is a Magit buffer and still alive), as well as the respective - Magit status buffer. Unmodified buffers visiting files that are - tracked in the current repository are reverted if - ‘magit-revert-buffers’ is non-nil. - - -- Variable: magit-this-process - - The child process which is about to start. This can be used to - change the filter and sentinel. - - -- Variable: magit-process-raise-error - - When this is non-nil, then ‘magit-process-sentinel’ raises an error - if git exits with a non-zero exit status. For debugging purposes. - - -File: magit.info, Node: Section Plumbing, Next: Refreshing Buffers, Prev: Calling Git, Up: Plumbing - -10.2 Section Plumbing -===================== - -* Menu: - -* Creating Sections:: -* Section Selection:: -* Matching Sections:: - - -File: magit.info, Node: Creating Sections, Next: Section Selection, Up: Section Plumbing - -10.2.1 Creating Sections ------------------------- - - -- Macro: magit-insert-section &rest args - - Insert a section at point. - - TYPE is the section type, a symbol. Many commands that act on the - current section behave differently depending on that type. Also if - a variable ‘magit-TYPE-section-map’ exists, then use that as the - text-property ‘keymap’ of all text belonging to the section (but - this may be overwritten in subsections). TYPE can also have the - form ‘(eval FORM)’ in which case FORM is evaluated at runtime. - - Optional VALUE is the value of the section, usually a string that - is required when acting on the section. - - When optional HIDE is non-nil collapse the section body by default, - i.e. when first creating the section, but not when refreshing the - buffer. Otherwise, expand it by default. This can be overwritten - using ‘magit-section-set-visibility-hook’. When a section is - recreated during a refresh, then the visibility of predecessor is - inherited and HIDE is ignored (but the hook is still honored). - - BODY is any number of forms that actually insert the section’s - heading and body. Optional NAME, if specified, has to be a symbol, - which is then bound to the struct of the section being inserted. - - Before BODY is evaluated the ‘start’ of the section object is set - to the value of ‘point’ and after BODY was evaluated its ‘end’ is - set to the new value of ‘point’; BODY is responsible for moving - ‘point’ forward. - - If it turns out inside BODY that the section is empty, then - ‘magit-cancel-section’ can be used to abort and remove all traces - of the partially inserted section. This can happen when creating a - section by washing Git’s output and Git didn’t actually output - anything this time around. - - -- Function: magit-insert-heading &rest args - - Insert the heading for the section currently being inserted. - - This function should only be used inside ‘magit-insert-section’. - - When called without any arguments, then just set the ‘content’ slot - of the object representing the section being inserted to a marker - at ‘point’. The section should only contain a single line when - this function is used like this. - - When called with arguments ARGS, which have to be strings, then - insert those strings at point. The section should not contain any - text before this happens and afterwards it should again only - contain a single line. If the ‘face’ property is set anywhere - inside any of these strings, then insert all of them unchanged. - Otherwise use the ‘magit-section-heading’ face for all inserted - text. - - The ‘content’ property of the section struct is the end of the - heading (which lasts from ‘start’ to ‘content’) and the beginning - of the body (which lasts from ‘content’ to ‘end’). If the value of - ‘content’ is nil, then the section has no heading and its body - cannot be collapsed. If a section does have a heading then its - height must be exactly one line, including a trailing newline - character. This isn’t enforced; you are responsible for getting it - right. The only exception is that this function does insert a - newline character if necessary. - - -- Function: magit-cancel-section - - Cancel the section currently being inserted. This exits the - innermost call to ‘magit-insert-section’ and removes all traces of - what has already happened inside that call. - - -- Function: magit-define-section-jumper sym title &optional value - - Define an interactive function to go to section SYM. TITLE is the - displayed title of the section. - - -File: magit.info, Node: Section Selection, Next: Matching Sections, Prev: Creating Sections, Up: Section Plumbing - -10.2.2 Section Selection ------------------------- - - -- Function: magit-current-section - - Return the section at point. - - -- Function: magit-region-sections &optional condition multiple - - Return a list of the selected sections. - - When the region is active and constitutes a valid section - selection, then return a list of all selected sections. This is - the case when the region begins in the heading of a section and - ends in the heading of the same section or in that of a sibling - section. If optional MULTIPLE is non-nil, then the region cannot - begin and end in the same section. - - When the selection is not valid, then return nil. In this case, - most commands that can act on the selected sections will instead - act on the section at point. - - When the region looks like it would in any other buffer then the - selection is invalid. When the selection is valid then the region - uses the ‘magit-section-highlight’ face. This does not apply to - diffs where things get a bit more complicated, but even here if the - region looks like it usually does, then that’s not a valid - selection as far as this function is concerned. - - If optional CONDITION is non-nil, then the selection not only has - to be valid; all selected sections additionally have to match - CONDITION, or nil is returned. See ‘magit-section-match’ for the - forms CONDITION can take. - - -- Function: magit-region-values &optional condition multiple - - Return a list of the values of the selected sections. - - Return the values that themselves would be returned by - ‘magit-region-sections’ (which see). - - -File: magit.info, Node: Matching Sections, Prev: Section Selection, Up: Section Plumbing - -10.2.3 Matching Sections ------------------------- - -‘M-x magit-describe-section-briefly’ (‘magit-describe-section-briefly’) - - Show information about the section at point. This command is - intended for debugging purposes. - - -- Function: magit-section-ident section - - Return an unique identifier for SECTION. The return value has the - form ‘((TYPE . VALUE)...)’. - - -- Function: magit-get-section ident &optional root - - Return the section identified by IDENT. IDENT has to be a list as - returned by ‘magit-section-ident’. - - -- Function: magit-section-match condition &optional section - - Return ‘t’ if SECTION matches CONDITION. SECTION defaults to the - section at point. If SECTION is not specified and there also is no - section at point, then return ‘nil’. - - CONDITION can take the following forms: - • ‘(CONDITION...)’ - - matches if any of the CONDITIONs matches. - - • ‘[CLASS...]’ - - matches if the section’s class is the same as the first CLASS - or a subclass of that; the section’s parent class matches the - second CLASS; and so on. - - • ‘[* CLASS...]’ - - matches sections that match ‘[CLASS...]’ and also recursively - all their child sections. - - • ‘CLASS’ - - matches if the section’s class is the same as CLASS or a - subclass of that; regardless of the classes of the parent - sections. - - Each CLASS should be a class symbol, identifying a class that - derives from ‘magit-section’. For backward compatibility CLASS can - also be a "type symbol". A section matches such a symbol if the - value of its ‘type’ slot is ‘eq’. If a type symbol has an entry in - ‘magit--section-type-alist’, then a section also matches that type - if its class is a subclass of the class that corresponds to the - type as per that alist. - - Note that it is not necessary to specify the complete section - lineage as printed by ‘magit-describe-section-briefly’, unless of - course you want to be that precise. - - -- Function: magit-section-value-if condition &optional section - - If the section at point matches CONDITION, then return its value. - - If optional SECTION is non-nil then test whether that matches - instead. If there is no section at point and SECTION is nil, then - return nil. If the section does not match, then return nil. - - See ‘magit-section-match’ for the forms CONDITION can take. - - -- Function: magit-section-case &rest clauses - - Choose among clauses on the type of the section at point. - - Each clause looks like (CONDITION BODY...). The type of the - section is compared against each CONDITION; the BODY forms of the - first match are evaluated sequentially and the value of the last - form is returned. Inside BODY the symbol ‘it’ is bound to the - section at point. If no clause succeeds or if there is no section - at point return nil. - - See ‘magit-section-match’ for the forms CONDITION can take. - Additionally a CONDITION of t is allowed in the final clause and - matches if no other CONDITION match, even if there is no section at - point. - - -- Variable: magit-root-section - - The root section in the current buffer. All other sections are - descendants of this section. The value of this variable is set by - ‘magit-insert-section’ and you should never modify it. - - For diff related sections a few additional tools exist. - - -- Function: magit-diff-type &optional section - - Return the diff type of SECTION. - - The returned type is one of the symbols ‘staged’, ‘unstaged’, - ‘committed’, or ‘undefined’. This type serves a similar purpose as - the general type common to all sections (which is stored in the - ‘type’ slot of the corresponding ‘magit-section’ struct) but takes - additional information into account. When the SECTION isn’t - related to diffs and the buffer containing it also isn’t a - diff-only buffer, then return nil. - - Currently the type can also be one of ‘tracked’ and ‘untracked’, - but these values are not handled explicitly in every place they - should be. A possible fix could be to just return nil here. - - The section has to be a ‘diff’ or ‘hunk’ section, or a section - whose children are of type ‘diff’. If optional SECTION is nil, - return the diff type for the current section. In buffers whose - major mode is ‘magit-diff-mode’ SECTION is ignored and the type is - determined using other means. In ‘magit-revision-mode’ buffers the - type is always ‘committed’. - - -- Function: magit-diff-scope &optional section strict - - Return the diff scope of SECTION or the selected section(s). - - A diff’s "scope" describes what part of a diff is selected, it is a - symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or - ‘list’. Do not confuse this with the diff "type", as returned by - ‘magit-diff-type’. - - If optional SECTION is non-nil, then return the scope of that, - ignoring the sections selected by the region. Otherwise return the - scope of the current section, or if the region is active and - selects a valid group of diff related sections, the type of these - sections, i.e. ‘hunks’ or ‘files’. If SECTION (or if the current - section that is nil) is a ‘hunk’ section and the region starts and - ends inside the body of a that section, then the type is ‘region’. - - If optional STRICT is non-nil then return nil if the diff type of - the section at point is ‘untracked’ or the section at point is not - actually a ‘diff’ but a ‘diffstat’ section. - - -File: magit.info, Node: Refreshing Buffers, Next: Conventions, Prev: Section Plumbing, Up: Plumbing - -10.3 Refreshing Buffers -======================= - -All commands that create a new Magit buffer or change what is being -displayed in an existing buffer do so by calling ‘magit-mode-setup’. -Among other things, that function sets the buffer local values of -‘default-directory’ (to the top-level of the repository), -‘magit-refresh-function’, and ‘magit-refresh-args’. - - Buffers are refreshed by calling the function that is the local value -of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’, -where ‘*’ may be something like ‘diff’) with the value of -‘magit-refresh-args’ as arguments. - - -- Macro: magit-mode-setup buffer switch-func mode refresh-func - &optional refresh-args - - This function displays and selects BUFFER, turns on MODE, and - refreshes a first time. - - This function displays and optionally selects BUFFER by calling - ‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as - arguments. Then it sets the local value of - ‘magit-refresh-function’ to REFRESH-FUNC and that of - ‘magit-refresh-args’ to REFRESH-ARGS. Finally it creates the - buffer content by calling REFRESH-FUNC with REFRESH-ARGS as - arguments. - - All arguments are evaluated before switching to BUFFER. - - -- Function: magit-mode-display-buffer buffer mode &optional - switch-function - - This function display BUFFER in some window and select it. BUFFER - may be a buffer or a string, the name of a buffer. The buffer is - returned. - - Unless BUFFER is already displayed in the selected frame, store the - previous window configuration as a buffer local value, so that it - can later be restored by ‘magit-mode-bury-buffer’. - - The buffer is displayed and selected using SWITCH-FUNCTION. If - that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s - major mode derives from ‘magit-mode’. Otherwise ‘switch-to-buffer’ - is used. - - -- Variable: magit-refresh-function - - The value of this buffer-local variable is the function used to - refresh the current buffer. It is called with ‘magit-refresh-args’ - as arguments. - - -- Variable: magit-refresh-args - - The list of arguments used by ‘magit-refresh-function’ to refresh - the current buffer. ‘magit-refresh-function’ is called with these - arguments. - - The value is usually set using ‘magit-mode-setup’, but in some - cases it’s also useful to provide commands that can change the - value. For example, the ‘magit-diff-refresh’ transient can be used - to change any of the arguments used to display the diff, without - having to specify again which differences should be shown, but - ‘magit-diff-more-context’, ‘magit-diff-less-context’ and - ‘magit-diff-default-context’ change just the ‘-U<N>’ argument. In - both case this is done by changing the value of this variable and - then calling this ‘magit-refresh-function’. - - -File: magit.info, Node: Conventions, Prev: Refreshing Buffers, Up: Plumbing - -10.4 Conventions -================ - -Also see *note Completion and Confirmation::. - -* Menu: - -* Theming Faces:: - - -File: magit.info, Node: Theming Faces, Up: Conventions - -10.4.1 Theming Faces --------------------- - -The default theme uses blue for local branches, green for remote -branches, and goldenrod (brownish yellow) for tags. When creating a new -theme, you should probably follow that example. If your theme already -uses other colors, then stick to that. - - In older releases these reference faces used to have a background -color and a box around them. The basic default faces no longer do so, -to make Magit buffers much less noisy, and you should follow that -example at least with regards to boxes. (Boxes were used in the past to -work around a conflict between the highlighting overlay and text -property backgrounds. That’s no longer necessary because highlighting -no longer causes other background colors to disappear.) Alternatively -you can keep the background color and/or box, but then have to take -special care to adjust ‘magit-branch-current’ accordingly. By default -it looks mostly like ‘magit-branch-local’, but with a box (by default -the former is the only face that uses a box, exactly so that it sticks -out). If the former also uses a box, then you have to make sure that it -differs in some other way from the latter. - - The most difficult faces to theme are those related to diffs, -headings, highlighting, and the region. There are faces that fall into -all four groups - expect to spend some time getting this right. - - The ‘region’ face in the default theme, in both the light and dark -variants, as well as in many other themes, distributed with Emacs or by -third-parties, is very ugly. It is common to use a background color -that really sticks out, which is ugly but if that were the only problem -then it would be acceptable. Unfortunately many themes also set the -foreground color, which ensures that all text within the region is -readable. Without doing that there might be cases where some foreground -color is too close to the region background color to still be readable. -But it also means that text within the region loses all syntax -highlighting. - - I consider the work that went into getting the ‘region’ face right to -be a good indicator for the general quality of a theme. My -recommendation for the ‘region’ face is this: use a background color -slightly different from the background color of the ‘default’ face, and -do not set the foreground color at all. So for a light theme you might -use a light (possibly tinted) gray as the background color of ‘default’ -and a somewhat darker gray for the background of ‘region’. That should -usually be enough to not collide with the foreground color of any other -face. But if some other faces also set a light gray as background -color, then you should also make sure it doesn’t collide with those (in -some cases it might be acceptable though). - - Magit only uses the ‘region’ face when the region is "invalid" by its -own definition. In a Magit buffer the region is used to either select -multiple sibling sections, so that commands which support it act on all -of these sections instead of just the current section, or to select -lines within a single hunk section. In all other cases, the section is -considered invalid and Magit won’t act on it. But such invalid sections -happen, either because the user has not moved point enough yet to make -it valid or because she wants to use a non-magit command to act on the -region, e.g. ‘kill-region’. - - So using the regular ‘region’ face for invalid sections is a feature. -It tells the user that Magit won’t be able to act on it. It’s -acceptable if that face looks a bit odd and even (but less so) if it -collides with the background colors of section headings and other things -that have a background color. - - Magit highlights the current section. If a section has subsections, -then all of them are highlighted. This is done using faces that have -"highlight" in their names. For most sections, -‘magit-section-highlight’ is used for both the body and the heading. -Like the ‘region’ face, it should only set the background color to -something similar to that of ‘default’. The highlight background color -must be different from both the ‘region’ background color and the -‘default’ background color. - - For diff related sections Magit uses various faces to highlight -different parts of the selected section(s). Note that hunk headings, -unlike all other section headings, by default have a background color, -because it is useful to have very visible separators between hunks. -That face ‘magit-diff-hunk-heading’, should be different from both -‘magit-diff-hunk-heading-highlight’ and ‘magit-section-highlight’, as -well as from ‘magit-diff-context’ and ‘magit-diff-context-highlight’. -By default we do that by changing the foreground color. Changing the -background color would lead to complications, and there are already -enough we cannot get around. (Also note that it is generally a good -idea for section headings to always be bold, but only for sections that -have subsections). - - When there is a valid region selecting diff-related sibling sections, -i.e. multiple files or hunks, then the bodies of all these sections use -the respective highlight faces, but additionally the headings instead -use one of the faces ‘magit-diff-file-heading-selection’ or -‘magit-diff-hunk-heading-selection’. These faces have to be different -from the regular highlight variants to provide explicit visual -indication that the region is active. - - When theming diff related faces, start by setting the option -‘magit-diff-refine-hunk’ to ‘all’. You might personally prefer to only -refine the current hunk or not use hunk refinement at all, but some of -the users of your theme want all hunks to be refined, so you have to -cater to that. - - (Also turn on ‘magit-diff-highlight-indentation’, -‘magit-diff-highlight-trailing’, and ‘magit-diff-paint-whitespace’; and -insert some whitespace errors into the code you use for testing.) - - For e.g. "added lines" you have to adjust three faces: -‘magit-diff-added’, ‘magit-diff-added-highlight’, and -‘smerge-refined-added’. Make sure that the latter works well with both -of the former, as well as ‘smerge-other’ and ‘diff-added’. Then do the -same for the removed lines, context lines, lines added by us, and lines -added by them. Also make sure the respective added, removed, and -context faces use approximately the same saturation for both the -highlighted and unhighlighted variants. Also make sure the file and -diff headings work nicely with context lines (e.g. make them look -different). Line faces should set both the foreground and the -background color. For example, for added lines use two different -greens. - - It’s best if the foreground color of both the highlighted and the -unhighlighted variants are the same, so you will need to have to find a -color that works well on the highlight and unhighlighted background, the -refine background, and the highlight context background. When there is -an hunk internal region, then the added- and removed-lines background -color is used only within that region. Outside the region the -highlighted context background color is used. This makes it easier to -see what is being staged. With an hunk internal region the hunk heading -is shown using ‘magit-diff-hunk-heading-selection’, and so are the thin -lines that are added around the lines that fall within the region. The -background color of that has to be distinct enough from the various -other involved background colors. - - Nobody said this would be easy. If your theme restricts itself to a -certain set of colors, then you should make an exception here. -Otherwise it would be impossible to make the diffs look good in each and -every variation. Actually you might want to just stick to the default -definitions for these faces. You have been warned. Also please note -that if you do not get this right, this will in some cases look to users -like bugs in Magit - so please do it right or not at all. - - -File: magit.info, Node: FAQ, Next: Debugging Tools, Prev: Plumbing, Up: Top - -Appendix A FAQ -************** - -The next two nodes lists frequently asked questions. For a list of -frequently *and recently* asked questions, i.e. questions that haven’t -made it into the manual yet, see -<https://github.com/magit/magit/wiki/FAQ>. - - Please also use the *note Debugging Tools::. - -* Menu: - -* FAQ - How to ...?:: -* FAQ - Issues and Errors:: - - -File: magit.info, Node: FAQ - How to ...?, Next: FAQ - Issues and Errors, Up: FAQ - -A.1 FAQ - How to ...? -===================== - -* Menu: - -* How to show git's output?:: -* How to install the gitman info manual?:: -* How to show diffs for gpg-encrypted files?:: -* How does branching and pushing work?:: -* Can Magit be used as ediff-version-control-package?:: -* Should I disable VC?:: - - -File: magit.info, Node: How to show git's output?, Next: How to install the gitman info manual?, Up: FAQ - How to ...? - -A.1.1 How to show git’s output? -------------------------------- - -To show the output of recently run git commands, press ‘$’ (or, if that -isn’t available, ‘M-x magit-process-buffer’). This will show a buffer -containing a section per git invocation; as always press ‘TAB’ to expand -or collapse them. - - By default, git’s output is only inserted into the process buffer if -it is run for side-effects. When the output is consumed in some way, -also inserting it into the process buffer would be too expensive. For -debugging purposes, it’s possible to do so anyway by setting -‘magit-git-debug’ to ‘t’. - - -File: magit.info, Node: How to install the gitman info manual?, Next: How to show diffs for gpg-encrypted files?, Prev: How to show git's output?, Up: FAQ - How to ...? - -A.1.2 How to install the gitman info manual? --------------------------------------------- - -Git’s manpages can be exported as an info manual called ‘gitman’. -Magit’s own info manual links to nodes in that manual instead of the -actual manpages because Info doesn’t support linking to manpages. - - Unfortunately some distributions do not install the ‘gitman’ manual -by default and you will have to install a separate documentation package -to get it. - - Magit patches Info adding the ability to visit links to the ‘gitman’ -Info manual by instead viewing the respective manpage. If you prefer -that approach, then set the value of ‘magit-view-git-manual-method’ to -one of the supported packages ‘man’ or ‘woman’, e.g.: - - (setq magit-view-git-manual-method 'man) - - -File: magit.info, Node: How to show diffs for gpg-encrypted files?, Next: How does branching and pushing work?, Prev: How to install the gitman info manual?, Up: FAQ - How to ...? - -A.1.3 How to show diffs for gpg-encrypted files? ------------------------------------------------- - -Git supports showing diffs for encrypted files, but has to be told to do -so. Since Magit just uses Git to get the diffs, configuring Git also -affects the diffs displayed inside Magit. - - git config --global diff.gpg.textconv "gpg --no-tty --decrypt" - echo "*.gpg filter=gpg diff=gpg" > .gitattributes - - -File: magit.info, Node: How does branching and pushing work?, Next: Can Magit be used as ediff-version-control-package?, Prev: How to show diffs for gpg-encrypted files?, Up: FAQ - How to ...? - -A.1.4 How does branching and pushing work? ------------------------------------------- - -Please see *note Branching:: and -<http://emacsair.me/2016/01/18/magit-2.4> - - -File: magit.info, Node: Can Magit be used as ediff-version-control-package?, Next: Should I disable VC?, Prev: How does branching and pushing work?, Up: FAQ - How to ...? - -A.1.5 Can Magit be used as ‘ediff-version-control-package’? ------------------------------------------------------------ - -No, it cannot. For that to work the functions ‘ediff-magit-internal’ -and ‘ediff-magit-merge-internal’ would have to be implemented, and they -are not. These two functions are only used by the three commands -‘ediff-revision’, ‘ediff-merge-revisions-with-ancestor’, and -‘ediff-merge-revisions’. - - These commands only delegate the task of populating buffers with -certain revisions to the "internal" functions. The equally important -task of determining which revisions are to be compared/merged is not -delegated. Instead this is done without any support whatsoever from the -version control package/system - meaning that the user has to enter the -revisions explicitly. Instead of implementing ‘ediff-magit-internal’ we -provide ‘magit-ediff-compare’, which handles both tasks like it is 2005. - - The other commands ‘ediff-merge-revisions’ and -‘ediff-merge-revisions-with-ancestor’ are normally not what you want -when using a modern version control system like Git. Instead of letting -the user resolve only those conflicts which Git could not resolve on its -own, they throw away all work done by Git and then expect the user to -manually merge all conflicts, including those that had already been -resolved. That made sense back in the days when version control systems -couldn’t merge (or so I have been told), but not anymore. Once in a -blue moon you might actually want to see all conflicts, in which case -you *can* use these commands, which then use ‘ediff-vc-merge-internal’. -So we don’t actually have to implement ‘ediff-magit-merge-internal’. -Instead we provide the more useful command ‘magit-ediff-resolve’ which -only shows yet-to-be resolved conflicts. - - -File: magit.info, Node: Should I disable VC?, Prev: Can Magit be used as ediff-version-control-package?, Up: FAQ - How to ...? - -A.1.6 Should I disable VC? --------------------------- - -If you don’t use VC (the built-in version control interface) then you -might be tempted to disable it, not least because we used to recommend -that you do that. - - We no longer recommend that you disable VC. Doing so would break -useful third-party packages (such as ‘diff-hl’), which depend on VC -being enabled. - - If you choose to disable VC anyway, then you can do so by changing -the value of ‘vc-handled-backends’. - - -File: magit.info, Node: FAQ - Issues and Errors, Prev: FAQ - How to ...?, Up: FAQ - -A.2 FAQ - Issues and Errors -=========================== - -* Menu: - -* Magit is slow:: -* I changed several thousand files at once and now Magit is unusable:: -* I am having problems committing:: -* I am using MS Windows and cannot push with Magit:: -* I am using OS X and SOMETHING works in shell, but not in Magit: I am using OS X and SOMETHING works in shell but not in Magit. -* Expanding a file to show the diff causes it to disappear:: -* Point is wrong in the COMMIT_EDITMSG buffer:: -* The mode-line information isn't always up-to-date:: -* A branch and tag sharing the same name breaks SOMETHING:: -* My Git hooks work on the command-line but not inside Magit:: -* git-commit-mode isn't used when committing from the command-line:: -* Point ends up inside invisible text when jumping to a file-visiting buffer:: - - -File: magit.info, Node: Magit is slow, Next: I changed several thousand files at once and now Magit is unusable, Up: FAQ - Issues and Errors - -A.2.1 Magit is slow -------------------- - -See *note Performance::. - - -File: magit.info, Node: I changed several thousand files at once and now Magit is unusable, Next: I am having problems committing, Prev: Magit is slow, Up: FAQ - Issues and Errors - -A.2.2 I changed several thousand files at once and now Magit is unusable ------------------------------------------------------------------------- - -Magit is *currently* not expected to work under such conditions. It -sure would be nice if it did, and v2.5 will hopefully be a big step into -that direction. But it might take until v3.1 to accomplish fully -satisfactory performance, because that requires some heavy refactoring. - - But for now we recommend you use the command line to complete this -one commit. Also see *note Performance::. - - -File: magit.info, Node: I am having problems committing, Next: I am using MS Windows and cannot push with Magit, Prev: I changed several thousand files at once and now Magit is unusable, Up: FAQ - Issues and Errors - -A.2.3 I am having problems committing -------------------------------------- - -That likely means that Magit is having problems finding an appropriate -emacsclient executable. See *note (with-editor)Configuring -With-Editor:: and *note (with-editor)Debugging::. - - -File: magit.info, Node: I am using MS Windows and cannot push with Magit, Next: I am using OS X and SOMETHING works in shell but not in Magit, Prev: I am having problems committing, Up: FAQ - Issues and Errors - -A.2.4 I am using MS Windows and cannot push with Magit ------------------------------------------------------- - -It’s almost certain that Magit is only incidental to this issue. It is -much more likely that this is a configuration issue, even if you can -push on the command line. - - Detailed setup instructions can be found at -<https://github.com/magit/magit/wiki/Pushing-with-Magit-from-Windows>. - - -File: magit.info, Node: I am using OS X and SOMETHING works in shell but not in Magit, Next: Expanding a file to show the diff causes it to disappear, Prev: I am using MS Windows and cannot push with Magit, Up: FAQ - Issues and Errors - -A.2.5 I am using OS X and SOMETHING works in shell, but not in Magit --------------------------------------------------------------------- - -This usually occurs because Emacs doesn’t have the same environment -variables as your shell. Try installing and configuring -<https://github.com/purcell/exec-path-from-shell>. By default it -synchronizes ‘$PATH’, which helps Magit find the same ‘git’ as the one -you are using on the shell. - - If SOMETHING is "passphrase caching with gpg-agent for commit and/or -tag signing", then you’ll also need to synchronize ‘$GPG_AGENT_INFO’. - - -File: magit.info, Node: Expanding a file to show the diff causes it to disappear, Next: Point is wrong in the COMMIT_EDITMSG buffer, Prev: I am using OS X and SOMETHING works in shell but not in Magit, Up: FAQ - Issues and Errors - -A.2.6 Expanding a file to show the diff causes it to disappear --------------------------------------------------------------- - -This is probably caused by a change of a ‘diff.*’ Git variable. You -probably set that variable for a reason, and should therefore only undo -that setting in Magit by customizing ‘magit-git-global-arguments’. - - -File: magit.info, Node: Point is wrong in the COMMIT_EDITMSG buffer, Next: The mode-line information isn't always up-to-date, Prev: Expanding a file to show the diff causes it to disappear, Up: FAQ - Issues and Errors - -A.2.7 Point is wrong in the ‘COMMIT_EDITMSG’ buffer ---------------------------------------------------- - -Neither Magit nor ‘git-commit‘ fiddle with point in the buffer used to -write commit messages, so something else must be doing it. - - You have probably globally enabled a mode which does restore point in -file-visiting buffers. It might be a bit surprising, but when you write -a commit message, then you are actually editing a file. - - So you have to figure out which package is doing. ‘saveplace’, -‘pointback’, and ‘session’ are likely candidates. These snippets might -help: - - (setq session-name-disable-regexp "\\(?:\\`'\\.git/[A-Z_]+\\'\\)") - - (with-eval-after-load 'pointback - (lambda () - (when (or git-commit-mode git-rebase-mode) - (pointback-mode -1)))) - - -File: magit.info, Node: The mode-line information isn't always up-to-date, Next: A branch and tag sharing the same name breaks SOMETHING, Prev: Point is wrong in the COMMIT_EDITMSG buffer, Up: FAQ - Issues and Errors - -A.2.8 The mode-line information isn’t always up-to-date -------------------------------------------------------- - -Magit is not responsible for the version control information that is -being displayed in the mode-line and looks something like ‘Git-master’. -The built-in "Version Control" package, also known as "VC", updates that -information, and can be told to do so more often: - - (setq auto-revert-check-vc-info t) - - But doing so isn’t good for performance. For more (overly -optimistic) information see *note (emacs)VC Mode Line::. - - If you don’t really care about seeing this information in the -mode-line, but just don’t want to see _incorrect_ information, then -consider simply not displaying it in the mode-line: - - (setq-default mode-line-format - (delete '(vc-mode vc-mode) mode-line-format)) - - -File: magit.info, Node: A branch and tag sharing the same name breaks SOMETHING, Next: My Git hooks work on the command-line but not inside Magit, Prev: The mode-line information isn't always up-to-date, Up: FAQ - Issues and Errors - -A.2.9 A branch and tag sharing the same name breaks SOMETHING -------------------------------------------------------------- - -Or more generally, ambiguous refnames break SOMETHING. - - Magit assumes that refs are named non-ambiguously across the -"refs/heads/", "refs/tags/", and "refs/remotes/" namespaces (i.e., all -the names remain unique when those prefixes are stripped). We consider -ambiguous refnames unsupported and recommend that you use a -non-ambiguous naming scheme. However, if you do work with a repository -that has ambiguous refnames, please report any issues you encounter so -that we can investigate whether there is a simple fix. - - -File: magit.info, Node: My Git hooks work on the command-line but not inside Magit, Next: git-commit-mode isn't used when committing from the command-line, Prev: A branch and tag sharing the same name breaks SOMETHING, Up: FAQ - Issues and Errors - -A.2.10 My Git hooks work on the command-line but not inside Magit ------------------------------------------------------------------ - -When Magit calls ‘git’ it adds a few global arguments including -‘--literal-pathspecs’ and the ‘git’ process started by Magit then passes -that setting on to other ‘git’ process it starts itself. It does so by -setting the environment variable ‘GIT_LITERAL_PATHSPECS’, not by calling -subprocesses with the ‘--literal-pathspecs’ argument. You can therefore -override this setting in hook scripts using ‘unset -GIT_LITERAL_PATHSPECS’. - - -File: magit.info, Node: git-commit-mode isn't used when committing from the command-line, Next: Point ends up inside invisible text when jumping to a file-visiting buffer, Prev: My Git hooks work on the command-line but not inside Magit, Up: FAQ - Issues and Errors - -A.2.11 ‘git-commit-mode’ isn’t used when committing from the command-line -------------------------------------------------------------------------- - -The reason for this is that ‘git-commit.el’ has not been loaded yet -and/or that the server has not been started yet. These things have -always already been taken care of when you commit from Magit because in -order to do so, Magit has to be loaded and doing that involves loading -‘git-commit’ and starting the server. - - If you want to commit from the command-line, then you have to take -care of these things yourself. Your ‘init.el’ file should contain: - - (require 'git-commit) - (server-mode) - - Instead of ‘(require ’git-commit)‘ you may also use: - - (load "/path/to/magit-autoloads.el") - - You might want to do that because loading ‘git-commit’ causes large -parts of Magit to be loaded. - - There are also some variations of ‘(server-mode)’ that you might want -to try. Personally I use: - - (use-package server - :config (or (server-running-p) (server-mode))) - - Now you can use: - - $ emacs& - $ EDITOR=emacsclient git commit - - However you cannot use: - - $ killall emacs - $ EDITOR="emacsclient --alternate-editor emacs" git commit - - This will actually end up using ‘emacs’, not ‘emacsclient’. If you -do this, then can still edit the commit message but ‘git-commit-mode’ -won’t be used and you have to exit ‘emacs’ to finish the process. - - Tautology ahead. If you want to be able to use ‘emacsclient’ to -connect to a running ‘emacs’ instance, even though no ‘emacs’ instance -is running, then you cannot use ‘emacsclient’ directly. - - Instead you have to create a script that does something like this: - - Try to use ‘emacsclient’ (without using ‘--alternate-editor’). If -that succeeds, do nothing else. Otherwise start ‘emacs &’ (and -‘init.el’ must call ‘server-start’) and try to use ‘emacsclient’ again. - - -File: magit.info, Node: Point ends up inside invisible text when jumping to a file-visiting buffer, Prev: git-commit-mode isn't used when committing from the command-line, Up: FAQ - Issues and Errors - -A.2.12 Point ends up inside invisible text when jumping to a file-visiting buffer ---------------------------------------------------------------------------------- - -This can happen when you type ‘RET’ on a hunk to visit the respective -file at the respective position. One solution to this problem is to use -‘global-reveal-mode’. It makes sure that text around point is always -visible. If that is too drastic for your taste, then you may instead -use ‘magit-diff-visit-file-hook’ to reveal the text, possibly using -‘reveal-post-command’ or for Org buffers ‘org-reveal’. - - -File: magit.info, Node: Debugging Tools, Next: Keystroke Index, Prev: FAQ, Up: Top - -B Debugging Tools -***************** - -Magit and its dependencies provide a few debugging tools, and we -appreciate it very much if you use those tools before reporting an -issue. Please include all relevant output when reporting an issue. - -‘M-x magit-version’ (‘magit-version’) - - This command shows the currently used versions of Magit, Git, and - Emacs in the echo area. Non-interactively this just returns the - Magit version. - -‘M-x magit-emacs-Q-command’ (‘magit-emacs-Q-command’) - - This command shows a debugging shell command in the echo area and - adds it to the kill ring. Paste that command into a shell and run - it. - - This shell command starts ‘emacs’ with only ‘magit’ and its - dependencies loaded. Neither your configuration nor other - installed packages are loaded. This makes it easier to determine - whether some issue lays with Magit or something else. - - If you run Magit from its Git repository, then you should be able - to use ‘make emacs-Q’ instead of the output of this command. - -‘M-x magit-toggle-verbose-refresh’ (‘magit-toggle-verbose-refresh’) - - This command toggles whether Magit refreshes buffers verbosely. - Enabling this helps figuring out which sections are bottlenecks. - The additional output can be found in the ‘*Messages*’ buffer. - -‘M-x magit-debug-git-executable’ (‘magit-debug-git-executable’) - - This command displays a buffer containing information about the - available and used ‘git’ executable(s), and can be useful when - investigating ‘exec-path’ issues. - - Also see *note Git Executable::. - -‘M-x with-editor-debug’ (‘with-editor-debug’) - - This command displays a buffer containing information about the - available and used ‘emacsclient’ executable(s), and can be useful - when investigating why Magit (or rather ‘with-editor’) cannot find - an appropriate ‘emacsclient’ executable. - - Also see *note (with-editor)Debugging::. - - Please also see the *note FAQ::. - - -File: magit.info, Node: Keystroke Index, Next: Command Index, Prev: Debugging Tools, Up: Top - -Appendix C Keystroke Index -************************** - - -* Menu: - -* !: Running Git Manually. - (line 12) -* ! !: Running Git Manually. - (line 17) -* ! a: Running Git Manually. - (line 58) -* ! b: Running Git Manually. - (line 62) -* ! g: Running Git Manually. - (line 66) -* ! k: Running Git Manually. - (line 54) -* ! p: Running Git Manually. - (line 25) -* ! s: Running Git Manually. - (line 35) -* ! S: Running Git Manually. - (line 40) -* $: Viewing Git Output. (line 16) -* %: Worktree. (line 8) -* % b: Worktree. (line 13) -* % c: Worktree. (line 17) -* % g: Worktree. (line 30) -* % k: Worktree. (line 25) -* % m: Worktree. (line 21) -* +: Log Buffer. (line 61) -* + <1>: Refreshing Diffs. (line 69) -* -: Log Buffer. (line 65) -* - <1>: Refreshing Diffs. (line 65) -* 0: Refreshing Diffs. (line 73) -* 1: Section Visibility. (line 26) -* 2: Section Visibility. (line 27) -* 3: Section Visibility. (line 28) -* 4: Section Visibility. (line 29) -* =: Log Buffer. (line 55) -* ^: Section Movement. (line 31) -* a: Applying. (line 33) -* A: Cherry Picking. (line 8) -* A A: Cherry Picking. (line 17) -* A a: Cherry Picking. (line 24) -* A A <1>: Cherry Picking. (line 90) -* A a <1>: Cherry Picking. (line 98) -* A d: Cherry Picking. (line 54) -* A h: Cherry Picking. (line 42) -* A n: Cherry Picking. (line 65) -* A s: Cherry Picking. (line 76) -* A s <1>: Cherry Picking. (line 94) -* B: Bisecting. (line 8) -* b: Blaming. (line 105) -* b <1>: Branch Commands. (line 12) -* b <2>: Editing Rebase Sequences. - (line 85) -* B B: Bisecting. (line 16) -* B b: Bisecting. (line 31) -* b b: Branch Commands. (line 49) -* b C: Branch Commands. (line 29) -* b c: Branch Commands. (line 67) -* B g: Bisecting. (line 36) -* B k: Bisecting. (line 41) -* b k: Branch Commands. (line 147) -* b l: Branch Commands. (line 74) -* b n: Branch Commands. (line 57) -* B r: Bisecting. (line 47) -* b r: Branch Commands. (line 153) -* B s: Bisecting. (line 24) -* b s: Branch Commands. (line 97) -* b S: Branch Commands. (line 125) -* b x: Branch Commands. (line 131) -* c: Blaming. (line 138) -* C: Cloning Repository. (line 20) -* c <1>: Initiating a Commit. (line 8) -* c <2>: Editing Rebase Sequences. - (line 72) -* c a: Initiating a Commit. (line 19) -* c A: Initiating a Commit. (line 67) -* C b: Cloning Repository. (line 41) -* C C: Cloning Repository. (line 29) -* c c: Initiating a Commit. (line 14) -* C d: Cloning Repository. (line 54) -* C e: Cloning Repository. (line 61) -* c e: Initiating a Commit. (line 23) -* c f: Initiating a Commit. (line 43) -* c F: Initiating a Commit. (line 51) -* C m: Cloning Repository. (line 46) -* C s: Cloning Repository. (line 34) -* c s: Initiating a Commit. (line 55) -* c S: Initiating a Commit. (line 63) -* c w: Initiating a Commit. (line 33) -* C-<return>: Visiting Files and Blobs from a Diff. - (line 51) -* C-<tab>: Section Visibility. (line 13) -* C-c C-a: Commit Pseudo Headers. - (line 17) -* C-c C-b: Log Buffer. (line 21) -* C-c C-b <1>: Refreshing Diffs. (line 91) -* C-c C-c: Transient Commands. (line 18) -* C-c C-c <1>: Select from Log. (line 20) -* C-c C-c <2>: Editing Commit Messages. - (line 17) -* C-c C-c <3>: Editing Rebase Sequences. - (line 6) -* C-c C-d: Refreshing Diffs. (line 81) -* C-c C-d <1>: Editing Commit Messages. - (line 58) -* C-c C-e: Commands Available in Diffs. - (line 25) -* C-c C-f: Log Buffer. (line 25) -* C-c C-f <1>: Refreshing Diffs. (line 95) -* C-c C-i: Commit Pseudo Headers. - (line 13) -* C-c C-k: Select from Log. (line 26) -* C-c C-k <1>: Editing Commit Messages. - (line 22) -* C-c C-k <2>: Editing Rebase Sequences. - (line 11) -* C-c C-n: Log Buffer. (line 29) -* C-c C-o: Commit Pseudo Headers. - (line 33) -* C-c C-p: Commit Pseudo Headers. - (line 37) -* C-c C-r: Commit Pseudo Headers. - (line 21) -* C-c C-s: Commit Pseudo Headers. - (line 25) -* C-c C-t: Commands Available in Diffs. - (line 14) -* C-c C-t <1>: Commit Pseudo Headers. - (line 29) -* C-c C-w: Using the Revision Stack. - (line 6) -* C-c M-g: Minor Mode for Buffers Visiting Files. - (line 54) -* C-c M-g B: Blaming. (line 21) -* C-c M-g b: Blaming. (line 32) -* C-c M-g B <1>: Minor Mode for Buffers Visiting Files. - (line 123) -* C-c M-g B b: Blaming. (line 33) -* C-c M-g B e: Blaming. (line 67) -* C-c M-g B f: Blaming. (line 58) -* C-c M-g B r: Blaming. (line 49) -* C-c M-g c: Minor Mode for Buffers Visiting Files. - (line 68) -* C-c M-g D: Minor Mode for Buffers Visiting Files. - (line 75) -* C-c M-g d: Minor Mode for Buffers Visiting Files. - (line 86) -* C-c M-g e: Blaming. (line 66) -* C-c M-g e <1>: Minor Mode for Buffers Visiting Files. - (line 136) -* C-c M-g f: Blaming. (line 57) -* C-c M-g L: Minor Mode for Buffers Visiting Files. - (line 96) -* C-c M-g l: Minor Mode for Buffers Visiting Files. - (line 107) -* C-c M-g p: Minor Mode for Buffers Visiting Files. - (line 146) -* C-c M-g r: Blaming. (line 48) -* C-c M-g s: Minor Mode for Buffers Visiting Files. - (line 59) -* C-c M-g t: Minor Mode for Buffers Visiting Files. - (line 114) -* C-c M-g u: Minor Mode for Buffers Visiting Files. - (line 63) -* C-c M-i: Commit Pseudo Headers. - (line 42) -* C-c M-s: Editing Commit Messages. - (line 34) -* C-w: Common Commands. (line 10) -* C-x g: Status Buffer. (line 22) -* C-x u: Editing Rebase Sequences. - (line 94) -* d: Diffing. (line 21) -* D: Refreshing Diffs. (line 11) -* d c: Diffing. (line 69) -* d d: Diffing. (line 27) -* D f: Refreshing Diffs. (line 46) -* D F: Refreshing Diffs. (line 51) -* D g: Refreshing Diffs. (line 17) -* d p: Diffing. (line 61) -* d r: Diffing. (line 31) -* D r: Refreshing Diffs. (line 41) -* d s: Diffing. (line 51) -* D s: Refreshing Diffs. (line 22) -* d t: Diffing. (line 74) -* D t: Refreshing Diffs. (line 37) -* d u: Diffing. (line 57) -* d w: Diffing. (line 45) -* D w: Refreshing Diffs. (line 29) -* DEL: Log Buffer. (line 45) -* DEL <1>: Commands Available in Diffs. - (line 60) -* DEL <2>: Blaming. (line 92) -* DEL <3>: Editing Rebase Sequences. - (line 28) -* e: Ediffing. (line 9) -* E: Ediffing. (line 21) -* e <1>: Editing Rebase Sequences. - (line 55) -* E c: Ediffing. (line 65) -* E i: Ediffing. (line 57) -* E m: Ediffing. (line 35) -* E r: Ediffing. (line 26) -* E s: Ediffing. (line 48) -* E u: Ediffing. (line 53) -* E w: Ediffing. (line 61) -* E z: Ediffing. (line 69) -* f: Editing Rebase Sequences. - (line 63) -* f <1>: Fetching. (line 9) -* F: Pulling. (line 9) -* f a: Fetching. (line 50) -* f C: Branch Commands. (line 30) -* F C: Branch Commands. (line 31) -* f e: Fetching. (line 36) -* F e: Pulling. (line 30) -* f m: Fetching. (line 54) -* f o: Fetching. (line 40) -* f p: Fetching. (line 15) -* F p: Pulling. (line 14) -* f r: Fetching. (line 45) -* f u: Fetching. (line 23) -* F u: Pulling. (line 22) -* g: Automatic Refreshing of Magit Buffers. - (line 24) -* G: Automatic Refreshing of Magit Buffers. - (line 33) -* j: Commands Available in Diffs. - (line 45) -* k: Viewing Git Output. (line 24) -* k <1>: Applying. (line 40) -* k <2>: Editing Rebase Sequences. - (line 68) -* k <3>: Stashing. (line 96) -* l: Logging. (line 29) -* L: Refreshing Logs. (line 11) -* L <1>: Log Buffer. (line 6) -* L <2>: Log Margin. (line 57) -* l <1>: Editing Rebase Sequences. - (line 115) -* l a: Logging. (line 60) -* l b: Logging. (line 56) -* L d: Log Margin. (line 74) -* L g: Refreshing Logs. (line 17) -* l h: Logging. (line 48) -* l H: Reflog. (line 19) -* l l: Logging. (line 35) -* l L: Logging. (line 52) -* L L: Log Margin. (line 66) -* L l: Log Margin. (line 70) -* l o: Logging. (line 41) -* l O: Reflog. (line 15) -* l r: Reflog. (line 11) -* L s: Refreshing Logs. (line 22) -* L t: Refreshing Logs. (line 37) -* L w: Refreshing Logs. (line 29) -* m: Merging. (line 9) -* M: Remote Commands. (line 13) -* m a: Merging. (line 45) -* m a <1>: Merging. (line 95) -* M a: Remote Commands. (line 50) -* M C: Remote Commands. (line 33) -* m e: Merging. (line 31) -* m i: Merging. (line 58) -* M k: Remote Commands. (line 65) -* m m: Merging. (line 18) -* m m <1>: Merging. (line 89) -* m n: Merging. (line 38) -* m p: Merging. (line 81) -* M p: Remote Commands. (line 69) -* M P: Remote Commands. (line 74) -* M r: Remote Commands. (line 55) -* m s: Merging. (line 72) -* M u: Remote Commands. (line 60) -* M-1: Section Visibility. (line 33) -* M-2: Section Visibility. (line 34) -* M-3: Section Visibility. (line 35) -* M-4: Section Visibility. (line 36) -* M-<tab>: Section Visibility. (line 17) -* M-n: Section Movement. (line 26) -* M-n <1>: Editing Commit Messages. - (line 44) -* M-n <2>: Editing Rebase Sequences. - (line 47) -* M-p: Section Movement. (line 20) -* M-p <1>: Editing Commit Messages. - (line 38) -* M-p <2>: Editing Rebase Sequences. - (line 43) -* M-w: Blaming. (line 130) -* M-w <1>: Common Commands. (line 27) -* M-x magit-debug-git-executable: Git Executable. (line 45) -* M-x magit-debug-git-executable <1>: Debugging Tools. (line 36) -* M-x magit-describe-section-briefly: Section Types and Values. - (line 13) -* M-x magit-describe-section-briefly <1>: Matching Sections. (line 6) -* M-x magit-emacs-Q-command: Debugging Tools. (line 16) -* M-x magit-init: Creating Repository. (line 6) -* M-x magit-reset-index: Staging and Unstaging. - (line 87) -* M-x magit-reverse-in-index: Staging and Unstaging. - (line 62) -* M-x magit-stage-file: Staging from File-Visiting Buffers. - (line 10) -* M-x magit-toggle-buffer-lock: Modes and Buffers. (line 17) -* M-x magit-toggle-verbose-refresh: Debugging Tools. (line 30) -* M-x magit-unstage-file: Staging from File-Visiting Buffers. - (line 18) -* M-x magit-version: Git Executable. (line 17) -* M-x magit-version <1>: Debugging Tools. (line 10) -* M-x magit-wip-commit: Wip Modes. (line 88) -* M-x with-editor-debug: Debugging Tools. (line 44) -* MM: Editing Rebase Sequences. - (line 125) -* Mt: Editing Rebase Sequences. - (line 132) -* n: Section Movement. (line 16) -* n <1>: Blaming. (line 109) -* N: Blaming. (line 113) -* n <2>: Editing Rebase Sequences. - (line 39) -* n <3>: Minor Mode for Buffers Visiting Blobs. - (line 16) -* o: Submodule Transient. (line 6) -* O: Subtree. (line 8) -* o a: Submodule Transient. (line 20) -* o d: Submodule Transient. (line 50) -* O e: Subtree. (line 42) -* O e p: Subtree. (line 54) -* O e s: Subtree. (line 59) -* o f: Submodule Transient. (line 58) -* O i: Subtree. (line 13) -* O i a: Subtree. (line 25) -* O i c: Subtree. (line 30) -* O i f: Subtree. (line 38) -* O i m: Subtree. (line 34) -* o l: Submodule Transient. (line 54) -* o p: Submodule Transient. (line 34) -* o r: Submodule Transient. (line 27) -* o s: Submodule Transient. (line 44) -* o u: Submodule Transient. (line 39) -* p: Section Movement. (line 10) -* p <1>: Blaming. (line 117) -* P: Blaming. (line 121) -* p <2>: Editing Rebase Sequences. - (line 35) -* P <1>: Pushing. (line 9) -* p <3>: Minor Mode for Buffers Visiting Blobs. - (line 12) -* P C: Branch Commands. (line 32) -* P e: Pushing. (line 31) -* P m: Pushing. (line 50) -* P o: Pushing. (line 36) -* P p: Pushing. (line 15) -* P r: Pushing. (line 41) -* P t: Pushing. (line 58) -* P T: Pushing. (line 66) -* P u: Pushing. (line 23) -* q: Quitting Windows. (line 6) -* q <1>: Log Buffer. (line 14) -* q <2>: Blaming. (line 125) -* q <3>: Minor Mode for Buffers Visiting Blobs. - (line 20) -* r: Rebasing. (line 9) -* r <1>: Editing Rebase Sequences. - (line 51) -* r a: Rebasing. (line 123) -* r e: Rebasing. (line 44) -* r e <1>: Rebasing. (line 118) -* r f: Rebasing. (line 84) -* r i: Rebasing. (line 80) -* r k: Rebasing. (line 99) -* r m: Rebasing. (line 89) -* r p: Rebasing. (line 28) -* r r: Rebasing. (line 106) -* r s: Rebasing. (line 50) -* r s <1>: Rebasing. (line 113) -* r u: Rebasing. (line 36) -* r w: Rebasing. (line 94) -* RET: References Buffer. (line 181) -* RET <1>: Visiting Files and Blobs from a Diff. - (line 8) -* RET <2>: Blaming. (line 78) -* RET <3>: Editing Rebase Sequences. - (line 16) -* s: Staging and Unstaging. - (line 28) -* S: Staging and Unstaging. - (line 36) -* s <1>: Editing Rebase Sequences. - (line 59) -* S-<tab>: Section Visibility. (line 22) -* SPC: Log Buffer. (line 35) -* SPC <1>: Commands Available in Diffs. - (line 56) -* SPC <2>: Blaming. (line 82) -* SPC <3>: Editing Rebase Sequences. - (line 21) -* t: Editing Rebase Sequences. - (line 119) -* t <1>: Tagging. (line 8) -* T: Notes. (line 8) -* T a: Notes. (line 52) -* T c: Notes. (line 47) -* t k: Tagging. (line 39) -* T m: Notes. (line 38) -* t p: Tagging. (line 46) -* T p: Notes. (line 30) -* t r: Tagging. (line 19) -* T r: Notes. (line 22) -* t t: Tagging. (line 14) -* T T: Notes. (line 14) -* TAB: Section Visibility. (line 9) -* u: Staging and Unstaging. - (line 43) -* U: Staging and Unstaging. - (line 52) -* v: Applying. (line 44) -* V: Reverting. (line 6) -* V A: Reverting. (line 31) -* V a: Reverting. (line 39) -* V s: Reverting. (line 35) -* V V: Reverting. (line 15) -* V v: Reverting. (line 21) -* W: Plain Patches. (line 6) -* w: Maildir Patches. (line 8) -* w a: Plain Patches. (line 21) -* w a <1>: Maildir Patches. (line 25) -* w a <2>: Maildir Patches. (line 43) -* W c: Plain Patches. (line 12) -* w m: Maildir Patches. (line 21) -* W s: Plain Patches. (line 28) -* w s: Maildir Patches. (line 38) -* w w: Maildir Patches. (line 14) -* w w <1>: Maildir Patches. (line 34) -* x: Editing Rebase Sequences. - (line 76) -* x <1>: Resetting. (line 8) -* X f: Resetting. (line 50) -* X h: Resetting. (line 26) -* X i: Resetting. (line 37) -* X k: Resetting. (line 31) -* X m: Resetting. (line 15) -* X s: Resetting. (line 20) -* X w: Resetting. (line 44) -* X w <1>: Wip Modes. (line 66) -* Y: Cherries. (line 17) -* y: References Buffer. (line 6) -* y <1>: Editing Rebase Sequences. - (line 90) -* y c: References Buffer. (line 26) -* y o: References Buffer. (line 32) -* y y: References Buffer. (line 21) -* z: Stashing. (line 8) -* z a: Stashing. (line 59) -* z b: Stashing. (line 81) -* z B: Stashing. (line 86) -* z f: Stashing. (line 92) -* z i: Stashing. (line 21) -* z I: Stashing. (line 47) -* z k: Stashing. (line 72) -* z l: Stashing. (line 100) -* z p: Stashing. (line 65) -* z v: Stashing. (line 77) -* z w: Stashing. (line 26) -* z W: Stashing. (line 52) -* z x: Stashing. (line 33) -* z z: Stashing. (line 14) -* z Z: Stashing. (line 40) - - -File: magit.info, Node: Command Index, Next: Function Index, Prev: Keystroke Index, Up: Top - -Appendix D Command Index -************************ - - -* Menu: - -* forward-line: Editing Rebase Sequences. - (line 39) -* git-commit-ack: Commit Pseudo Headers. - (line 17) -* git-commit-cc: Commit Pseudo Headers. - (line 33) -* git-commit-insert-pseudo-header: Commit Pseudo Headers. - (line 13) -* git-commit-next-message: Editing Commit Messages. - (line 44) -* git-commit-prev-message: Editing Commit Messages. - (line 38) -* git-commit-reported: Commit Pseudo Headers. - (line 37) -* git-commit-review: Commit Pseudo Headers. - (line 21) -* git-commit-save-message: Editing Commit Messages. - (line 34) -* git-commit-signoff: Commit Pseudo Headers. - (line 25) -* git-commit-suggested: Commit Pseudo Headers. - (line 42) -* git-commit-test: Commit Pseudo Headers. - (line 29) -* git-rebase-backward-line: Editing Rebase Sequences. - (line 35) -* git-rebase-break: Editing Rebase Sequences. - (line 85) -* git-rebase-edit: Editing Rebase Sequences. - (line 55) -* git-rebase-exec: Editing Rebase Sequences. - (line 76) -* git-rebase-fixup: Editing Rebase Sequences. - (line 63) -* git-rebase-insert: Editing Rebase Sequences. - (line 90) -* git-rebase-kill-line: Editing Rebase Sequences. - (line 68) -* git-rebase-label: Editing Rebase Sequences. - (line 115) -* git-rebase-merge: Editing Rebase Sequences. - (line 125) -* git-rebase-merge-toggle-editmsg: Editing Rebase Sequences. - (line 132) -* git-rebase-move-line-down: Editing Rebase Sequences. - (line 47) -* git-rebase-move-line-up: Editing Rebase Sequences. - (line 43) -* git-rebase-pick: Editing Rebase Sequences. - (line 72) -* git-rebase-reset: Editing Rebase Sequences. - (line 119) -* git-rebase-reword: Editing Rebase Sequences. - (line 51) -* git-rebase-show-commit: Editing Rebase Sequences. - (line 16) -* git-rebase-show-or-scroll-down: Editing Rebase Sequences. - (line 28) -* git-rebase-show-or-scroll-up: Editing Rebase Sequences. - (line 21) -* git-rebase-squash: Editing Rebase Sequences. - (line 59) -* git-rebase-undo: Editing Rebase Sequences. - (line 94) -* ido-enter-magit-status: Status Buffer. (line 72) -* magit-am: Maildir Patches. (line 8) -* magit-am-abort: Maildir Patches. (line 43) -* magit-am-apply-maildir: Maildir Patches. (line 21) -* magit-am-apply-patches: Maildir Patches. (line 14) -* magit-am-continue: Maildir Patches. (line 34) -* magit-am-skip: Maildir Patches. (line 38) -* magit-apply: Applying. (line 33) -* magit-bisect: Bisecting. (line 8) -* magit-bisect-bad: Bisecting. (line 31) -* magit-bisect-good: Bisecting. (line 36) -* magit-bisect-reset: Bisecting. (line 47) -* magit-bisect-run: Bisecting. (line 24) -* magit-bisect-skip: Bisecting. (line 41) -* magit-bisect-start: Bisecting. (line 16) -* magit-blame: Blaming. (line 21) -* magit-blame <1>: Blaming. (line 105) -* magit-blame <2>: Minor Mode for Buffers Visiting Files. - (line 123) -* magit-blame-addition: Blaming. (line 32) -* magit-blame-addition <1>: Blaming. (line 33) -* magit-blame-copy-hash: Blaming. (line 130) -* magit-blame-cycle-style: Blaming. (line 138) -* magit-blame-echo: Blaming. (line 66) -* magit-blame-echo <1>: Blaming. (line 67) -* magit-blame-next-chunk: Blaming. (line 109) -* magit-blame-next-chunk-same-commit: Blaming. (line 113) -* magit-blame-previous-chunk: Blaming. (line 117) -* magit-blame-previous-chunk-same-commit: Blaming. (line 121) -* magit-blame-quit: Blaming. (line 125) -* magit-blame-removal: Blaming. (line 48) -* magit-blame-removal <1>: Blaming. (line 49) -* magit-blame-reverse: Blaming. (line 57) -* magit-blame-reverse <1>: Blaming. (line 58) -* magit-blob-next: Minor Mode for Buffers Visiting Blobs. - (line 16) -* magit-blob-previous: Minor Mode for Buffers Visiting Files. - (line 146) -* magit-blob-previous <1>: Minor Mode for Buffers Visiting Blobs. - (line 12) -* magit-branch: Branch Commands. (line 12) -* magit-branch-and-checkout: Branch Commands. (line 67) -* magit-branch-checkout: Branch Commands. (line 74) -* magit-branch-configure: Branch Commands. (line 29) -* magit-branch-configure <1>: Branch Commands. (line 30) -* magit-branch-configure <2>: Branch Commands. (line 31) -* magit-branch-configure <3>: Branch Commands. (line 32) -* magit-branch-create: Branch Commands. (line 57) -* magit-branch-delete: Branch Commands. (line 147) -* magit-branch-or-checkout: Branch Commands. (line 257) -* magit-branch-orphan: Branch Commands. (line 252) -* magit-branch-rename: Branch Commands. (line 153) -* magit-branch-reset: Branch Commands. (line 131) -* magit-branch-shelve: Auxiliary Branch Commands. - (line 9) -* magit-branch-spinoff: Branch Commands. (line 97) -* magit-branch-spinout: Branch Commands. (line 125) -* magit-branch-unshelve: Auxiliary Branch Commands. - (line 20) -* magit-checkout: Branch Commands. (line 49) -* magit-cherry: Cherries. (line 17) -* magit-cherry-apply: Cherry Picking. (line 24) -* magit-cherry-copy: Cherry Picking. (line 17) -* magit-cherry-donate: Cherry Picking. (line 54) -* magit-cherry-harvest: Cherry Picking. (line 42) -* magit-cherry-pick: Cherry Picking. (line 8) -* magit-cherry-spinoff: Cherry Picking. (line 76) -* magit-cherry-spinout: Cherry Picking. (line 65) -* magit-clone: Cloning Repository. (line 20) -* magit-clone-bare: Cloning Repository. (line 41) -* magit-clone-mirror: Cloning Repository. (line 46) -* magit-clone-regular: Cloning Repository. (line 29) -* magit-clone-shallow: Cloning Repository. (line 34) -* magit-clone-shallow-exclude: Cloning Repository. (line 61) -* magit-clone-shallow-since: Cloning Repository. (line 54) -* magit-commit: Initiating a Commit. (line 8) -* magit-commit <1>: Minor Mode for Buffers Visiting Files. - (line 68) -* magit-commit-amend: Initiating a Commit. (line 19) -* magit-commit-augment: Initiating a Commit. (line 67) -* magit-commit-create: Initiating a Commit. (line 14) -* magit-commit-extend: Initiating a Commit. (line 23) -* magit-commit-fixup: Initiating a Commit. (line 43) -* magit-commit-instant-fixup: Initiating a Commit. (line 51) -* magit-commit-instant-squash: Initiating a Commit. (line 63) -* magit-commit-reword: Initiating a Commit. (line 33) -* magit-commit-squash: Initiating a Commit. (line 55) -* magit-copy-buffer-revision: Common Commands. (line 27) -* magit-copy-section-value: Common Commands. (line 10) -* magit-cycle-margin-style: Log Margin. (line 70) -* magit-debug-git-executable: Git Executable. (line 45) -* magit-debug-git-executable <1>: Debugging Tools. (line 36) -* magit-describe-section-briefly: Section Types and Values. - (line 13) -* magit-describe-section-briefly <1>: Matching Sections. (line 6) -* magit-diff: Diffing. (line 21) -* magit-diff <1>: Minor Mode for Buffers Visiting Files. - (line 75) -* magit-diff-buffer-file: Minor Mode for Buffers Visiting Files. - (line 86) -* magit-diff-default-context: Refreshing Diffs. (line 73) -* magit-diff-dwim: Diffing. (line 27) -* magit-diff-edit-hunk-commit: Commands Available in Diffs. - (line 25) -* magit-diff-flip-revs: Refreshing Diffs. (line 46) -* magit-diff-less-context: Refreshing Diffs. (line 65) -* magit-diff-more-context: Refreshing Diffs. (line 69) -* magit-diff-paths: Diffing. (line 61) -* magit-diff-range: Diffing. (line 31) -* magit-diff-refresh: Refreshing Diffs. (line 11) -* magit-diff-refresh <1>: Refreshing Diffs. (line 17) -* magit-diff-save-default-arguments: Refreshing Diffs. (line 29) -* magit-diff-set-default-arguments: Refreshing Diffs. (line 22) -* magit-diff-show-or-scroll-down: Log Buffer. (line 45) -* magit-diff-show-or-scroll-down <1>: Blaming. (line 92) -* magit-diff-show-or-scroll-up: Log Buffer. (line 35) -* magit-diff-show-or-scroll-up <1>: Blaming. (line 82) -* magit-diff-staged: Diffing. (line 51) -* magit-diff-switch-range-type: Refreshing Diffs. (line 41) -* magit-diff-toggle-file-filter: Refreshing Diffs. (line 51) -* magit-diff-toggle-refine-hunk: Refreshing Diffs. (line 37) -* magit-diff-trace-definition: Commands Available in Diffs. - (line 14) -* magit-diff-unstaged: Diffing. (line 57) -* magit-diff-visit-file: Visiting Files and Blobs from a Diff. - (line 8) -* magit-diff-visit-file-other-frame: Visiting Files and Blobs from a Diff. - (line 74) -* magit-diff-visit-file-other-window: Visiting Files and Blobs from a Diff. - (line 73) -* magit-diff-visit-file-worktree: Visiting Files and Blobs from a Diff. - (line 51) -* magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs from a Diff. - (line 76) -* magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs from a Diff. - (line 75) -* magit-diff-while-committing: Refreshing Diffs. (line 81) -* magit-diff-while-committing <1>: Editing Commit Messages. - (line 58) -* magit-diff-working-tree: Diffing. (line 45) -* magit-discard: Applying. (line 40) -* magit-dispatch: Transient Commands. (line 18) -* magit-ediff: Ediffing. (line 21) -* magit-ediff-compare: Ediffing. (line 26) -* magit-ediff-dwim: Ediffing. (line 9) -* magit-ediff-resolve: Ediffing. (line 35) -* magit-ediff-show-commit: Ediffing. (line 65) -* magit-ediff-show-staged: Ediffing. (line 57) -* magit-ediff-show-stash: Ediffing. (line 69) -* magit-ediff-show-unstaged: Ediffing. (line 53) -* magit-ediff-show-working-tree: Ediffing. (line 61) -* magit-ediff-stage: Ediffing. (line 48) -* magit-edit-line-commit: Minor Mode for Buffers Visiting Files. - (line 136) -* magit-emacs-Q-command: Debugging Tools. (line 16) -* magit-fetch: Fetching. (line 9) -* magit-fetch-all: Fetching. (line 50) -* magit-fetch-branch: Fetching. (line 40) -* magit-fetch-from-pushremote: Fetching. (line 15) -* magit-fetch-from-upstream: Fetching. (line 23) -* magit-fetch-modules: Submodule Transient. (line 58) -* magit-fetch-other: Fetching. (line 36) -* magit-fetch-refspec: Fetching. (line 45) -* magit-file-checkout: Resetting. (line 50) -* magit-file-checkout <1>: Minor Mode for Buffers Visiting Files. - (line 165) -* magit-file-delete: Minor Mode for Buffers Visiting Files. - (line 157) -* magit-file-dispatch: Minor Mode for Buffers Visiting Files. - (line 54) -* magit-file-rename: Minor Mode for Buffers Visiting Files. - (line 153) -* magit-file-untrack: Minor Mode for Buffers Visiting Files. - (line 161) -* magit-find-file: General-Purpose Visit Commands. - (line 9) -* magit-find-file-other-frame: General-Purpose Visit Commands. - (line 21) -* magit-find-file-other-window: General-Purpose Visit Commands. - (line 15) -* magit-git-command: Running Git Manually. - (line 25) -* magit-git-command-topdir: Running Git Manually. - (line 17) -* magit-go-backward: Log Buffer. (line 21) -* magit-go-backward <1>: Refreshing Diffs. (line 91) -* magit-go-forward: Log Buffer. (line 25) -* magit-go-forward <1>: Refreshing Diffs. (line 95) -* magit-init: Creating Repository. (line 6) -* magit-jump-to-diffstat-or-diff: Commands Available in Diffs. - (line 45) -* magit-kill-this-buffer: Minor Mode for Buffers Visiting Blobs. - (line 20) -* magit-list-repositories: Repository List. (line 6) -* magit-list-submodules: Listing Submodules. (line 13) -* magit-list-submodules <1>: Submodule Transient. (line 54) -* magit-log: Logging. (line 29) -* magit-log <1>: Minor Mode for Buffers Visiting Files. - (line 96) -* magit-log-all: Logging. (line 60) -* magit-log-all-branches: Logging. (line 56) -* magit-log-branches: Logging. (line 52) -* magit-log-buffer-file: Minor Mode for Buffers Visiting Files. - (line 107) -* magit-log-bury-buffer: Log Buffer. (line 14) -* magit-log-current: Logging. (line 35) -* magit-log-double-commit-limit: Log Buffer. (line 61) -* magit-log-half-commit-limit: Log Buffer. (line 65) -* magit-log-head: Logging. (line 48) -* magit-log-move-to-parent: Log Buffer. (line 29) -* magit-log-other: Logging. (line 41) -* magit-log-refresh: Refreshing Logs. (line 11) -* magit-log-refresh <1>: Refreshing Logs. (line 17) -* magit-log-refresh <2>: Log Buffer. (line 6) -* magit-log-save-default-arguments: Refreshing Logs. (line 29) -* magit-log-select-pick: Select from Log. (line 20) -* magit-log-select-quit: Select from Log. (line 26) -* magit-log-set-default-arguments: Refreshing Logs. (line 22) -* magit-log-toggle-commit-limit: Log Buffer. (line 55) -* magit-log-trace-definition: Minor Mode for Buffers Visiting Files. - (line 114) -* magit-margin-settings: Log Margin. (line 57) -* magit-merge: Merging. (line 9) -* magit-merge <1>: Merging. (line 89) -* magit-merge-abort: Merging. (line 95) -* magit-merge-absorb: Merging. (line 45) -* magit-merge-editmsg: Merging. (line 31) -* magit-merge-into: Merging. (line 58) -* magit-merge-nocommit: Merging. (line 38) -* magit-merge-plain: Merging. (line 18) -* magit-merge-preview: Merging. (line 81) -* magit-merge-squash: Merging. (line 72) -* magit-mode-bury-buffer: Quitting Windows. (line 6) -* magit-notes: Notes. (line 8) -* magit-notes-edit: Notes. (line 14) -* magit-notes-merge: Notes. (line 38) -* magit-notes-merge-abort: Notes. (line 52) -* magit-notes-merge-commit: Notes. (line 47) -* magit-notes-prune: Notes. (line 30) -* magit-notes-remove: Notes. (line 22) -* magit-patch: Plain Patches. (line 6) -* magit-patch-apply: Plain Patches. (line 21) -* magit-patch-apply <1>: Maildir Patches. (line 25) -* magit-patch-create: Plain Patches. (line 12) -* magit-patch-save: Plain Patches. (line 28) -* magit-pop-revision-stack: Using the Revision Stack. - (line 6) -* magit-process: Viewing Git Output. (line 16) -* magit-process-kill: Viewing Git Output. (line 24) -* magit-pull: Pulling. (line 9) -* magit-pull-branch: Pulling. (line 30) -* magit-pull-from-pushremote: Pulling. (line 14) -* magit-pull-from-upstream: Pulling. (line 22) -* magit-push: Pushing. (line 9) -* magit-push-current: Pushing. (line 31) -* magit-push-current-to-pushremote: Pushing. (line 15) -* magit-push-current-to-upstream: Pushing. (line 23) -* magit-push-implicitly args: Pushing. (line 74) -* magit-push-matching: Pushing. (line 50) -* magit-push-other: Pushing. (line 36) -* magit-push-refspecs: Pushing. (line 41) -* magit-push-tag: Pushing. (line 66) -* magit-push-tags: Pushing. (line 58) -* magit-push-to-remote remote args: Pushing. (line 85) -* magit-rebase: Rebasing. (line 9) -* magit-rebase-abort: Rebasing. (line 123) -* magit-rebase-autosquash: Rebasing. (line 84) -* magit-rebase-branch: Rebasing. (line 44) -* magit-rebase-continue: Rebasing. (line 106) -* magit-rebase-edit: Rebasing. (line 118) -* magit-rebase-edit-commit: Rebasing. (line 89) -* magit-rebase-interactive: Rebasing. (line 80) -* magit-rebase-onto-pushremote: Rebasing. (line 28) -* magit-rebase-onto-upstream: Rebasing. (line 36) -* magit-rebase-remove-commit: Rebasing. (line 99) -* magit-rebase-reword-commit: Rebasing. (line 94) -* magit-rebase-skip: Rebasing. (line 113) -* magit-rebase-subset: Rebasing. (line 50) -* magit-reflog-current: Reflog. (line 11) -* magit-reflog-head: Reflog. (line 19) -* magit-reflog-other: Reflog. (line 15) -* magit-refresh: Automatic Refreshing of Magit Buffers. - (line 24) -* magit-refresh-all: Automatic Refreshing of Magit Buffers. - (line 33) -* magit-remote: Remote Commands. (line 13) -* magit-remote-add: Remote Commands. (line 50) -* magit-remote-configure: Remote Commands. (line 33) -* magit-remote-prune: Remote Commands. (line 69) -* magit-remote-prune-refspecs: Remote Commands. (line 74) -* magit-remote-remove: Remote Commands. (line 65) -* magit-remote-rename: Remote Commands. (line 55) -* magit-remote-set-url: Remote Commands. (line 60) -* magit-reset-hard: Resetting. (line 26) -* magit-reset-index: Staging and Unstaging. - (line 87) -* magit-reset-index <1>: Resetting. (line 37) -* magit-reset-keep: Resetting. (line 31) -* magit-reset-mixed: Resetting. (line 15) -* magit-reset-quickly: Resetting. (line 8) -* magit-reset-soft: Resetting. (line 20) -* magit-reset-worktree: Resetting. (line 44) -* magit-reset-worktree <1>: Wip Modes. (line 66) -* magit-reverse: Applying. (line 44) -* magit-reverse-in-index: Staging and Unstaging. - (line 62) -* magit-revert: Reverting. (line 6) -* magit-revert-and-commit: Reverting. (line 15) -* magit-revert-no-commit: Reverting. (line 21) -* magit-run: Running Git Manually. - (line 12) -* magit-run-git-gui: Running Git Manually. - (line 66) -* magit-run-gitk: Running Git Manually. - (line 54) -* magit-run-gitk-all: Running Git Manually. - (line 58) -* magit-run-gitk-branches: Running Git Manually. - (line 62) -* magit-section-backward: Section Movement. (line 10) -* magit-section-backward-siblings: Section Movement. (line 20) -* magit-section-cycle: Section Visibility. (line 13) -* magit-section-cycle-diffs: Section Visibility. (line 17) -* magit-section-cycle-global: Section Visibility. (line 22) -* magit-section-forward: Section Movement. (line 16) -* magit-section-forward-siblings: Section Movement. (line 26) -* magit-section-hide: Section Visibility. (line 49) -* magit-section-hide-children: Section Visibility. (line 64) -* magit-section-show: Section Visibility. (line 45) -* magit-section-show-children: Section Visibility. (line 58) -* magit-section-show-headings: Section Visibility. (line 53) -* magit-section-show-level-1: Section Visibility. (line 26) -* magit-section-show-level-1-all: Section Visibility. (line 33) -* magit-section-show-level-2: Section Visibility. (line 27) -* magit-section-show-level-2-all: Section Visibility. (line 34) -* magit-section-show-level-3: Section Visibility. (line 28) -* magit-section-show-level-3-all: Section Visibility. (line 35) -* magit-section-show-level-4: Section Visibility. (line 29) -* magit-section-show-level-4-all: Section Visibility. (line 36) -* magit-section-toggle: Section Visibility. (line 9) -* magit-section-toggle-children: Section Visibility. (line 68) -* magit-section-up: Section Movement. (line 31) -* magit-sequence-abort: Cherry Picking. (line 98) -* magit-sequence-abort <1>: Reverting. (line 39) -* magit-sequence-continue: Cherry Picking. (line 90) -* magit-sequence-continue <1>: Reverting. (line 31) -* magit-sequence-skip: Cherry Picking. (line 94) -* magit-sequence-skip <1>: Reverting. (line 35) -* magit-shell-command: Running Git Manually. - (line 40) -* magit-shell-command-topdir: Running Git Manually. - (line 35) -* magit-show-commit: Diffing. (line 69) -* magit-show-commit <1>: Blaming. (line 78) -* magit-show-refs: References Buffer. (line 6) -* magit-show-refs-current: References Buffer. (line 26) -* magit-show-refs-head: References Buffer. (line 21) -* magit-show-refs-other: References Buffer. (line 32) -* magit-snapshot-both: Stashing. (line 40) -* magit-snapshot-index: Stashing. (line 47) -* magit-snapshot-worktree: Stashing. (line 52) -* magit-stage: Staging and Unstaging. - (line 28) -* magit-stage-file: Staging from File-Visiting Buffers. - (line 10) -* magit-stage-file <1>: Minor Mode for Buffers Visiting Files. - (line 59) -* magit-stage-modified: Staging and Unstaging. - (line 36) -* magit-stash: Stashing. (line 8) -* magit-stash-apply: Stashing. (line 59) -* magit-stash-both: Stashing. (line 14) -* magit-stash-branch: Stashing. (line 81) -* magit-stash-branch-here: Stashing. (line 86) -* magit-stash-clear: Stashing. (line 96) -* magit-stash-drop: Stashing. (line 72) -* magit-stash-format-patch: Stashing. (line 92) -* magit-stash-index: Stashing. (line 21) -* magit-stash-keep-index: Stashing. (line 33) -* magit-stash-list: Stashing. (line 100) -* magit-stash-pop: Stashing. (line 65) -* magit-stash-show: Diffing. (line 74) -* magit-stash-show <1>: Stashing. (line 77) -* magit-stash-worktree: Stashing. (line 26) -* magit-status: Status Buffer. (line 22) -* magit-submodule: Submodule Transient. (line 6) -* magit-submodule-add: Submodule Transient. (line 20) -* magit-submodule-fetch: Fetching. (line 54) -* magit-submodule-populate: Submodule Transient. (line 34) -* magit-submodule-register: Submodule Transient. (line 27) -* magit-submodule-synchronize: Submodule Transient. (line 44) -* magit-submodule-unpopulate: Submodule Transient. (line 50) -* magit-submodule-update: Submodule Transient. (line 39) -* magit-subtree: Subtree. (line 8) -* magit-subtree-add: Subtree. (line 25) -* magit-subtree-add-commit: Subtree. (line 30) -* magit-subtree-export: Subtree. (line 42) -* magit-subtree-import: Subtree. (line 13) -* magit-subtree-merge: Subtree. (line 34) -* magit-subtree-pull: Subtree. (line 38) -* magit-subtree-push: Subtree. (line 54) -* magit-subtree-split: Subtree. (line 59) -* magit-tag: Tagging. (line 8) -* magit-tag-create: Tagging. (line 14) -* magit-tag-delete: Tagging. (line 39) -* magit-tag-prune: Tagging. (line 46) -* magit-tag-release: Tagging. (line 19) -* magit-toggle-buffer-lock: Modes and Buffers. (line 17) -* magit-toggle-margin: Refreshing Logs. (line 37) -* magit-toggle-margin <1>: Log Margin. (line 66) -* magit-toggle-margin-details: Log Margin. (line 74) -* magit-toggle-verbose-refresh: Debugging Tools. (line 30) -* magit-unstage: Staging and Unstaging. - (line 43) -* magit-unstage-all: Staging and Unstaging. - (line 52) -* magit-unstage-file: Staging from File-Visiting Buffers. - (line 18) -* magit-unstage-file <1>: Minor Mode for Buffers Visiting Files. - (line 63) -* magit-version: Git Executable. (line 17) -* magit-version <1>: Debugging Tools. (line 10) -* magit-visit-ref: References Buffer. (line 181) -* magit-wip-commit: Wip Modes. (line 88) -* magit-wip-log: Wip Modes. (line 48) -* magit-wip-log-current: Wip Modes. (line 57) -* magit-worktree: Worktree. (line 8) -* magit-worktree-branch: Worktree. (line 17) -* magit-worktree-checkout: Worktree. (line 13) -* magit-worktree-delete: Worktree. (line 25) -* magit-worktree-move: Worktree. (line 21) -* magit-worktree-status: Worktree. (line 30) -* scroll-down: Commands Available in Diffs. - (line 60) -* scroll-up: Commands Available in Diffs. - (line 56) -* with-editor-cancel: Editing Commit Messages. - (line 22) -* with-editor-cancel <1>: Editing Rebase Sequences. - (line 11) -* with-editor-debug: Debugging Tools. (line 44) -* with-editor-finish: Editing Commit Messages. - (line 17) -* with-editor-finish <1>: Editing Rebase Sequences. - (line 6) - - -File: magit.info, Node: Function Index, Next: Variable Index, Prev: Command Index, Up: Top - -Appendix E Function Index -************************* - - -* Menu: - -* bug-reference-mode: Commit Mode and Hooks. - (line 56) -* git-commit-check-style-conventions: Commit Message Conventions. - (line 40) -* git-commit-propertize-diff: Commit Mode and Hooks. - (line 47) -* git-commit-save-message: Commit Mode and Hooks. - (line 28) -* git-commit-setup-changelog-support: Commit Mode and Hooks. - (line 32) -* git-commit-turn-on-auto-fill: Commit Mode and Hooks. - (line 37) -* git-commit-turn-on-flyspell: Commit Mode and Hooks. - (line 42) -* ido-enter-magit-status: Status Buffer. (line 72) -* magit-add-section-hook: Section Hooks. (line 20) -* magit-after-save-refresh-status: Automatic Refreshing of Magit Buffers. - (line 58) -* magit-branch-or-checkout: Branch Commands. (line 257) -* magit-branch-orphan: Branch Commands. (line 252) -* magit-branch-shelve: Auxiliary Branch Commands. - (line 9) -* magit-branch-unshelve: Auxiliary Branch Commands. - (line 20) -* magit-builtin-completing-read: Support for Completion Frameworks. - (line 42) -* magit-call-git: Calling Git for Effect. - (line 28) -* magit-call-process: Calling Git for Effect. - (line 32) -* magit-cancel-section: Creating Sections. (line 71) -* magit-completing-read: Support for Completion Frameworks. - (line 60) -* magit-current-section: Section Selection. (line 6) -* magit-define-section-jumper: Creating Sections. (line 77) -* magit-diff-scope: Matching Sections. (line 118) -* magit-diff-type: Matching Sections. (line 95) -* magit-diff-visit-file-other-frame: Visiting Files and Blobs from a Diff. - (line 74) -* magit-diff-visit-file-other-window: Visiting Files and Blobs from a Diff. - (line 73) -* magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs from a Diff. - (line 76) -* magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs from a Diff. - (line 75) -* magit-disable-section-inserter: Per-Repository Configuration. - (line 31) -* magit-display-buffer: Switching Buffers. (line 6) -* magit-display-buffer-fullcolumn-most-v1: Switching Buffers. (line 75) -* magit-display-buffer-fullframe-status-topleft-v1: Switching Buffers. - (line 65) -* magit-display-buffer-fullframe-status-v1: Switching Buffers. - (line 59) -* magit-display-buffer-same-window-except-diff-v1: Switching Buffers. - (line 53) -* magit-display-buffer-traditional: Switching Buffers. (line 45) -* magit-file-checkout: Minor Mode for Buffers Visiting Files. - (line 165) -* magit-file-delete: Minor Mode for Buffers Visiting Files. - (line 157) -* magit-file-rename: Minor Mode for Buffers Visiting Files. - (line 153) -* magit-file-untrack: Minor Mode for Buffers Visiting Files. - (line 161) -* magit-find-file: General-Purpose Visit Commands. - (line 9) -* magit-find-file-other-frame: General-Purpose Visit Commands. - (line 21) -* magit-find-file-other-window: General-Purpose Visit Commands. - (line 15) -* magit-generate-buffer-name-default-function: Naming Buffers. - (line 17) -* magit-get-section: Matching Sections. (line 16) -* magit-git: Calling Git for Effect. - (line 65) -* magit-git-exit-code: Getting a Value from Git. - (line 10) -* magit-git-failure: Getting a Value from Git. - (line 19) -* magit-git-false: Getting a Value from Git. - (line 29) -* magit-git-insert: Getting a Value from Git. - (line 34) -* magit-git-items: Getting a Value from Git. - (line 49) -* magit-git-lines: Getting a Value from Git. - (line 44) -* magit-git-str: Getting a Value from Git. - (line 72) -* magit-git-string: Getting a Value from Git. - (line 38) -* magit-git-success: Getting a Value from Git. - (line 14) -* magit-git-true: Getting a Value from Git. - (line 24) -* magit-git-wash: Calling Git for Effect. - (line 70) -* magit-hunk-set-window-start: Section Movement. (line 51) -* magit-ido-completing-read: Support for Completion Frameworks. - (line 48) -* magit-insert-am-sequence: Status Sections. (line 28) -* magit-insert-assumed-unchanged-files: Status Sections. (line 117) -* magit-insert-bisect-log: Status Sections. (line 46) -* magit-insert-bisect-output: Status Sections. (line 38) -* magit-insert-bisect-rest: Status Sections. (line 42) -* magit-insert-diff-filter-header: Status Header Sections. - (line 38) -* magit-insert-error-header: Status Header Sections. - (line 28) -* magit-insert-head-branch-header: Status Header Sections. - (line 42) -* magit-insert-heading: Creating Sections. (line 42) -* magit-insert-ignored-files: Status Sections. (line 100) -* magit-insert-local-branches: References Sections. (line 17) -* magit-insert-merge-log: Status Sections. (line 18) -* magit-insert-modules: Status Module Sections. - (line 12) -* magit-insert-modules-overview: Status Module Sections. - (line 33) -* magit-insert-modules-unpulled-from-pushremote: Status Module Sections. - (line 50) -* magit-insert-modules-unpulled-from-upstream: Status Module Sections. - (line 44) -* magit-insert-modules-unpushed-to-pushremote: Status Module Sections. - (line 62) -* magit-insert-modules-unpushed-to-upstream: Status Module Sections. - (line 56) -* magit-insert-push-branch-header: Status Header Sections. - (line 51) -* magit-insert-rebase-sequence: Status Sections. (line 23) -* magit-insert-recent-commits: Status Sections. (line 131) -* magit-insert-remote-branches: References Sections. (line 21) -* magit-insert-remote-header: Status Header Sections. - (line 67) -* magit-insert-repo-header: Status Header Sections. - (line 63) -* magit-insert-section: Creating Sections. (line 6) -* magit-insert-sequencer-sequence: Status Sections. (line 33) -* magit-insert-skip-worktree-files: Status Sections. (line 110) -* magit-insert-staged-changes: Status Sections. (line 63) -* magit-insert-stashes: Status Sections. (line 67) -* magit-insert-status-headers: Status Header Sections. - (line 12) -* magit-insert-tags: References Sections. (line 25) -* magit-insert-tags-header: Status Header Sections. - (line 56) -* magit-insert-tracked-files: Status Sections. (line 96) -* magit-insert-unpulled-cherries: Status Sections. (line 142) -* magit-insert-unpulled-from-pushremote: Status Sections. (line 79) -* magit-insert-unpulled-from-upstream: Status Sections. (line 74) -* magit-insert-unpulled-or-recent-commits: Status Sections. (line 124) -* magit-insert-unpushed-cherries: Status Sections. (line 149) -* magit-insert-unpushed-to-pushremote: Status Sections. (line 89) -* magit-insert-unpushed-to-upstream: Status Sections. (line 84) -* magit-insert-unstaged-changes: Status Sections. (line 59) -* magit-insert-untracked-files: Status Sections. (line 50) -* magit-insert-upstream-branch-header: Status Header Sections. - (line 46) -* magit-insert-user-header: Status Header Sections. - (line 75) -* magit-list-repositories: Repository List. (line 6) -* magit-list-submodules: Listing Submodules. (line 13) -* magit-log-maybe-show-more-commits: Section Movement. (line 66) -* magit-log-maybe-update-blob-buffer: Section Movement. (line 82) -* magit-log-maybe-update-revision-buffer: Section Movement. (line 74) -* magit-maybe-set-dedicated: Switching Buffers. (line 100) -* magit-mode-display-buffer: Refreshing Buffers. (line 33) -* magit-mode-quit-window: Quitting Windows. (line 34) -* magit-mode-setup: Refreshing Buffers. (line 17) -* magit-push-implicitly: Pushing. (line 74) -* magit-push-to-remote: Pushing. (line 85) -* magit-region-sections: Section Selection. (line 10) -* magit-region-values: Section Selection. (line 37) -* magit-repolist-column-branch: Repository List. (line 44) -* magit-repolist-column-branches: Repository List. (line 53) -* magit-repolist-column-flag: Repository List. (line 61) -* magit-repolist-column-ident: Repository List. (line 30) -* magit-repolist-column-path: Repository List. (line 35) -* magit-repolist-column-stashes: Repository List. (line 57) -* magit-repolist-column-unpulled-from-pushremote: Repository List. - (line 81) -* magit-repolist-column-unpulled-from-upstream: Repository List. - (line 76) -* magit-repolist-column-unpushed-to-pushremote: Repository List. - (line 91) -* magit-repolist-column-unpushed-to-upstream: Repository List. - (line 86) -* magit-repolist-column-upstream: Repository List. (line 48) -* magit-repolist-column-version: Repository List. (line 39) -* magit-restore-window-configuration: Quitting Windows. (line 23) -* magit-run-git: Calling Git for Effect. - (line 36) -* magit-run-git-async: Calling Git for Effect. - (line 80) -* magit-run-git-with-editor: Calling Git for Effect. - (line 93) -* magit-run-git-with-input: Calling Git for Effect. - (line 40) -* magit-run-git-with-logfile: Calling Git for Effect. - (line 56) -* magit-save-window-configuration: Switching Buffers. (line 89) -* magit-section-case: Matching Sections. (line 71) -* magit-section-hide: Section Visibility. (line 49) -* magit-section-hide-children: Section Visibility. (line 64) -* magit-section-ident: Matching Sections. (line 11) -* magit-section-match: Matching Sections. (line 21) -* magit-section-set-window-start: Section Movement. (line 59) -* magit-section-show: Section Visibility. (line 45) -* magit-section-show-children: Section Visibility. (line 58) -* magit-section-show-headings: Section Visibility. (line 53) -* magit-section-toggle-children: Section Visibility. (line 68) -* magit-section-value-if: Matching Sections. (line 61) -* magit-start-git: Calling Git for Effect. - (line 105) -* magit-start-process: Calling Git for Effect. - (line 124) -* magit-stashes-maybe-update-stash-buffer: Section Movement. (line 106) -* magit-status-maybe-update-blob-buffer: Section Movement. (line 100) -* magit-status-maybe-update-revision-buffer: Section Movement. - (line 88) -* magit-status-maybe-update-stash-buffer: Section Movement. (line 94) -* magit-wip-log: Wip Modes. (line 48) -* magit-wip-log-current: Wip Modes. (line 57) -* with-editor-usage-message: Commit Mode and Hooks. - (line 60) - - -File: magit.info, Node: Variable Index, Prev: Function Index, Up: Top - -Appendix F Variable Index -************************* - - -* Menu: - -* auto-revert-buffer-list-filter: Automatic Reverting of File-Visiting Buffers. - (line 81) -* auto-revert-interval: Automatic Reverting of File-Visiting Buffers. - (line 76) -* auto-revert-mode: Automatic Reverting of File-Visiting Buffers. - (line 62) -* auto-revert-stop-on-user-input: Automatic Reverting of File-Visiting Buffers. - (line 71) -* auto-revert-use-notify: Automatic Reverting of File-Visiting Buffers. - (line 49) -* auto-revert-verbose: Automatic Reverting of File-Visiting Buffers. - (line 103) -* branch.autoSetupMerge: Branch Git Variables. - (line 81) -* branch.autoSetupRebase: Branch Git Variables. - (line 98) -* branch.NAME.description: Branch Git Variables. - (line 48) -* branch.NAME.merge: Branch Git Variables. - (line 10) -* branch.NAME.pushRemote: Branch Git Variables. - (line 34) -* branch.NAME.rebase: Branch Git Variables. - (line 22) -* branch.NAME.remote: Branch Git Variables. - (line 16) -* core.notesRef: Notes. (line 60) -* git-commit-fill-column: Commit Message Conventions. - (line 19) -* git-commit-finish-query-functions: Commit Message Conventions. - (line 24) -* git-commit-known-pseudo-headers: Commit Pseudo Headers. - (line 9) -* git-commit-major-mode: Commit Mode and Hooks. - (line 12) -* git-commit-setup-hook: Commit Mode and Hooks. - (line 22) -* git-commit-setup-hook <1>: Commit Mode and Hooks. - (line 64) -* git-commit-style-convention-checks: Commit Message Conventions. - (line 46) -* git-commit-summary-max-length: Commit Message Conventions. - (line 13) -* git-rebase-auto-advance: Editing Rebase Sequences. - (line 99) -* git-rebase-confirm-cancel: Editing Rebase Sequences. - (line 107) -* git-rebase-show-instructions: Editing Rebase Sequences. - (line 103) -* global-auto-revert-mode: Automatic Reverting of File-Visiting Buffers. - (line 22) -* global-magit-file-mode: Minor Mode for Buffers Visiting Files. - (line 13) -* magit-auto-revert-immediately: Automatic Reverting of File-Visiting Buffers. - (line 32) -* magit-auto-revert-mode: Automatic Reverting of File-Visiting Buffers. - (line 17) -* magit-auto-revert-tracked-only: Automatic Reverting of File-Visiting Buffers. - (line 55) -* magit-bisect-show-graph: Bisecting. (line 55) -* magit-blame-disable-modes: Blaming. (line 168) -* magit-blame-echo-style: Blaming. (line 151) -* magit-blame-goto-chunk-hook: Blaming. (line 174) -* magit-blame-read-only: Blaming. (line 163) -* magit-blame-styles: Blaming. (line 146) -* magit-blame-time-format: Blaming. (line 158) -* magit-branch-adjust-remote-upstream-alist: Branch Commands. (line 210) -* magit-branch-direct-configure: Branch Commands. (line 20) -* magit-branch-prefer-remote-upstream: Branch Commands. (line 165) -* magit-branch-read-upstream-first: Branch Commands. (line 159) -* magit-buffer-name-format: Naming Buffers. (line 27) -* magit-bury-buffer-function: Quitting Windows. (line 14) -* magit-cherry-margin: Cherries. (line 22) -* magit-clone-always-transient: Cloning Repository. (line 12) -* magit-clone-default-directory: Cloning Repository. (line 90) -* magit-clone-name-alist: Cloning Repository. (line 103) -* magit-clone-set-remote-head: Cloning Repository. (line 68) -* magit-clone-set-remote.pushDefault: Cloning Repository. (line 78) -* magit-clone-url-format: Cloning Repository. (line 124) -* magit-commit-ask-to-stage: Initiating a Commit. (line 75) -* magit-commit-extend-override-date: Initiating a Commit. (line 80) -* magit-commit-reword-override-date: Initiating a Commit. (line 84) -* magit-commit-squash-confirm: Initiating a Commit. (line 88) -* magit-completing-read-function: Support for Completion Frameworks. - (line 27) -* magit-diff-adjust-tab-width: Diff Options. (line 21) -* magit-diff-buffer-file-locked: Minor Mode for Buffers Visiting Files. - (line 91) -* magit-diff-hide-trailing-cr-characters: Diff Options. (line 90) -* magit-diff-highlight-hunk-region-functions: Diff Options. (line 94) -* magit-diff-highlight-indentation: Diff Options. (line 75) -* magit-diff-highlight-trailing: Diff Options. (line 70) -* magit-diff-paint-whitespace: Diff Options. (line 43) -* magit-diff-paint-whitespace-lines: Diff Options. (line 60) -* magit-diff-refine-hunk: Diff Options. (line 6) -* magit-diff-refine-ignore-whitespace: Diff Options. (line 16) -* magit-diff-unmarked-lines-keep-foreground: Diff Options. (line 120) -* magit-diff-visit-previous-blob: Visiting Files and Blobs from a Diff. - (line 39) -* magit-direct-use-buffer-arguments: Transient Arguments and Buffer Variables. - (line 73) -* magit-display-buffer-function: Switching Buffers. (line 27) -* magit-display-buffer-noselect: Switching Buffers. (line 18) -* magit-dwim-selection: Completion and Confirmation. - (line 42) -* magit-ediff-dwim-show-on-hunks: Ediffing. (line 73) -* magit-ediff-quit-hook: Ediffing. (line 88) -* magit-ediff-show-stash-with-index: Ediffing. (line 81) -* magit-file-mode-map: Minor Mode for Buffers Visiting Files. - (line 20) -* magit-generate-buffer-name-function: Naming Buffers. (line 6) -* magit-git-debug: Viewing Git Output. (line 28) -* magit-git-debug <1>: Getting a Value from Git. - (line 64) -* magit-git-executable: Git Executable. (line 39) -* magit-git-global-arguments: Global Git Arguments. - (line 6) -* magit-keep-region-overlay: The Selection. (line 52) -* magit-list-refs-sortby: Additional Completion Options. - (line 6) -* magit-log-auto-more: Log Buffer. (line 69) -* magit-log-buffer-file-locked: Minor Mode for Buffers Visiting Files. - (line 118) -* magit-log-margin: Log Margin. (line 12) -* magit-log-margin-show-committer-date: Log Margin. (line 49) -* magit-log-section-commit-count: Status Sections. (line 136) -* magit-log-select-margin: Select from Log. (line 30) -* magit-log-show-refname-after-summary: Log Buffer. (line 75) -* magit-log-trace-definition-function: Commands Available in Diffs. - (line 18) -* magit-module-sections-hook: Status Module Sections. - (line 20) -* magit-module-sections-nested: Status Module Sections. - (line 24) -* magit-no-confirm: Action Confirmation. (line 18) -* magit-pop-revision-stack-format: Using the Revision Stack. - (line 35) -* magit-post-display-buffer-hook: Switching Buffers. (line 95) -* magit-pre-display-buffer-hook: Switching Buffers. (line 84) -* magit-prefer-remote-upstream: Branch Git Variables. - (line 126) -* magit-prefix-use-buffer-arguments: Transient Arguments and Buffer Variables. - (line 64) -* magit-process-raise-error: Calling Git for Effect. - (line 151) -* magit-pull-or-fetch: Fetching. (line 59) -* magit-reflog-margin: Reflog. (line 23) -* magit-refresh-args: Refreshing Buffers. (line 55) -* magit-refresh-buffer-hook: Automatic Refreshing of Magit Buffers. - (line 42) -* magit-refresh-function: Refreshing Buffers. (line 49) -* magit-refresh-status-buffer: Automatic Refreshing of Magit Buffers. - (line 48) -* magit-refs-filter-alist: References Buffer. (line 159) -* magit-refs-focus-column-width: References Buffer. (line 82) -* magit-refs-margin: References Buffer. (line 97) -* magit-refs-margin-for-tags: References Buffer. (line 125) -* magit-refs-pad-commit-counts: References Buffer. (line 49) -* magit-refs-primary-column-width: References Buffer. (line 69) -* magit-refs-sections-hook: References Sections. (line 13) -* magit-refs-show-commit-count: References Buffer. (line 37) -* magit-refs-show-remote-prefix: References Buffer. (line 62) -* magit-remote-add-set-remote.pushDefault: Remote Commands. (line 92) -* magit-remote-direct-configure: Remote Commands. (line 21) -* magit-repolist-columns: Repository List. (line 14) -* magit-repository-directories: Status Buffer. (line 58) -* magit-revision-filter-files-on-follow: Revision Buffer. (line 64) -* magit-revision-insert-related-refs: Revision Buffer. (line 6) -* magit-revision-show-gravatars: Revision Buffer. (line 19) -* magit-revision-use-hash-sections: Revision Buffer. (line 36) -* magit-root-section: Matching Sections. (line 87) -* magit-save-repository-buffers: Automatic Saving of File-Visiting Buffers. - (line 13) -* magit-section-cache-visibility: Section Visibility. (line 95) -* magit-section-initial-visibility-alist: Section Visibility. (line 78) -* magit-section-movement-hook: Section Movement. (line 46) -* magit-section-set-visibility-hook: Section Visibility. (line 106) -* magit-section-show-child-count: Section Options. (line 9) -* magit-section-visibility-indicator: Section Visibility. (line 124) -* magit-shell-command-verbose-prompt: Running Git Manually. - (line 47) -* magit-stashes-margin: Stashing. (line 104) -* magit-status-headers-hook: Status Header Sections. - (line 18) -* magit-status-margin: Status Options. (line 10) -* magit-status-refresh-hook: Status Options. (line 6) -* magit-status-sections-hook: Status Sections. (line 10) -* magit-submodule-list-columns: Listing Submodules. (line 21) -* magit-this-process: Calling Git for Effect. - (line 146) -* magit-uniquify-buffer-names: Naming Buffers. (line 74) -* magit-unstage-committed: Staging and Unstaging. - (line 56) -* magit-update-other-window-delay: Section Movement. (line 112) -* magit-visit-ref-behavior: References Buffer. (line 192) -* magit-wip-after-apply-mode: Legacy Wip Modes. (line 19) -* magit-wip-after-apply-mode-lighter: Legacy Wip Modes. (line 59) -* magit-wip-after-save-local-mode-lighter: Legacy Wip Modes. (line 55) -* magit-wip-after-save-mode: Legacy Wip Modes. (line 13) -* magit-wip-before-change-mode: Legacy Wip Modes. (line 33) -* magit-wip-before-change-mode-lighter: Legacy Wip Modes. (line 63) -* magit-wip-initial-backup-mode: Legacy Wip Modes. (line 38) -* magit-wip-initial-backup-mode-lighter: Legacy Wip Modes. (line 67) -* magit-wip-merge-branch: Wip Graph. (line 6) -* magit-wip-mode: Wip Modes. (line 30) -* magit-wip-mode-lighter: Wip Modes. (line 104) -* magit-wip-namespace: Wip Modes. (line 96) -* notes.displayRef: Notes. (line 65) -* pull.rebase: Branch Git Variables. - (line 57) -* remote.NAME.fetch: Remote Git Variables. - (line 15) -* remote.NAME.push: Remote Git Variables. - (line 26) -* remote.NAME.pushurl: Remote Git Variables. - (line 20) -* remote.NAME.tagOpts: Remote Git Variables. - (line 31) -* remote.NAME.url: Remote Git Variables. - (line 10) -* remote.pushDefault: Branch Git Variables. - (line 71) - |