magit.info-2 (208851B)
1 This is magit.info, produced by makeinfo version 6.7 from magit.texi. 2 3 Copyright (C) 2015-2021 Jonas Bernoulli <jonas@bernoul.li> 4 5 You can redistribute this document and/or modify it under the terms 6 of the GNU General Public License as published by the Free Software 7 Foundation, either version 3 of the License, or (at your option) 8 any later version. 9 10 This document is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 INFO-DIR-SECTION Emacs 16 START-INFO-DIR-ENTRY 17 * Magit: (magit). Using Git from Emacs with Magit. 18 END-INFO-DIR-ENTRY 19 20 21 File: magit.info, Node: Submodules, Next: Subtree, Prev: Notes, Up: Miscellaneous 22 23 8.3 Submodules 24 ============== 25 26 Also see *note (gitman)git-submodule::. 27 28 * Menu: 29 30 * Listing Submodules:: 31 * Submodule Transient:: 32 33 34 File: magit.info, Node: Listing Submodules, Next: Submodule Transient, Up: Submodules 35 36 8.3.1 Listing Submodules 37 ------------------------ 38 39 The command ‘magit-list-submodules’ displays a list of the current 40 repository’s submodules in a separate buffer. It’s also possible to 41 display information about submodules directly in the status buffer of 42 the super-repository by adding ‘magit-insert-modules’ to the hook 43 ‘magit-status-sections-hook’ as described in *note Status Module 44 Sections::. 45 46 -- Command: magit-list-submodules 47 48 This command displays a list of the current repository’s submodules 49 in a separate buffer. 50 51 It can be invoked by pressing ‘RET’ on the section titled 52 "Modules". 53 54 -- User Option: magit-submodule-list-columns 55 56 This option controls what columns are displayed by the command 57 ‘magit-list-submodules’ and how they are displayed. 58 59 Each element has the form ‘(HEADER WIDTH FORMAT PROPS)’. 60 61 HEADER is the string displayed in the header. WIDTH is the width 62 of the column. FORMAT is a function that is called with one 63 argument, the repository identification (usually its basename), and 64 with ‘default-directory’ bound to the toplevel of its working tree. 65 It has to return a string to be inserted or nil. PROPS is an alist 66 that supports the keys ‘:right-align’ and ‘:pad-right’. 67 68 69 File: magit.info, Node: Submodule Transient, Prev: Listing Submodules, Up: Submodules 70 71 8.3.2 Submodule Transient 72 ------------------------- 73 74 ‘o’ (‘magit-submodule’) 75 76 This transient prefix command binds the following suffix commands 77 along with the appropriate infix arguments and displays them in a 78 temporary buffer until a suffix is invoked. 79 80 Some of the below commands default to act on the modules that are 81 selected using the region. For brevity their description talk about 82 "the selected modules", but if no modules are selected, then they act on 83 the current module instead, or if point isn’t on a module, then the read 84 a single module to act on. With a prefix argument these commands ignore 85 the selection and the current module and instead act on all suitable 86 modules. 87 88 ‘o a’ (‘magit-submodule-add’) 89 90 This commands adds the repository at URL as a module. Optional 91 PATH is the path to the module relative to the root of the 92 super-project. If it is nil then the path is determined based on 93 URL. 94 95 ‘o r’ (‘magit-submodule-register’) 96 97 This command registers the selected modules by copying their urls 98 from ".gitmodules" to "$GIT_DIR/config". These values can then be 99 edited before running ‘magit-submodule-populate’. If you don’t 100 need to edit any urls, then use the latter directly. 101 102 ‘o p’ (‘magit-submodule-populate’) 103 104 This command creates the working directory or directories of the 105 selected modules, checking out the recorded commits. 106 107 ‘o u’ (‘magit-submodule-update’) 108 109 This command updates the selected modules checking out the recorded 110 commits. 111 112 ‘o s’ (‘magit-submodule-synchronize’) 113 114 This command synchronizes the urls of the selected modules, copying 115 the values from ".gitmodules" to the ".git/config" of the 116 super-project as well those of the modules. 117 118 ‘o d’ (‘magit-submodule-unpopulate’) 119 120 This command removes the working directory of the selected modules. 121 122 ‘o l’ (‘magit-list-submodules’) 123 124 This command displays a list of the current repository’s modules. 125 126 ‘o f’ (‘magit-fetch-modules’) 127 128 This command fetches all modules. 129 130 Option ‘magit-fetch-modules-jobs’ controls how many submodules are 131 being fetched in parallel. Also fetch the super-repository, 132 because ‘git fetch’ does not support not doing that. With a prefix 133 argument fetch all remotes. 134 135 136 File: magit.info, Node: Subtree, Next: Worktree, Prev: Submodules, Up: Miscellaneous 137 138 8.4 Subtree 139 =========== 140 141 Also see *note (gitman)git-subtree::. 142 143 ‘O’ (‘magit-subtree’) 144 145 This transient prefix command binds the two sub-transients; one for 146 importing a subtree and one for exporting a subtree. 147 148 ‘O i’ (‘magit-subtree-import’) 149 150 This transient prefix command binds the following suffix commands 151 along with the appropriate infix arguments and displays them in a 152 temporary buffer until a suffix is invoked. 153 154 The suffixes of this command import subtrees. 155 156 If the ‘--prefix’ argument is set, then the suffix commands use 157 that prefix without prompting the user. If it is unset, then they 158 read the prefix in the minibuffer. 159 160 ‘O i a’ (‘magit-subtree-add’) 161 162 This command adds COMMIT from REPOSITORY as a new subtree at 163 PREFIX. 164 165 ‘O i c’ (‘magit-subtree-add-commit’) 166 167 This command add COMMIT as a new subtree at PREFIX. 168 169 ‘O i m’ (‘magit-subtree-merge’) 170 171 This command merges COMMIT into the PREFIX subtree. 172 173 ‘O i f’ (‘magit-subtree-pull’) 174 175 This command pulls COMMIT from REPOSITORY into the PREFIX subtree. 176 177 ‘O e’ (‘magit-subtree-export’) 178 179 This transient prefix command binds the following suffix commands 180 along with the appropriate infix arguments and displays them in a 181 temporary buffer until a suffix is invoked. 182 183 The suffixes of this command export subtrees. 184 185 If the ‘--prefix’ argument is set, then the suffix commands use 186 that prefix without prompting the user. If it is unset, then they 187 read the prefix in the minibuffer. 188 189 ‘O e p’ (‘magit-subtree-push’) 190 191 This command extract the history of the subtree PREFIX and pushes 192 it to REF on REPOSITORY. 193 194 ‘O e s’ (‘magit-subtree-split’) 195 196 This command extracts the history of the subtree PREFIX. 197 198 199 File: magit.info, Node: Worktree, Next: Bundle, Prev: Subtree, Up: Miscellaneous 200 201 8.5 Worktree 202 ============ 203 204 Also see *note (gitman)git-worktree::. 205 206 ‘Z’ (‘magit-worktree’) 207 208 This transient prefix command binds the following suffix commands 209 and displays them in a temporary buffer until a suffix is invoked. 210 211 ‘Z b’ (‘magit-worktree-checkout’) 212 213 Checkout BRANCH in a new worktree at PATH. 214 215 ‘Z c’ (‘magit-worktree-branch’) 216 217 Create a new BRANCH and check it out in a new worktree at PATH. 218 219 ‘Z m’ (‘magit-worktree-move’) 220 221 Move an existing worktree to a new PATH. 222 223 ‘Z k’ (‘magit-worktree-delete’) 224 225 Delete a worktree, defaulting to the worktree at point. The 226 primary worktree cannot be deleted. 227 228 ‘Z g’ (‘magit-worktree-status’) 229 230 Show the status for the worktree at point. 231 232 If there is no worktree at point, then read one in the minibuffer. 233 If the worktree at point is the one whose status is already being 234 displayed in the current buffer, then show it in Dired instead. 235 236 237 File: magit.info, Node: Bundle, Next: Common Commands, Prev: Worktree, Up: Miscellaneous 238 239 8.6 Bundle 240 ========== 241 242 Also see *note (gitman)git-bundle::. 243 244 -- Command: magit-bundle 245 246 This transient prefix command binds several suffix commands for 247 running ‘git bundle’ subcommands and displays them in a temporary 248 buffer until a suffix is invoked. 249 250 251 File: magit.info, Node: Common Commands, Next: Wip Modes, Prev: Bundle, Up: Miscellaneous 252 253 8.7 Common Commands 254 =================== 255 256 -- Command: magit-switch-to-repository-buffer 257 -- Command: magit-switch-to-repository-buffer-other-window 258 -- Command: magit-switch-to-repository-buffer-other-frame 259 -- Command: magit-display-repository-buffer 260 261 These commands read any existing Magit buffer that belongs to the 262 current repository from the user and then switch to the selected 263 buffer (without refreshing it). 264 265 The last variant uses ‘magit-display-buffer’ to do so and thus 266 respects ‘magit-display-buffer-function’. 267 268 These are some of the commands that can be used in all buffers whose 269 major-modes derive from ‘magit-mode’. There are other common commands 270 beside the ones below, but these didn’t fit well anywhere else. 271 272 ‘C-w’ (‘magit-copy-section-value’) 273 274 This command saves the value of the current section to the 275 ‘kill-ring’, and, provided that the current section is a commit, 276 branch, or tag section, it also pushes the (referenced) revision to 277 the ‘magit-revision-stack’. 278 279 When the current section is a branch or a tag, and a prefix 280 argument is used, then it saves the revision at its tip to the 281 ‘kill-ring’ instead of the reference name. 282 283 When the region is active, this command saves that to the 284 ‘kill-ring’, like ‘kill-ring-save’ would, instead of behaving as 285 described above. If a prefix argument is used and the region is 286 within a hunk, then it strips the diff marker column and keeps only 287 either the added or removed lines, depending on the sign of the 288 prefix argument. 289 290 ‘M-w’ (‘magit-copy-buffer-revision’) 291 292 This command saves the revision being displayed in the current 293 buffer to the ‘kill-ring’ and also pushes it to the 294 ‘magit-revision-stack’. It is mainly intended for use in 295 ‘magit-revision-mode’ buffers, the only buffers where it is always 296 unambiguous exactly which revision should be saved. 297 298 Most other Magit buffers usually show more than one revision, in 299 some way or another, so this command has to select one of them, and 300 that choice might not always be the one you think would have been 301 the best pick. 302 303 Outside of Magit ‘M-w’ and ‘C-w’ are usually bound to 304 ‘kill-ring-save’ and ‘kill-region’, and these commands would also be 305 useful in Magit buffers. Therefore when the region is active, then both 306 of these commands behave like ‘kill-ring-save’ instead of as described 307 above. 308 309 310 File: magit.info, Node: Wip Modes, Next: Commands for Buffers Visiting Files, Prev: Common Commands, Up: Miscellaneous 311 312 8.8 Wip Modes 313 ============= 314 315 Git keeps *committed* changes around long enough for users to recover 316 changes they have accidentally deleted. It does so by not garbage 317 collecting any committed but no longer referenced objects for a certain 318 period of time, by default 30 days. 319 320 But Git does *not* keep track of *uncommitted* changes in the working 321 tree and not even the index (the staging area). Because Magit makes it 322 so convenient to modify uncommitted changes, it also makes it easy to 323 shoot yourself in the foot in the process. 324 325 For that reason Magit provides a global mode that saves *tracked* 326 files to work-in-progress references after or before certain actions. 327 (At present untracked files are never saved and for technical reasons 328 nothing is saved before the first commit has been created). 329 330 Two separate work-in-progress references are used to track the state 331 of the index and of the working tree: ‘refs/wip/index/<branchref>’ and 332 ‘refs/wip/wtree/<branchref>’, where ‘<branchref>’ is the full ref of the 333 current branch, e.g. ‘refs/heads/master’. When the ‘HEAD’ is detached 334 then ‘HEAD’ is used in place of ‘<branchref>’. 335 336 Checking out another branch (or detaching ‘HEAD’) causes the use of 337 different wip refs for subsequent changes. 338 339 -- User Option: magit-wip-mode 340 341 When this mode is enabled, then uncommitted changes are committed 342 to dedicated work-in-progress refs whenever appropriate (i.e. when 343 dataloss would be a possibility otherwise). 344 345 Setting this variable directly does not take effect; either use the 346 Custom interface to do so or call the respective mode function. 347 348 For historic reasons this mode is implemented on top of four other 349 ‘magit-wip-*’ modes, which can also be used individually, if you 350 want finer control over when the wip refs are updated; but that is 351 discouraged. See *note Legacy Wip Modes::. 352 353 To view the log for a branch and its wip refs use the commands 354 ‘magit-wip-log’ and ‘magit-wip-log-current’. You should use ‘--graph’ 355 when using these commands. 356 357 -- Command: magit-wip-log 358 359 This command shows the log for a branch and its wip refs. With a 360 negative prefix argument only the worktree wip ref is shown. 361 362 The absolute numeric value of the prefix argument controls how many 363 "branches" of each wip ref are shown. This is only relevant if the 364 value of ‘magit-wip-merge-branch’ is ‘nil’. 365 366 -- Command: magit-wip-log-current 367 368 This command shows the log for the current branch and its wip refs. 369 With a negative prefix argument only the worktree wip ref is shown. 370 371 The absolute numeric value of the prefix argument controls how many 372 "branches" of each wip ref are shown. This is only relevant if the 373 value of ‘magit-wip-merge-branch’ is ‘nil’. 374 375 ‘X w’ (‘magit-reset-worktree’) 376 377 This command resets the working tree to some commit read from the 378 user and defaulting to the commit at point, while keeping the 379 ‘HEAD’ and index as-is. 380 381 This can be used to restore files to the state committed to a wip 382 ref. Note that this will discard any unstaged changes that might 383 have existed before invoking this command (but of course only after 384 committing that to the working tree wip ref). 385 386 Note that even if you enable ‘magit-wip-mode’ this won’t give you 387 perfect protection. The most likely scenario for losing changes despite 388 the use of ‘magit-wip-mode’ is making a change outside Emacs and then 389 destroying it also outside Emacs. In some such a scenario, Magit, being 390 an Emacs package, didn’t get the opportunity to keep you from shooting 391 yourself in the foot. 392 393 When you are unsure whether Magit did commit a change to the wip 394 refs, then you can explicitly request that all changes to all tracked 395 files are being committed. 396 397 ‘M-x magit-wip-commit’ (‘magit-wip-commit’) 398 399 This command commits all changes to all tracked files to the index 400 and working tree work-in-progress refs. Like the modes described 401 above, it does not commit untracked files, but it does check all 402 tracked files for changes. Use this command when you suspect that 403 the modes might have overlooked a change made outside Emacs/Magit. 404 405 -- User Option: magit-wip-namespace 406 407 The namespace used for work-in-progress refs. It has to end with a 408 slash. The wip refs are named ‘<namespace>index/<branchref>’ and 409 ‘<namespace>wtree/<branchref>’. When snapshots are created while 410 the ‘HEAD’ is detached then ‘HEAD’ is used in place of 411 ‘<branchref>’. 412 413 -- User Option: magit-wip-mode-lighter 414 415 Mode-line lighter for ‘magit-wip--mode’. 416 417 * Menu: 418 419 * Wip Graph:: 420 * Legacy Wip Modes:: 421 422 423 File: magit.info, Node: Wip Graph, Next: Legacy Wip Modes, Up: Wip Modes 424 425 8.8.1 Wip Graph 426 --------------- 427 428 -- User Option: magit-wip-merge-branch 429 430 This option controls whether the current branch is merged into the 431 wip refs after a new commit was created on the branch. 432 433 If non-nil and the current branch has new commits, then it is 434 merged into the wip ref before creating a new wip commit. This 435 makes it easier to inspect wip history and the wip commits are 436 never garbage collected. 437 438 If nil and the current branch has new commits, then the wip ref is 439 reset to the tip of the branch before creating a new wip commit. 440 With this setting wip commits are eventually garbage collected. 441 442 When ‘magit-wip-merge-branch’ is ‘t’, then the history looks like 443 this: 444 445 *--*--*--*--*--* refs/wip/index/refs/heads/master 446 / / / 447 A-----B-----C refs/heads/master 448 449 When ‘magit-wip-merge-branch’ is ‘nil’, then creating a commit on the 450 real branch and then making a change causes the wip refs to be recreated 451 to fork from the new commit. But the old commits on the wip refs are 452 not lost. They are still available from the reflog. To make it easier 453 to see when the fork point of a wip ref was changed, an additional 454 commit with the message "restart autosaving" is created on it (‘xxO’ 455 commits below are such boundary commits). 456 457 Starting with 458 459 BI0---BI1 refs/wip/index/refs/heads/master 460 / 461 A---B refs/heads/master 462 \ 463 BW0---BW1 refs/wip/wtree/refs/heads/master 464 465 and committing the staged changes and editing and saving a file would 466 result in 467 468 BI0---BI1 refs/wip/index/refs/heads/master 469 / 470 A---B---C refs/heads/master 471 \ \ 472 \ CW0---CW1 refs/wip/wtree/refs/heads/master 473 \ 474 BW0---BW1 refs/wip/wtree/refs/heads/master@{2} 475 476 The fork-point of the index wip ref is not changed until some change 477 is being staged. Likewise just checking out a branch or creating a 478 commit does not change the fork-point of the working tree wip ref. The 479 fork-points are not adjusted until there actually is a change that 480 should be committed to the respective wip ref. 481 482 483 File: magit.info, Node: Legacy Wip Modes, Prev: Wip Graph, Up: Wip Modes 484 485 8.8.2 Legacy Wip Modes 486 ---------------------- 487 488 It is recommended that you use the mode ‘magit-wip-mode’ (which see) and 489 ignore the existence of the following modes, which are preserved for 490 historic reasons. 491 492 Setting the following variables directly does not take effect; either 493 use the Custom interface to do so or call the respective mode functions. 494 495 -- User Option: magit-wip-after-save-mode 496 497 When this mode is enabled, then saving a buffer that visits a file 498 tracked in a Git repository causes its current state to be 499 committed to the working tree wip ref for the current branch. 500 501 -- User Option: magit-wip-after-apply-mode 502 503 When this mode is enabled, then applying (i.e. staging, unstaging, 504 discarding, reversing, and regularly applying) a change to a file 505 tracked in a Git repository causes its current state to be 506 committed to the index and/or working tree wip refs for the current 507 branch. 508 509 If you only ever edit files using Emacs and only ever interact with 510 Git using Magit, then the above two modes should be enough to protect 511 each and every change from accidental loss. In practice nobody does 512 that. Two additional modes exists that do commit to the wip refs before 513 making changes that could cause the loss of earlier changes. 514 515 -- User Option: magit-wip-before-change-mode 516 517 When this mode is enabled, then certain commands commit the 518 existing changes to the files they are about to make changes to. 519 520 -- User Option: magit-wip-initial-backup-mode 521 522 When this mode is enabled, then the current version of a file is 523 committed to the worktree wip ref before the buffer visiting that 524 file is saved for the first time since the buffer was created. 525 526 This backs up the same version of the file that ‘backup-buffer’ 527 would save. While ‘backup-buffer’ uses a backup file, this mode 528 uses the same worktree wip ref as used by the other Magit Wip 529 modes. Like ‘backup-buffer’, it only does this once; unless you 530 kill the buffer and visit the file again only one backup will be 531 created per Emacs session. 532 533 This mode ignores the variables that affect ‘backup-buffer’ and can 534 be used along-side that function, which is recommended because it 535 only backs up files that are tracked in a Git repository. 536 537 -- User Option: magit-wip-after-save-local-mode-lighter 538 539 Mode-line lighter for ‘magit-wip-after-save-local-mode’. 540 541 -- User Option: magit-wip-after-apply-mode-lighter 542 543 Mode-line lighter for ‘magit-wip-after-apply-mode’. 544 545 -- User Option: magit-wip-before-change-mode-lighter 546 547 Mode-line lighter for ‘magit-wip-before-change-mode’. 548 549 -- User Option: magit-wip-initial-backup-mode-lighter 550 551 Mode-line lighter for ‘magit-wip-initial-backup-mode’. 552 553 554 File: magit.info, Node: Commands for Buffers Visiting Files, Next: Minor Mode for Buffers Visiting Blobs, Prev: Wip Modes, Up: Miscellaneous 555 556 8.9 Commands for Buffers Visiting Files 557 ======================================= 558 559 Magit defines a few global key bindings unless the user sets 560 ‘magit-define-global-key-bindings’ to ‘nil’. This includes binding ‘C-c 561 M-g’ to ‘magit-file-dispatch’. ‘C-c g’ would be a much better binding 562 but the ‘C-c <letter>’ namespace is reserved for users, meaning that 563 packages are not allowed to use it. If you want to use ‘C-c g’, then 564 you have to add that binding yourself. Also see *note Default 565 Bindings:: and *note (elisp)Key Binding Conventions::. 566 567 If you want a better binding, you have to add it yourself: 568 569 (global-set-key (kbd "C-c g") 'magit-file-dispatch) 570 571 The key bindings shown below assume that you have not improved the 572 binding for ‘magit-file-dispatch’. 573 574 ‘C-c M-g’ (‘magit-file-dispatch’) 575 576 This transient prefix command binds the following suffix commands 577 and displays them in a temporary buffer until a suffix is invoked. 578 579 When invoked in a buffer that does not visit a file, then it falls 580 back to regular ‘magit-dispatch’. 581 582 ‘C-c M-g s’ (‘magit-stage-file’) 583 584 Stage all changes to the file being visited in the current buffer. 585 586 ‘C-c M-g u’ (‘magit-unstage-file’) 587 588 Unstage all changes to the file being visited in the current 589 buffer. 590 591 ‘C-c M-g c’ (‘magit-commit’) 592 593 This transient prefix command binds the following suffix commands 594 along with the appropriate infix arguments and displays them in a 595 temporary buffer until a suffix is invoked. See *note Initiating a 596 Commit::. 597 598 ‘C-c M-g D’ (‘magit-diff’) 599 600 This transient prefix command binds several diff suffix commands 601 and infix arguments and displays them in a temporary buffer until a 602 suffix is invoked. See *note Diffing::. 603 604 This is the same command that ‘d’ is bound to in Magit buffers. If 605 this command is invoked from a file-visiting buffer, then the 606 initial value of the option (‘--’) that limits the diff to certain 607 file(s) is set to the visited file. 608 609 ‘C-c M-g d’ (‘magit-diff-buffer-file’) 610 611 This command shows the diff for the file of blob that the current 612 buffer visits. 613 614 -- User Option: magit-diff-buffer-file-locked 615 616 This option controls whether ‘magit-diff-buffer-file’ uses a 617 dedicated buffer. See *note Modes and Buffers::. 618 619 ‘C-c M-g L’ (‘magit-log’) 620 621 This transient prefix command binds several log suffix commands and 622 infix arguments and displays them in a temporary buffer until a 623 suffix is invoked. See *note Logging::. 624 625 This is the same command that ‘l’ is bound to in Magit buffers. If 626 this command is invoked from a file-visiting buffer, then the 627 initial value of the option (‘--’) that limits the log to certain 628 file(s) is set to the visited file. 629 630 ‘C-c M-g l’ (‘magit-log-buffer-file’) 631 632 This command shows the log for the file of blob that the current 633 buffer visits. Renames are followed when a prefix argument is used 634 or when ‘--follow’ is an active log argument. When the region is 635 active, the log is restricted to the selected line range. 636 637 ‘C-c M-g t’ (‘magit-log-trace-definition’) 638 639 This command shows the log for the definition at point. 640 641 -- User Option: magit-log-buffer-file-locked 642 643 This option controls whether ‘magit-log-buffer-file’ uses a 644 dedicated buffer. See *note Modes and Buffers::. 645 646 ‘C-c M-g B’ (‘magit-blame’) 647 648 This transient prefix command binds all blaming suffix commands 649 along with the appropriate infix arguments and displays them in a 650 temporary buffer until a suffix is invoked. 651 652 For more information about this and the following commands also see 653 *note Blaming::. 654 655 In addition to the ‘magit-blame’ sub-transient, the dispatch 656 transient also binds several blaming suffix commands directly. See 657 *note Blaming:: for information about those commands and bindings. 658 659 ‘C-c M-g e’ (‘magit-edit-line-commit’) 660 661 This command makes the commit editable that added the current line. 662 663 With a prefix argument it makes the commit editable that removes 664 the line, if any. The commit is determined using ‘git blame’ and 665 made editable using ‘git rebase --interactive’ if it is reachable 666 from ‘HEAD’, or by checking out the commit (or a branch that points 667 at it) otherwise. 668 669 ‘C-c M-g p’ (‘magit-blob-previous’) 670 671 Visit the previous blob which modified the current file. 672 673 There are a few additional commands that operate on a single file but 674 are not enabled in the file transient command by default: 675 676 -- Command: magit-file-rename 677 678 This command renames a file read from the user. 679 680 -- Command: magit-file-delete 681 682 This command deletes a file read from the user. 683 684 -- Command: magit-file-untrack 685 686 This command untracks a file read from the user. 687 688 -- Command: magit-file-checkout 689 690 This command updates a file in the working tree and index to the 691 contents from a revision. Both the revision and file are read from 692 the user. 693 694 To enable them invoke the transient (‘C-c M-g’), enter "edit mode" 695 (‘C-x l’), set the "transient level" (‘C-x l’ again), enter ‘5’, and 696 leave edit mode (‘C-g’). Also see *note (transient)Enabling and 697 Disabling Suffixes::. 698 699 700 File: magit.info, Node: Minor Mode for Buffers Visiting Blobs, Prev: Commands for Buffers Visiting Files, Up: Miscellaneous 701 702 8.10 Minor Mode for Buffers Visiting Blobs 703 ========================================== 704 705 The ‘magit-blob-mode’ enables certain Magit features in blob-visiting 706 buffers. Such buffers can be created using ‘magit-find-file’ and some 707 of the commands mentioned below, which also take care of turning on this 708 minor mode. Currently this mode only establishes a few key bindings, 709 but this might be extended. 710 711 ‘p’ (‘magit-blob-previous’) 712 713 Visit the previous blob which modified the current file. 714 715 ‘n’ (‘magit-blob-next’) 716 717 Visit the next blob which modified the current file. 718 719 ‘q’ (‘magit-kill-this-buffer’) 720 721 Kill the current buffer. 722 723 724 File: magit.info, Node: Customizing, Next: Plumbing, Prev: Miscellaneous, Up: Top 725 726 9 Customizing 727 ************* 728 729 Both Git and Emacs are highly customizable. Magit is both a Git 730 porcelain as well as an Emacs package, so it makes sense to customize it 731 using both Git variables as well as Emacs options. However this 732 flexibility doesn’t come without problems, including but not limited to 733 the following. 734 735 • Some Git variables automatically have an effect in Magit without 736 requiring any explicit support. Sometimes that is desirable - in 737 other cases, it breaks Magit. 738 739 When a certain Git setting breaks Magit but you want to keep using 740 that setting on the command line, then that can be accomplished by 741 overriding the value for Magit only by appending something like 742 ‘("-c" "some.variable=compatible-value")’ to 743 ‘magit-git-global-arguments’. 744 745 • Certain settings like ‘fetch.prune=true’ are respected by Magit 746 commands (because they simply call the respective Git command) but 747 their value is not reflected in the respective transient buffers. 748 In this case the ‘--prune’ argument in ‘magit-fetch’ might be 749 active or inactive, but that doesn’t keep the Git variable from 750 being honored by the suffix commands anyway. So pruning might 751 happen despite the ‘--prune’ arguments being displayed in a way 752 that seems to indicate that no pruning will happen. 753 754 I intend to address these and similar issues in a future release. 755 756 * Menu: 757 758 * Per-Repository Configuration:: 759 * Essential Settings:: 760 761 762 File: magit.info, Node: Per-Repository Configuration, Next: Essential Settings, Up: Customizing 763 764 9.1 Per-Repository Configuration 765 ================================ 766 767 Magit can be configured on a per-repository level using both Git 768 variables as well as Emacs options. 769 770 To set a Git variable for one repository only, simply set it in 771 ‘/path/to/repo/.git/config’ instead of ‘$HOME/.gitconfig’ or 772 ‘/etc/gitconfig’. See *note (gitman)git-config::. 773 774 Similarly, Emacs options can be set for one repository only by 775 editing ‘/path/to/repo/.dir-locals.el’. See *note (emacs)Directory 776 Variables::. For example to disable automatic refreshes of 777 file-visiting buffers in just one huge repository use this: 778 779 • ‘/path/to/huge/repo/.dir-locals.el’ 780 781 ((nil . ((magit-refresh-buffers . nil)))) 782 783 It might only be costly to insert certain information into Magit 784 buffers for repositories that are exceptionally large, in which case you 785 can disable the respective section inserters just for that repository: 786 787 • ‘/path/to/tag/invested/repo/.dir-locals.el’ 788 789 ((magit-status-mode 790 . ((eval . (magit-disable-section-inserter 'magit-insert-tags-header))))) 791 792 -- Function: magit-disable-section-inserter fn 793 794 This function disables the section inserter FN in the current 795 repository. It is only intended for use in ‘.dir-locals.el’ and 796 ‘.dir-locals-2.el’. 797 798 If you want to apply the same settings to several, but not all, 799 repositories then keeping the repository-local config files in sync 800 would quickly become annoying. To avoid that you can create config 801 files for certain classes of repositories (e.g. "huge repositories") 802 and then include those files in the per-repository config files. For 803 example: 804 805 • ‘/path/to/huge/repo/.git/config’ 806 807 [include] 808 path = /path/to/huge-gitconfig 809 810 • ‘/path/to/huge-gitconfig’ 811 812 [status] 813 showUntrackedFiles = no 814 815 • ‘$HOME/.emacs.d/init.el’ 816 817 (dir-locals-set-class-variables 'huge-git-repository 818 '((nil . ((magit-refresh-buffers . nil))))) 819 820 (dir-locals-set-directory-class 821 "/path/to/huge/repo/" 'huge-git-repository) 822 823 824 File: magit.info, Node: Essential Settings, Prev: Per-Repository Configuration, Up: Customizing 825 826 9.2 Essential Settings 827 ====================== 828 829 The next two sections list and discuss several variables that many users 830 might want to customize, for safety and/or performance reasons. 831 832 * Menu: 833 834 * Safety:: 835 * Performance:: 836 * Default Bindings:: 837 838 839 File: magit.info, Node: Safety, Next: Performance, Up: Essential Settings 840 841 9.2.1 Safety 842 ------------ 843 844 This section discusses various variables that you might want to change 845 (or *not* change) for safety reasons. 846 847 Git keeps *committed* changes around long enough for users to recover 848 changes they have accidentally been deleted. It does not do the same 849 for *uncommitted* changes in the working tree and not even the index 850 (the staging area). Because Magit makes it so easy to modify 851 uncommitted changes, it also makes it easy to shoot yourself in the foot 852 in the process. For that reason Magit provides three global modes that 853 save *tracked* files to work-in-progress references after or before 854 certain actions. See *note Wip Modes::. 855 856 These modes are not enabled by default because of performance 857 concerns. Instead a lot of potentially destructive commands require 858 confirmation every time they are used. In many cases this can be 859 disabled by adding a symbol to ‘magit-no-confirm’ (see *note Completion 860 and Confirmation::). If you enable the various wip modes then you 861 should add ‘safe-with-wip’ to this list. 862 863 Similarly it isn’t necessary to require confirmation before moving a 864 file to the system trash - if you trashed a file by mistake then you can 865 recover it from there. Option ‘magit-delete-by-moving-to-trash’ 866 controls whether the system trash is used, which is the case by default. 867 Nevertheless, ‘trash’ isn’t a member of ‘magit-no-confirm’ - you might 868 want to change that. 869 870 By default buffers visiting files are automatically reverted when the 871 visited file changes on disk. This isn’t as risky as it might seem, but 872 to make an informed decision you should see *note Risk of Reverting 873 Automatically::. 874 875 876 File: magit.info, Node: Performance, Next: Default Bindings, Prev: Safety, Up: Essential Settings 877 878 9.2.2 Performance 879 ----------------- 880 881 After Magit has run ‘git’ for side-effects, it also refreshes the 882 current Magit buffer and the respective status buffer. This is 883 necessary because otherwise outdated information might be displayed 884 without the user noticing. Magit buffers are updated by recreating 885 their content from scratch, which makes updating simpler and less 886 error-prone, but also more costly. Keeping it simple and just 887 re-creating everything from scratch is an old design decision and 888 departing from that will require major refactoring. 889 890 I plan to do that in time for the next major release. I also intend 891 to create logs and diffs asynchronously, which should also help a lot 892 but also requires major refactoring. 893 894 Meanwhile you can tell Magit to only automatically refresh the 895 current Magit buffer, but not the status buffer. If you do that, then 896 the status buffer is only refreshed automatically if it is the current 897 buffer. 898 899 (setq magit-refresh-status-buffer nil) 900 901 You should also check whether any third-party packages have added 902 anything to ‘magit-refresh-buffer-hook’, ‘magit-status-refresh-hook’, 903 ‘magit-pre-refresh-hook’, and ‘magit-post-refresh-hook’. If so, then 904 check whether those additions impact performance significantly. 905 906 Magit can be told to refresh buffers verbosely using ‘M-x 907 magit-toggle-verbose-refresh’. Enabling this helps figuring out which 908 sections are bottlenecks. The additional output can be found in the 909 ‘*Messages*’ buffer. 910 911 Magit also reverts buffers for visited files located inside the 912 current repository when the visited file changes on disk. That is 913 implemented on top of ‘auto-revert-mode’ from the built-in library 914 ‘autorevert’. To figure out whether that impacts performance, check 915 whether performance is significantly worse, when many buffers exist 916 and/or when some buffers visit files using TRAMP. If so, then this 917 should help. 918 919 (setq auto-revert-buffer-list-filter 920 'magit-auto-revert-repository-buffer-p) 921 922 For alternative approaches see *note Automatic Reverting of 923 File-Visiting Buffers::. 924 925 If you have enabled any features that are disabled by default, then 926 you should check whether they impact performance significantly. It’s 927 likely that they were not enabled by default because it is known that 928 they reduce performance at least in large repositories. 929 930 If performance is only slow inside certain unusually large 931 repositories, then you might want to disable certain features on a 932 per-repository or per-repository-class basis only. See *note 933 Per-Repository Configuration::. For example it takes a long time to 934 determine the next and current tag in repository with exceptional 935 numbers of tags. It would therefore be a good idea to disable 936 ‘magit-insert-tags-headers’, as explained at the mentioned node. 937 938 * Menu: 939 940 * Microsoft Windows Performance:: 941 * MacOS Performance:: 942 943 Log Performance 944 ............... 945 946 When showing logs, Magit limits the number of commits initially shown in 947 the hope that this avoids unnecessary work. When using ‘--graph’ is 948 used, then this unfortunately does not have the desired effect for large 949 histories. Junio, Git’s maintainer, said on the git mailing list 950 (<http://www.spinics.net/lists/git/msg232230.html>): "‘--graph’ wants to 951 compute the whole history and the max-count only affects the output 952 phase after ‘--graph’ does its computation". 953 954 In other words, it’s not that Git is slow at outputting the 955 differences, or that Magit is slow at parsing the output - the problem 956 is that Git first goes outside and has a smoke. 957 958 We actually work around this issue by limiting the number of commits 959 not only by using ‘-<N>’ but by also using a range. But unfortunately 960 that’s not always possible. 961 962 When more than a few thousand commits are shown, then the use of 963 ‘--graph’ can slow things down. 964 965 Using ‘--color --graph’ is even slower. Magit uses code that is part 966 of Emacs to turn control characters into faces. That code is pretty 967 slow and this is quite noticeable when showing a log with many branches 968 and merges. For that reason ‘--color’ is not enabled by default 969 anymore. Consider leaving it at that. 970 971 Diff Performance 972 ................ 973 974 If diffs are slow, then consider turning off some optional diff features 975 by setting all or some of the following variables to ‘nil’: 976 ‘magit-diff-highlight-indentation’, ‘magit-diff-highlight-trailing’, 977 ‘magit-diff-paint-whitespace’, ‘magit-diff-highlight-hunk-body’, and 978 ‘magit-diff-refine-hunk’. 979 980 When showing a commit instead of some arbitrary diff, then some 981 additional information is displayed. Calculating this information can 982 be quite expensive given certain circumstances. If looking at a commit 983 using ‘magit-revision-mode’ takes considerably more time than looking at 984 the same commit in ‘magit-diff-mode’, then consider setting 985 ‘magit-revision-insert-related-refs’ to ‘nil’. 986 987 When you are often confronted with diffs that contain deleted files, 988 then you might want to enable the ‘--irreversible-delete’ argument. If 989 you do that then diffs still show that a file was deleted but without 990 also showing the complete deleted content of the file. This argument is 991 not available by default, see *note (transient)Enabling and Disabling 992 Suffixes::. Once you have done that you should enable it and save that 993 setting, see *note (transient)Saving Values::. You should do this in 994 both the diff (‘d’) and the diff refresh (‘D’) transient popups. 995 996 Refs Buffer Performance 997 ....................... 998 999 When refreshing the "references buffer" is slow, then that’s usually 1000 because several hundred refs are being displayed. The best way to 1001 address that is to display fewer refs, obviously. 1002 1003 If you are not, or only mildly, interested in seeing the list of 1004 tags, then start by not displaying them: 1005 1006 (remove-hook 'magit-refs-sections-hook 'magit-insert-tags) 1007 1008 Then you should also make sure that the listed remote branches 1009 actually all exist. You can do so by pruning branches which no longer 1010 exist using ‘f-pa’. 1011 1012 Committing Performance 1013 ...................... 1014 1015 When you initiate a commit, then Magit by default automatically shows a 1016 diff of the changes you are about to commit. For large commits this can 1017 take a long time, which is especially distracting when you are 1018 committing large amounts of generated data which you don’t actually 1019 intend to inspect before committing. This behavior can be turned off 1020 using: 1021 1022 (remove-hook 'server-switch-hook 'magit-commit-diff) 1023 1024 Then you can type ‘C-c C-d’ to show the diff when you actually want 1025 to see it, but only then. Alternatively you can leave the hook alone 1026 and just type ‘C-g’ in those cases when it takes too long to generate 1027 the diff. If you do that, then you will end up with a broken diff 1028 buffer, but doing it this way has the advantage that you usually get to 1029 see the diff, which is useful because it increases the odds that you 1030 spot potential issues. 1031 1032 1033 File: magit.info, Node: Microsoft Windows Performance, Next: MacOS Performance, Up: Performance 1034 1035 Microsoft Windows Performance 1036 ............................. 1037 1038 In order to update the status buffer, ‘git’ has to be run a few dozen 1039 times. That is problematic on Microsoft Windows, because that operating 1040 system is exceptionally slow at starting processes. Sadly this is an 1041 issue that can only be fixed by Microsoft itself, and they don’t appear 1042 to be particularly interested in doing so. 1043 1044 Beside the subprocess issue, there are also other Windows-specific 1045 performance issues. Some of these have workarounds. The maintainers of 1046 "Git for Windows" try to improve performance on Windows. Always use the 1047 latest release in order to benefit from the latest performance tweaks. 1048 Magit too tries to work around some Windows-specific issues. 1049 1050 According to some sources, setting the following Git variables can 1051 also help. 1052 1053 git config --global core.preloadindex true # default since v2.1 1054 git config --global core.fscache true # default since v2.8 1055 git config --global gc.auto 256 1056 1057 You should also check whether an anti-virus program is affecting 1058 performance. 1059 1060 1061 File: magit.info, Node: MacOS Performance, Prev: Microsoft Windows Performance, Up: Performance 1062 1063 MacOS Performance 1064 ................. 1065 1066 Before Emacs 26.1 child processes were created using ‘fork’ on macOS. 1067 That needlessly copied GUI resources, which is expensive. The result 1068 was that forking took about 30 times as long on Darwin than on Linux, 1069 and because Magit starts many ‘git’ processes that made quite a 1070 difference. 1071 1072 So make sure that you are using at least Emacs 26.1, in which case 1073 the faster ‘vfork’ will be used. (The creation of child processes still 1074 takes about twice as long on Darwin compared to Linux.) See (1) for 1075 more information. 1076 1077 ---------- Footnotes ---------- 1078 1079 (1) 1080 <https://lists.gnu.org/archive/html/bug-gnu-emacs/2017-04/msg00201.html> 1081 1082 1083 File: magit.info, Node: Default Bindings, Prev: Performance, Up: Essential Settings 1084 1085 9.2.3 Default Bindings 1086 ---------------------- 1087 1088 -- User Option: magit-define-global-key-bindings 1089 1090 This option controls whether some Magit commands are automatically 1091 bound in the global keymap even before Magit is used for the first 1092 time in the current session. 1093 1094 If this variable is non-nil, which it is by default, then the 1095 following bindings may be added to the global keymap. 1096 1097 ‘C-x g’ ‘magit-status’ 1098 ‘C-x M-g’ ‘magit-dispatch’ 1099 ‘C-c M-g’ ‘magit-file-dispatch’ 1100 1101 These bindings may be added when ‘after-init-hook’ is run. Each 1102 binding is added if and only if at that time no other key is bound 1103 to the same command and no other command is bound to the same key. 1104 In other words we try to avoid adding bindings that are 1105 unnecessary, as well as bindings that conflict with other bindings. 1106 1107 Adding the above bindings is delayed until ‘after-init-hook’ is 1108 called to allow users to set the variable anywhere in their init 1109 file (without having to make sure to do so before ‘magit’ is loaded 1110 or autoloaded) and to increase the likelihood that all the 1111 potentially conflicting user bindings have already been added. 1112 1113 To set this variable use either ‘setq’ or the Custom interface. Do 1114 not use the function ‘customize-set-variable’ because doing that 1115 would cause Magit to be loaded immediately when that form is 1116 evaluated (this differs from ‘custom-set-variables’, which doesn’t 1117 load the libraries that define the customized variables). 1118 1119 Setting this variable to nil has no effect if that is done after 1120 the key bindings have already been added. 1121 1122 We recommend that you bind ‘C-c g’ instead of ‘C-c M-g’ to 1123 ‘magit-file-dispatch’. The former is a much better binding but the 1124 ‘C-c <letter>’ namespace is strictly reserved for users; preventing 1125 Magit from using it by default. 1126 1127 (global-set-key (kbd "C-c g") 'magit-file-dispatch) 1128 1129 Also see *note Commands for Buffers Visiting Files:: and *note 1130 (elisp)Key Binding Conventions::. 1131 1132 1133 File: magit.info, Node: Plumbing, Next: FAQ, Prev: Customizing, Up: Top 1134 1135 10 Plumbing 1136 *********** 1137 1138 The following sections describe how to use several of Magit’s core 1139 abstractions to extend Magit itself or implement a separate extension. 1140 1141 A few of the low-level features used by Magit have been factored out 1142 into separate libraries/packages, so that they can be used by other 1143 packages, without having to depend on Magit. See *note 1144 (with-editor)Top:: for information about ‘with-editor’. ‘transient’ 1145 doesn’t have a manual yet. 1146 1147 If you are trying to find an unused key that you can bind to a 1148 command provided by your own Magit extension, then checkout 1149 <https://github.com/magit/magit/wiki/Plugin-Dispatch-Key-Registry>. 1150 1151 * Menu: 1152 1153 * Calling Git:: 1154 * Section Plumbing:: 1155 * Refreshing Buffers:: 1156 * Conventions:: 1157 1158 1159 File: magit.info, Node: Calling Git, Next: Section Plumbing, Up: Plumbing 1160 1161 10.1 Calling Git 1162 ================ 1163 1164 Magit provides many specialized functions for calling Git. All of these 1165 functions are defined in either ‘magit-git.el’ or ‘magit-process.el’ and 1166 have one of the prefixes ‘magit-run-’, ‘magit-call-’, ‘magit-start-’, or 1167 ‘magit-git-’ (which is also used for other things). 1168 1169 All of these functions accept an indefinite number of arguments, 1170 which are strings that specify command line arguments for Git (or in 1171 some cases an arbitrary executable). These arguments are flattened 1172 before being passed on to the executable; so instead of strings they can 1173 also be lists of strings and arguments that are ‘nil’ are silently 1174 dropped. Some of these functions also require a single mandatory 1175 argument before these command line arguments. 1176 1177 Roughly speaking, these functions run Git either to get some value or 1178 for side-effects. The functions that return a value are useful to 1179 collect the information necessary to populate a Magit buffer, while the 1180 others are used to implement Magit commands. 1181 1182 The functions in the value-only group always run synchronously, and 1183 they never trigger a refresh. The function in the side-effect group can 1184 be further divided into subgroups depending on whether they run Git 1185 synchronously or asynchronously, and depending on whether they trigger a 1186 refresh when the executable has finished. 1187 1188 * Menu: 1189 1190 * Getting a Value from Git:: 1191 * Calling Git for Effect:: 1192 1193 1194 File: magit.info, Node: Getting a Value from Git, Next: Calling Git for Effect, Up: Calling Git 1195 1196 10.1.1 Getting a Value from Git 1197 ------------------------------- 1198 1199 These functions run Git in order to get a value, an exit status, or 1200 output. Of course you could also use them to run Git commands that have 1201 side-effects, but that should be avoided. 1202 1203 -- Function: magit-git-exit-code &rest args 1204 1205 Executes git with ARGS and returns its exit code. 1206 1207 -- Function: magit-git-success &rest args 1208 1209 Executes git with ARGS and returns ‘t’ if the exit code is ‘0’, 1210 ‘nil’ otherwise. 1211 1212 -- Function: magit-git-failure &rest args 1213 1214 Executes git with ARGS and returns ‘t’ if the exit code is ‘1’, 1215 ‘nil’ otherwise. 1216 1217 -- Function: magit-git-true &rest args 1218 1219 Executes git with ARGS and returns ‘t’ if the first line printed by 1220 git is the string "true", ‘nil’ otherwise. 1221 1222 -- Function: magit-git-false &rest args 1223 1224 Executes git with ARGS and returns ‘t’ if the first line printed by 1225 git is the string "false", ‘nil’ otherwise. 1226 1227 -- Function: magit-git-insert &rest args 1228 1229 Executes git with ARGS and inserts its output at point. 1230 1231 -- Function: magit-git-string &rest args 1232 1233 Executes git with ARGS and returns the first line of its output. 1234 If there is no output or if it begins with a newline character, 1235 then this returns ‘nil’. 1236 1237 -- Function: magit-git-lines &rest args 1238 1239 Executes git with ARGS and returns its output as a list of lines. 1240 Empty lines anywhere in the output are omitted. 1241 1242 -- Function: magit-git-items &rest args 1243 1244 Executes git with ARGS and returns its null-separated output as a 1245 list. Empty items anywhere in the output are omitted. 1246 1247 If the value of option ‘magit-git-debug’ is non-nil and git exits 1248 with a non-zero exit status, then warn about that in the echo area 1249 and add a section containing git’s standard error in the current 1250 repository’s process buffer. 1251 1252 -- Function: magit-process-git destination &rest args 1253 1254 Calls Git synchronously in a separate process, returning its exit 1255 code. DESTINATION specifies how to handle the output, like for 1256 ‘call-process’, except that file handlers are supported. Enables 1257 Cygwin’s "noglob" option during the call and ensures unix eol 1258 conversion. 1259 1260 -- Function: magit-process-file process &optional infile buffer display 1261 &rest args 1262 1263 Processes files synchronously in a separate process. Identical to 1264 ‘process-file’ but temporarily enables Cygwin’s "noglob" option 1265 during the call and ensures unix eol conversion. 1266 1267 If an error occurs when using one of the above functions, then that 1268 is usually due to a bug, i.e. using an argument which is not actually 1269 supported. Such errors are usually not reported, but when they occur we 1270 need to be able to debug them. 1271 1272 -- User Option: magit-git-debug 1273 1274 Whether to report errors that occur when using ‘magit-git-insert’, 1275 ‘magit-git-string’, ‘magit-git-lines’, or ‘magit-git-items’. This 1276 does not actually raise an error. Instead a message is shown in 1277 the echo area, and git’s standard error is insert into a new 1278 section in the current repository’s process buffer. 1279 1280 -- Function: magit-git-str &rest args 1281 1282 This is a variant of ‘magit-git-string’ that ignores the option 1283 ‘magit-git-debug’. It is mainly intended to be used while handling 1284 errors in functions that do respect that option. Using such a 1285 function while handing an error could cause yet another error and 1286 therefore lead to an infinite recursion. You probably won’t ever 1287 need to use this function. 1288 1289 1290 File: magit.info, Node: Calling Git for Effect, Prev: Getting a Value from Git, Up: Calling Git 1291 1292 10.1.2 Calling Git for Effect 1293 ----------------------------- 1294 1295 These functions are used to run git to produce some effect. Most Magit 1296 commands that actually run git do so by using such a function. 1297 1298 Because we do not need to consume git’s output when using these 1299 functions, their output is instead logged into a per-repository buffer, 1300 which can be shown using ‘$’ from a Magit buffer or ‘M-x magit-process’ 1301 elsewhere. 1302 1303 These functions can have an effect in two distinct ways. Firstly, 1304 running git may change something, i.e. create or push a new commit. 1305 Secondly, that change may require that Magit buffers are refreshed to 1306 reflect the changed state of the repository. But refreshing isn’t 1307 always desirable, so only some of these functions do perform such a 1308 refresh after git has returned. 1309 1310 Sometimes it is useful to run git asynchronously. For example, when 1311 the user has just initiated a push, then there is no reason to make her 1312 wait until that has completed. In other cases it makes sense to wait 1313 for git to complete before letting the user do something else. For 1314 example after staging a change it is useful to wait until after the 1315 refresh because that also automatically moves to the next change. 1316 1317 -- Function: magit-call-git &rest args 1318 1319 Calls git synchronously with ARGS. 1320 1321 -- Function: magit-call-process program &rest args 1322 1323 Calls PROGRAM synchronously with ARGS. 1324 1325 -- Function: magit-run-git &rest args 1326 1327 Calls git synchronously with ARGS and then refreshes. 1328 1329 -- Function: magit-run-git-with-input &rest args 1330 1331 Calls git synchronously with ARGS and sends it the content of the 1332 current buffer on standard input. 1333 1334 If the current buffer’s ‘default-directory’ is on a remote 1335 filesystem, this function actually runs git asynchronously. But 1336 then it waits for the process to return, so the function itself is 1337 synchronous. 1338 1339 -- Function: magit-git &rest args 1340 1341 Calls git synchronously with ARGS for side-effects only. This 1342 function does not refresh the buffer. 1343 1344 -- Function: magit-git-wash washer &rest args 1345 1346 Execute Git with ARGS, inserting washed output at point. Actually 1347 first insert the raw output at point. If there is no output call 1348 ‘magit-cancel-section’. Otherwise temporarily narrow the buffer to 1349 the inserted text, move to its beginning, and then call function 1350 WASHER with ARGS as its sole argument. 1351 1352 And now for the asynchronous variants. 1353 1354 -- Function: magit-run-git-async &rest args 1355 1356 Start Git, prepare for refresh, and return the process object. 1357 ARGS is flattened and then used as arguments to Git. 1358 1359 Display the command line arguments in the echo area. 1360 1361 After Git returns some buffers are refreshed: the buffer that was 1362 current when this function was called (if it is a Magit buffer and 1363 still alive), as well as the respective Magit status buffer. 1364 Unmodified buffers visiting files that are tracked in the current 1365 repository are reverted if ‘magit-revert-buffers’ is non-nil. 1366 1367 -- Function: magit-run-git-with-editor &rest args 1368 1369 Export GIT_EDITOR and start Git. Also prepare for refresh and 1370 return the process object. ARGS is flattened and then used as 1371 arguments to Git. 1372 1373 Display the command line arguments in the echo area. 1374 1375 After Git returns some buffers are refreshed: the buffer that was 1376 current when this function was called (if it is a Magit buffer and 1377 still alive), as well as the respective Magit status buffer. 1378 1379 -- Function: magit-start-git input &rest args 1380 1381 Start Git, prepare for refresh, and return the process object. 1382 1383 If INPUT is non-nil, it has to be a buffer or the name of an 1384 existing buffer. The buffer content becomes the processes standard 1385 input. 1386 1387 Option ‘magit-git-executable’ specifies the Git executable and 1388 option ‘magit-git-global-arguments’ specifies constant arguments. 1389 The remaining arguments ARGS specify arguments to Git. They are 1390 flattened before use. 1391 1392 After Git returns, some buffers are refreshed: the buffer that was 1393 current when this function was called (if it is a Magit buffer and 1394 still alive), as well as the respective Magit status buffer. 1395 Unmodified buffers visiting files that are tracked in the current 1396 repository are reverted if ‘magit-revert-buffers’ is non-nil. 1397 1398 -- Function: magit-start-process &rest args 1399 1400 Start PROGRAM, prepare for refresh, and return the process object. 1401 1402 If optional argument INPUT is non-nil, it has to be a buffer or the 1403 name of an existing buffer. The buffer content becomes the 1404 processes standard input. 1405 1406 The process is started using ‘start-file-process’ and then setup to 1407 use the sentinel ‘magit-process-sentinel’ and the filter 1408 ‘magit-process-filter’. Information required by these functions is 1409 stored in the process object. When this function returns the 1410 process has not started to run yet so it is possible to override 1411 the sentinel and filter. 1412 1413 After the process returns, ‘magit-process-sentinel’ refreshes the 1414 buffer that was current when ‘magit-start-process’ was called (if 1415 it is a Magit buffer and still alive), as well as the respective 1416 Magit status buffer. Unmodified buffers visiting files that are 1417 tracked in the current repository are reverted if 1418 ‘magit-revert-buffers’ is non-nil. 1419 1420 -- Variable: magit-this-process 1421 1422 The child process which is about to start. This can be used to 1423 change the filter and sentinel. 1424 1425 -- Variable: magit-process-raise-error 1426 1427 When this is non-nil, then ‘magit-process-sentinel’ raises an error 1428 if git exits with a non-zero exit status. For debugging purposes. 1429 1430 1431 File: magit.info, Node: Section Plumbing, Next: Refreshing Buffers, Prev: Calling Git, Up: Plumbing 1432 1433 10.2 Section Plumbing 1434 ===================== 1435 1436 * Menu: 1437 1438 * Creating Sections:: 1439 * Section Selection:: 1440 * Matching Sections:: 1441 1442 1443 File: magit.info, Node: Creating Sections, Next: Section Selection, Up: Section Plumbing 1444 1445 10.2.1 Creating Sections 1446 ------------------------ 1447 1448 -- Macro: magit-insert-section &rest args 1449 1450 Insert a section at point. 1451 1452 TYPE is the section type, a symbol. Many commands that act on the 1453 current section behave differently depending on that type. Also if 1454 a variable ‘magit-TYPE-section-map’ exists, then use that as the 1455 text-property ‘keymap’ of all text belonging to the section (but 1456 this may be overwritten in subsections). TYPE can also have the 1457 form ‘(eval FORM)’ in which case FORM is evaluated at runtime. 1458 1459 Optional VALUE is the value of the section, usually a string that 1460 is required when acting on the section. 1461 1462 When optional HIDE is non-nil collapse the section body by default, 1463 i.e. when first creating the section, but not when refreshing the 1464 buffer. Otherwise, expand it by default. This can be overwritten 1465 using ‘magit-section-set-visibility-hook’. When a section is 1466 recreated during a refresh, then the visibility of predecessor is 1467 inherited and HIDE is ignored (but the hook is still honored). 1468 1469 BODY is any number of forms that actually insert the section’s 1470 heading and body. Optional NAME, if specified, has to be a symbol, 1471 which is then bound to the struct of the section being inserted. 1472 1473 Before BODY is evaluated the ‘start’ of the section object is set 1474 to the value of ‘point’ and after BODY was evaluated its ‘end’ is 1475 set to the new value of ‘point’; BODY is responsible for moving 1476 ‘point’ forward. 1477 1478 If it turns out inside BODY that the section is empty, then 1479 ‘magit-cancel-section’ can be used to abort and remove all traces 1480 of the partially inserted section. This can happen when creating a 1481 section by washing Git’s output and Git didn’t actually output 1482 anything this time around. 1483 1484 -- Function: magit-insert-heading &rest args 1485 1486 Insert the heading for the section currently being inserted. 1487 1488 This function should only be used inside ‘magit-insert-section’. 1489 1490 When called without any arguments, then just set the ‘content’ slot 1491 of the object representing the section being inserted to a marker 1492 at ‘point’. The section should only contain a single line when 1493 this function is used like this. 1494 1495 When called with arguments ARGS, which have to be strings, then 1496 insert those strings at point. The section should not contain any 1497 text before this happens and afterwards it should again only 1498 contain a single line. If the ‘face’ property is set anywhere 1499 inside any of these strings, then insert all of them unchanged. 1500 Otherwise use the ‘magit-section-heading’ face for all inserted 1501 text. 1502 1503 The ‘content’ property of the section struct is the end of the 1504 heading (which lasts from ‘start’ to ‘content’) and the beginning 1505 of the body (which lasts from ‘content’ to ‘end’). If the value of 1506 ‘content’ is nil, then the section has no heading and its body 1507 cannot be collapsed. If a section does have a heading then its 1508 height must be exactly one line, including a trailing newline 1509 character. This isn’t enforced; you are responsible for getting it 1510 right. The only exception is that this function does insert a 1511 newline character if necessary. 1512 1513 -- Function: magit-cancel-section 1514 1515 Cancel the section currently being inserted. This exits the 1516 innermost call to ‘magit-insert-section’ and removes all traces of 1517 what has already happened inside that call. 1518 1519 -- Function: magit-define-section-jumper sym title &optional value 1520 1521 Define an interactive function to go to section SYM. TITLE is the 1522 displayed title of the section. 1523 1524 1525 File: magit.info, Node: Section Selection, Next: Matching Sections, Prev: Creating Sections, Up: Section Plumbing 1526 1527 10.2.2 Section Selection 1528 ------------------------ 1529 1530 -- Function: magit-current-section 1531 1532 Return the section at point. 1533 1534 -- Function: magit-region-sections &optional condition multiple 1535 1536 Return a list of the selected sections. 1537 1538 When the region is active and constitutes a valid section 1539 selection, then return a list of all selected sections. This is 1540 the case when the region begins in the heading of a section and 1541 ends in the heading of the same section or in that of a sibling 1542 section. If optional MULTIPLE is non-nil, then the region cannot 1543 begin and end in the same section. 1544 1545 When the selection is not valid, then return nil. In this case, 1546 most commands that can act on the selected sections will instead 1547 act on the section at point. 1548 1549 When the region looks like it would in any other buffer then the 1550 selection is invalid. When the selection is valid then the region 1551 uses the ‘magit-section-highlight’ face. This does not apply to 1552 diffs where things get a bit more complicated, but even here if the 1553 region looks like it usually does, then that’s not a valid 1554 selection as far as this function is concerned. 1555 1556 If optional CONDITION is non-nil, then the selection not only has 1557 to be valid; all selected sections additionally have to match 1558 CONDITION, or nil is returned. See ‘magit-section-match’ for the 1559 forms CONDITION can take. 1560 1561 -- Function: magit-region-values &optional condition multiple 1562 1563 Return a list of the values of the selected sections. 1564 1565 Return the values that themselves would be returned by 1566 ‘magit-region-sections’ (which see). 1567 1568 1569 File: magit.info, Node: Matching Sections, Prev: Section Selection, Up: Section Plumbing 1570 1571 10.2.3 Matching Sections 1572 ------------------------ 1573 1574 ‘M-x magit-describe-section-briefly’ (‘magit-describe-section-briefly’) 1575 1576 Show information about the section at point. This command is 1577 intended for debugging purposes. 1578 1579 -- Function: magit-section-ident section 1580 1581 Return an unique identifier for SECTION. The return value has the 1582 form ‘((TYPE . VALUE)...)’. 1583 1584 -- Function: magit-get-section ident &optional root 1585 1586 Return the section identified by IDENT. IDENT has to be a list as 1587 returned by ‘magit-section-ident’. 1588 1589 -- Function: magit-section-match condition &optional section 1590 1591 Return ‘t’ if SECTION matches CONDITION. SECTION defaults to the 1592 section at point. If SECTION is not specified and there also is no 1593 section at point, then return ‘nil’. 1594 1595 CONDITION can take the following forms: 1596 • ‘(CONDITION...)’ 1597 1598 matches if any of the CONDITIONs matches. 1599 1600 • ‘[CLASS...]’ 1601 1602 matches if the section’s class is the same as the first CLASS 1603 or a subclass of that; the section’s parent class matches the 1604 second CLASS; and so on. 1605 1606 • ‘[* CLASS...]’ 1607 1608 matches sections that match ‘[CLASS...]’ and also recursively 1609 all their child sections. 1610 1611 • ‘CLASS’ 1612 1613 matches if the section’s class is the same as CLASS or a 1614 subclass of that; regardless of the classes of the parent 1615 sections. 1616 1617 Each CLASS should be a class symbol, identifying a class that 1618 derives from ‘magit-section’. For backward compatibility CLASS can 1619 also be a "type symbol". A section matches such a symbol if the 1620 value of its ‘type’ slot is ‘eq’. If a type symbol has an entry in 1621 ‘magit--section-type-alist’, then a section also matches that type 1622 if its class is a subclass of the class that corresponds to the 1623 type as per that alist. 1624 1625 Note that it is not necessary to specify the complete section 1626 lineage as printed by ‘magit-describe-section-briefly’, unless of 1627 course you want to be that precise. 1628 1629 -- Function: magit-section-value-if condition &optional section 1630 1631 If the section at point matches CONDITION, then return its value. 1632 1633 If optional SECTION is non-nil then test whether that matches 1634 instead. If there is no section at point and SECTION is nil, then 1635 return nil. If the section does not match, then return nil. 1636 1637 See ‘magit-section-match’ for the forms CONDITION can take. 1638 1639 -- Function: magit-section-case &rest clauses 1640 1641 Choose among clauses on the type of the section at point. 1642 1643 Each clause looks like (CONDITION BODY...). The type of the 1644 section is compared against each CONDITION; the BODY forms of the 1645 first match are evaluated sequentially and the value of the last 1646 form is returned. Inside BODY the symbol ‘it’ is bound to the 1647 section at point. If no clause succeeds or if there is no section 1648 at point return nil. 1649 1650 See ‘magit-section-match’ for the forms CONDITION can take. 1651 Additionally a CONDITION of t is allowed in the final clause and 1652 matches if no other CONDITION match, even if there is no section at 1653 point. 1654 1655 -- Variable: magit-root-section 1656 1657 The root section in the current buffer. All other sections are 1658 descendants of this section. The value of this variable is set by 1659 ‘magit-insert-section’ and you should never modify it. 1660 1661 For diff related sections a few additional tools exist. 1662 1663 -- Function: magit-diff-type &optional section 1664 1665 Return the diff type of SECTION. 1666 1667 The returned type is one of the symbols ‘staged’, ‘unstaged’, 1668 ‘committed’, or ‘undefined’. This type serves a similar purpose as 1669 the general type common to all sections (which is stored in the 1670 ‘type’ slot of the corresponding ‘magit-section’ struct) but takes 1671 additional information into account. When the SECTION isn’t 1672 related to diffs and the buffer containing it also isn’t a 1673 diff-only buffer, then return nil. 1674 1675 Currently the type can also be one of ‘tracked’ and ‘untracked’, 1676 but these values are not handled explicitly in every place they 1677 should be. A possible fix could be to just return nil here. 1678 1679 The section has to be a ‘diff’ or ‘hunk’ section, or a section 1680 whose children are of type ‘diff’. If optional SECTION is nil, 1681 return the diff type for the current section. In buffers whose 1682 major mode is ‘magit-diff-mode’ SECTION is ignored and the type is 1683 determined using other means. In ‘magit-revision-mode’ buffers the 1684 type is always ‘committed’. 1685 1686 -- Function: magit-diff-scope &optional section strict 1687 1688 Return the diff scope of SECTION or the selected section(s). 1689 1690 A diff’s "scope" describes what part of a diff is selected, it is a 1691 symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or 1692 ‘list’. Do not confuse this with the diff "type", as returned by 1693 ‘magit-diff-type’. 1694 1695 If optional SECTION is non-nil, then return the scope of that, 1696 ignoring the sections selected by the region. Otherwise return the 1697 scope of the current section, or if the region is active and 1698 selects a valid group of diff related sections, the type of these 1699 sections, i.e. ‘hunks’ or ‘files’. If SECTION (or if the current 1700 section that is nil) is a ‘hunk’ section and the region starts and 1701 ends inside the body of a that section, then the type is ‘region’. 1702 1703 If optional STRICT is non-nil then return nil if the diff type of 1704 the section at point is ‘untracked’ or the section at point is not 1705 actually a ‘diff’ but a ‘diffstat’ section. 1706 1707 1708 File: magit.info, Node: Refreshing Buffers, Next: Conventions, Prev: Section Plumbing, Up: Plumbing 1709 1710 10.3 Refreshing Buffers 1711 ======================= 1712 1713 All commands that create a new Magit buffer or change what is being 1714 displayed in an existing buffer do so by calling ‘magit-mode-setup’. 1715 Among other things, that function sets the buffer local values of 1716 ‘default-directory’ (to the top-level of the repository), 1717 ‘magit-refresh-function’, and ‘magit-refresh-args’. 1718 1719 Buffers are refreshed by calling the function that is the local value 1720 of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’, 1721 where ‘*’ may be something like ‘diff’) with the value of 1722 ‘magit-refresh-args’ as arguments. 1723 1724 -- Macro: magit-mode-setup buffer switch-func mode refresh-func 1725 &optional refresh-args 1726 1727 This function displays and selects BUFFER, turns on MODE, and 1728 refreshes a first time. 1729 1730 This function displays and optionally selects BUFFER by calling 1731 ‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as 1732 arguments. Then it sets the local value of 1733 ‘magit-refresh-function’ to REFRESH-FUNC and that of 1734 ‘magit-refresh-args’ to REFRESH-ARGS. Finally it creates the 1735 buffer content by calling REFRESH-FUNC with REFRESH-ARGS as 1736 arguments. 1737 1738 All arguments are evaluated before switching to BUFFER. 1739 1740 -- Function: magit-mode-display-buffer buffer mode &optional 1741 switch-function 1742 1743 This function display BUFFER in some window and select it. BUFFER 1744 may be a buffer or a string, the name of a buffer. The buffer is 1745 returned. 1746 1747 Unless BUFFER is already displayed in the selected frame, store the 1748 previous window configuration as a buffer local value, so that it 1749 can later be restored by ‘magit-mode-bury-buffer’. 1750 1751 The buffer is displayed and selected using SWITCH-FUNCTION. If 1752 that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s 1753 major mode derives from ‘magit-mode’. Otherwise ‘switch-to-buffer’ 1754 is used. 1755 1756 -- Variable: magit-refresh-function 1757 1758 The value of this buffer-local variable is the function used to 1759 refresh the current buffer. It is called with ‘magit-refresh-args’ 1760 as arguments. 1761 1762 -- Variable: magit-refresh-args 1763 1764 The list of arguments used by ‘magit-refresh-function’ to refresh 1765 the current buffer. ‘magit-refresh-function’ is called with these 1766 arguments. 1767 1768 The value is usually set using ‘magit-mode-setup’, but in some 1769 cases it’s also useful to provide commands that can change the 1770 value. For example, the ‘magit-diff-refresh’ transient can be used 1771 to change any of the arguments used to display the diff, without 1772 having to specify again which differences should be shown, but 1773 ‘magit-diff-more-context’, ‘magit-diff-less-context’ and 1774 ‘magit-diff-default-context’ change just the ‘-U<N>’ argument. In 1775 both case this is done by changing the value of this variable and 1776 then calling this ‘magit-refresh-function’. 1777 1778 1779 File: magit.info, Node: Conventions, Prev: Refreshing Buffers, Up: Plumbing 1780 1781 10.4 Conventions 1782 ================ 1783 1784 Also see *note Completion and Confirmation::. 1785 1786 * Menu: 1787 1788 * Theming Faces:: 1789 1790 1791 File: magit.info, Node: Theming Faces, Up: Conventions 1792 1793 10.4.1 Theming Faces 1794 -------------------- 1795 1796 The default theme uses blue for local branches, green for remote 1797 branches, and goldenrod (brownish yellow) for tags. When creating a new 1798 theme, you should probably follow that example. If your theme already 1799 uses other colors, then stick to that. 1800 1801 In older releases these reference faces used to have a background 1802 color and a box around them. The basic default faces no longer do so, 1803 to make Magit buffers much less noisy, and you should follow that 1804 example at least with regards to boxes. (Boxes were used in the past to 1805 work around a conflict between the highlighting overlay and text 1806 property backgrounds. That’s no longer necessary because highlighting 1807 no longer causes other background colors to disappear.) Alternatively 1808 you can keep the background color and/or box, but then have to take 1809 special care to adjust ‘magit-branch-current’ accordingly. By default 1810 it looks mostly like ‘magit-branch-local’, but with a box (by default 1811 the former is the only face that uses a box, exactly so that it sticks 1812 out). If the former also uses a box, then you have to make sure that it 1813 differs in some other way from the latter. 1814 1815 The most difficult faces to theme are those related to diffs, 1816 headings, highlighting, and the region. There are faces that fall into 1817 all four groups - expect to spend some time getting this right. 1818 1819 The ‘region’ face in the default theme, in both the light and dark 1820 variants, as well as in many other themes, distributed with Emacs or by 1821 third-parties, is very ugly. It is common to use a background color 1822 that really sticks out, which is ugly but if that were the only problem 1823 then it would be acceptable. Unfortunately many themes also set the 1824 foreground color, which ensures that all text within the region is 1825 readable. Without doing that there might be cases where some foreground 1826 color is too close to the region background color to still be readable. 1827 But it also means that text within the region loses all syntax 1828 highlighting. 1829 1830 I consider the work that went into getting the ‘region’ face right to 1831 be a good indicator for the general quality of a theme. My 1832 recommendation for the ‘region’ face is this: use a background color 1833 slightly different from the background color of the ‘default’ face, and 1834 do not set the foreground color at all. So for a light theme you might 1835 use a light (possibly tinted) gray as the background color of ‘default’ 1836 and a somewhat darker gray for the background of ‘region’. That should 1837 usually be enough to not collide with the foreground color of any other 1838 face. But if some other faces also set a light gray as background 1839 color, then you should also make sure it doesn’t collide with those (in 1840 some cases it might be acceptable though). 1841 1842 Magit only uses the ‘region’ face when the region is "invalid" by its 1843 own definition. In a Magit buffer the region is used to either select 1844 multiple sibling sections, so that commands which support it act on all 1845 of these sections instead of just the current section, or to select 1846 lines within a single hunk section. In all other cases, the section is 1847 considered invalid and Magit won’t act on it. But such invalid sections 1848 happen, either because the user has not moved point enough yet to make 1849 it valid or because she wants to use a non-magit command to act on the 1850 region, e.g. ‘kill-region’. 1851 1852 So using the regular ‘region’ face for invalid sections is a feature. 1853 It tells the user that Magit won’t be able to act on it. It’s 1854 acceptable if that face looks a bit odd and even (but less so) if it 1855 collides with the background colors of section headings and other things 1856 that have a background color. 1857 1858 Magit highlights the current section. If a section has subsections, 1859 then all of them are highlighted. This is done using faces that have 1860 "highlight" in their names. For most sections, 1861 ‘magit-section-highlight’ is used for both the body and the heading. 1862 Like the ‘region’ face, it should only set the background color to 1863 something similar to that of ‘default’. The highlight background color 1864 must be different from both the ‘region’ background color and the 1865 ‘default’ background color. 1866 1867 For diff related sections Magit uses various faces to highlight 1868 different parts of the selected section(s). Note that hunk headings, 1869 unlike all other section headings, by default have a background color, 1870 because it is useful to have very visible separators between hunks. 1871 That face ‘magit-diff-hunk-heading’, should be different from both 1872 ‘magit-diff-hunk-heading-highlight’ and ‘magit-section-highlight’, as 1873 well as from ‘magit-diff-context’ and ‘magit-diff-context-highlight’. 1874 By default we do that by changing the foreground color. Changing the 1875 background color would lead to complications, and there are already 1876 enough we cannot get around. (Also note that it is generally a good 1877 idea for section headings to always be bold, but only for sections that 1878 have subsections). 1879 1880 When there is a valid region selecting diff-related sibling sections, 1881 i.e. multiple files or hunks, then the bodies of all these sections use 1882 the respective highlight faces, but additionally the headings instead 1883 use one of the faces ‘magit-diff-file-heading-selection’ or 1884 ‘magit-diff-hunk-heading-selection’. These faces have to be different 1885 from the regular highlight variants to provide explicit visual 1886 indication that the region is active. 1887 1888 When theming diff related faces, start by setting the option 1889 ‘magit-diff-refine-hunk’ to ‘all’. You might personally prefer to only 1890 refine the current hunk or not use hunk refinement at all, but some of 1891 the users of your theme want all hunks to be refined, so you have to 1892 cater to that. 1893 1894 (Also turn on ‘magit-diff-highlight-indentation’, 1895 ‘magit-diff-highlight-trailing’, and ‘magit-diff-paint-whitespace’; and 1896 insert some whitespace errors into the code you use for testing.) 1897 1898 For e.g. "added lines" you have to adjust three faces: 1899 ‘magit-diff-added’, ‘magit-diff-added-highlight’, and 1900 ‘smerge-refined-added’. Make sure that the latter works well with both 1901 of the former, as well as ‘smerge-other’ and ‘diff-added’. Then do the 1902 same for the removed lines, context lines, lines added by us, and lines 1903 added by them. Also make sure the respective added, removed, and 1904 context faces use approximately the same saturation for both the 1905 highlighted and unhighlighted variants. Also make sure the file and 1906 diff headings work nicely with context lines (e.g. make them look 1907 different). Line faces should set both the foreground and the 1908 background color. For example, for added lines use two different 1909 greens. 1910 1911 It’s best if the foreground color of both the highlighted and the 1912 unhighlighted variants are the same, so you will need to have to find a 1913 color that works well on the highlight and unhighlighted background, the 1914 refine background, and the highlight context background. When there is 1915 an hunk internal region, then the added- and removed-lines background 1916 color is used only within that region. Outside the region the 1917 highlighted context background color is used. This makes it easier to 1918 see what is being staged. With an hunk internal region the hunk heading 1919 is shown using ‘magit-diff-hunk-heading-selection’, and so are the thin 1920 lines that are added around the lines that fall within the region. The 1921 background color of that has to be distinct enough from the various 1922 other involved background colors. 1923 1924 Nobody said this would be easy. If your theme restricts itself to a 1925 certain set of colors, then you should make an exception here. 1926 Otherwise it would be impossible to make the diffs look good in each and 1927 every variation. Actually you might want to just stick to the default 1928 definitions for these faces. You have been warned. Also please note 1929 that if you do not get this right, this will in some cases look to users 1930 like bugs in Magit - so please do it right or not at all. 1931 1932 1933 File: magit.info, Node: FAQ, Next: Debugging Tools, Prev: Plumbing, Up: Top 1934 1935 Appendix A FAQ 1936 ************** 1937 1938 The next two nodes lists frequently asked questions. For a list of 1939 frequently *and recently* asked questions, i.e. questions that haven’t 1940 made it into the manual yet, see 1941 <https://github.com/magit/magit/wiki/FAQ>. 1942 1943 Please also use the *note Debugging Tools::. 1944 1945 * Menu: 1946 1947 * FAQ - How to ...?:: 1948 * FAQ - Issues and Errors:: 1949 1950 1951 File: magit.info, Node: FAQ - How to ...?, Next: FAQ - Issues and Errors, Up: FAQ 1952 1953 A.1 FAQ - How to ...? 1954 ===================== 1955 1956 * Menu: 1957 1958 * How to pronounce Magit?:: 1959 * How to show git's output?:: 1960 * How to install the gitman info manual?:: 1961 * How to show diffs for gpg-encrypted files?:: 1962 * How does branching and pushing work?:: 1963 * Can Magit be used as ediff-version-control-package?:: 1964 * Should I disable VC?:: 1965 1966 1967 File: magit.info, Node: How to pronounce Magit?, Next: How to show git's output?, Up: FAQ - How to ...? 1968 1969 A.1.1 How to pronounce Magit? 1970 ----------------------------- 1971 1972 Either ‘mu[m's] git’ or ‘magi{c => t}’ is fine. 1973 1974 The slogan is "It’s Magit! The magical Git client", so it makes 1975 sense to pronounce Magit like magic, while taking into account that C 1976 and T do not sound the same. 1977 1978 The German "Magie" is not pronounced the same as the English "magic", 1979 so if you speak German then you can use the above rational to justify 1980 using the former pronunciation; ‘Mag{ie => it}’. 1981 1982 You can also choose to use the former pronunciation just because you 1983 like it better. 1984 1985 Also see <https://magit.vc/assets/videos/magic.mp4>. Also see 1986 <https://emacs.stackexchange.com/questions/13696>. 1987 1988 1989 File: magit.info, Node: How to show git's output?, Next: How to install the gitman info manual?, Prev: How to pronounce Magit?, Up: FAQ - How to ...? 1990 1991 A.1.2 How to show git’s output? 1992 ------------------------------- 1993 1994 To show the output of recently run git commands, press ‘$’ (or, if that 1995 isn’t available, ‘M-x magit-process-buffer’). This will show a buffer 1996 containing a section per git invocation; as always press ‘TAB’ to expand 1997 or collapse them. 1998 1999 By default, git’s output is only inserted into the process buffer if 2000 it is run for side-effects. When the output is consumed in some way, 2001 also inserting it into the process buffer would be too expensive. For 2002 debugging purposes, it’s possible to do so anyway by setting 2003 ‘magit-git-debug’ to ‘t’. 2004 2005 2006 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 ...? 2007 2008 A.1.3 How to install the gitman info manual? 2009 -------------------------------------------- 2010 2011 Git’s manpages can be exported as an info manual called ‘gitman’. 2012 Magit’s own info manual links to nodes in that manual instead of the 2013 actual manpages because Info doesn’t support linking to manpages. 2014 2015 Unfortunately some distributions do not install the ‘gitman’ manual 2016 by default and you will have to install a separate documentation package 2017 to get it. 2018 2019 Magit patches Info adding the ability to visit links to the ‘gitman’ 2020 Info manual by instead viewing the respective manpage. If you prefer 2021 that approach, then set the value of ‘magit-view-git-manual-method’ to 2022 one of the supported packages ‘man’ or ‘woman’, e.g.: 2023 2024 (setq magit-view-git-manual-method 'man) 2025 2026 2027 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 ...? 2028 2029 A.1.4 How to show diffs for gpg-encrypted files? 2030 ------------------------------------------------ 2031 2032 Git supports showing diffs for encrypted files, but has to be told to do 2033 so. Since Magit just uses Git to get the diffs, configuring Git also 2034 affects the diffs displayed inside Magit. 2035 2036 git config --global diff.gpg.textconv "gpg --no-tty --decrypt" 2037 echo "*.gpg filter=gpg diff=gpg" > .gitattributes 2038 2039 2040 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 ...? 2041 2042 A.1.5 How does branching and pushing work? 2043 ------------------------------------------ 2044 2045 Please see *note Branching:: and 2046 <http://emacsair.me/2016/01/18/magit-2.4> 2047 2048 2049 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 ...? 2050 2051 A.1.6 Can Magit be used as ‘ediff-version-control-package’? 2052 ----------------------------------------------------------- 2053 2054 No, it cannot. For that to work the functions ‘ediff-magit-internal’ 2055 and ‘ediff-magit-merge-internal’ would have to be implemented, and they 2056 are not. These two functions are only used by the three commands 2057 ‘ediff-revision’, ‘ediff-merge-revisions-with-ancestor’, and 2058 ‘ediff-merge-revisions’. 2059 2060 These commands only delegate the task of populating buffers with 2061 certain revisions to the "internal" functions. The equally important 2062 task of determining which revisions are to be compared/merged is not 2063 delegated. Instead this is done without any support whatsoever from the 2064 version control package/system - meaning that the user has to enter the 2065 revisions explicitly. Instead of implementing ‘ediff-magit-internal’ we 2066 provide ‘magit-ediff-compare’, which handles both tasks like it is 2005. 2067 2068 The other commands ‘ediff-merge-revisions’ and 2069 ‘ediff-merge-revisions-with-ancestor’ are normally not what you want 2070 when using a modern version control system like Git. Instead of letting 2071 the user resolve only those conflicts which Git could not resolve on its 2072 own, they throw away all work done by Git and then expect the user to 2073 manually merge all conflicts, including those that had already been 2074 resolved. That made sense back in the days when version control systems 2075 couldn’t merge (or so I have been told), but not anymore. Once in a 2076 blue moon you might actually want to see all conflicts, in which case 2077 you *can* use these commands, which then use ‘ediff-vc-merge-internal’. 2078 So we don’t actually have to implement ‘ediff-magit-merge-internal’. 2079 Instead we provide the more useful command ‘magit-ediff-resolve’ which 2080 only shows yet-to-be resolved conflicts. 2081 2082 2083 File: magit.info, Node: Should I disable VC?, Prev: Can Magit be used as ediff-version-control-package?, Up: FAQ - How to ...? 2084 2085 A.1.7 Should I disable VC? 2086 -------------------------- 2087 2088 If you don’t use VC (the built-in version control interface) then you 2089 might be tempted to disable it, not least because we used to recommend 2090 that you do that. 2091 2092 We no longer recommend that you disable VC. Doing so would break 2093 useful third-party packages (such as ‘diff-hl’), which depend on VC 2094 being enabled. 2095 2096 If you choose to disable VC anyway, then you can do so by changing 2097 the value of ‘vc-handled-backends’. 2098 2099 2100 File: magit.info, Node: FAQ - Issues and Errors, Prev: FAQ - How to ...?, Up: FAQ 2101 2102 A.2 FAQ - Issues and Errors 2103 =========================== 2104 2105 * Menu: 2106 2107 * Magit is slow:: 2108 * I changed several thousand files at once and now Magit is unusable:: 2109 * I am having problems committing:: 2110 * I am using MS Windows and cannot push with Magit:: 2111 * 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. 2112 * Expanding a file to show the diff causes it to disappear:: 2113 * Point is wrong in the COMMIT_EDITMSG buffer:: 2114 * The mode-line information isn't always up-to-date:: 2115 * A branch and tag sharing the same name breaks SOMETHING:: 2116 * My Git hooks work on the command-line but not inside Magit:: 2117 * git-commit-mode isn't used when committing from the command-line:: 2118 * Point ends up inside invisible text when jumping to a file-visiting buffer:: 2119 * I am unable to stage when using Tramp from MS Windows:: 2120 * I am no longer able to save popup defaults:: 2121 2122 2123 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 2124 2125 A.2.1 Magit is slow 2126 ------------------- 2127 2128 See *note Performance::. 2129 2130 2131 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 2132 2133 A.2.2 I changed several thousand files at once and now Magit is unusable 2134 ------------------------------------------------------------------------ 2135 2136 Magit is *currently* not expected to work under such conditions. It 2137 sure would be nice if it did, and v2.5 will hopefully be a big step into 2138 that direction. But it might take until v3.1 to accomplish fully 2139 satisfactory performance, because that requires some heavy refactoring. 2140 2141 But for now we recommend you use the command line to complete this 2142 one commit. Also see *note Performance::. 2143 2144 2145 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 2146 2147 A.2.3 I am having problems committing 2148 ------------------------------------- 2149 2150 That likely means that Magit is having problems finding an appropriate 2151 emacsclient executable. See *note (with-editor)Configuring 2152 With-Editor:: and *note (with-editor)Debugging::. 2153 2154 2155 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 2156 2157 A.2.4 I am using MS Windows and cannot push with Magit 2158 ------------------------------------------------------ 2159 2160 It’s almost certain that Magit is only incidental to this issue. It is 2161 much more likely that this is a configuration issue, even if you can 2162 push on the command line. 2163 2164 Detailed setup instructions can be found at 2165 <https://github.com/magit/magit/wiki/Pushing-with-Magit-from-Windows>. 2166 2167 2168 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 2169 2170 A.2.5 I am using OS X and SOMETHING works in shell, but not in Magit 2171 -------------------------------------------------------------------- 2172 2173 This usually occurs because Emacs doesn’t have the same environment 2174 variables as your shell. Try installing and configuring 2175 <https://github.com/purcell/exec-path-from-shell>. By default it 2176 synchronizes ‘$PATH’, which helps Magit find the same ‘git’ as the one 2177 you are using on the shell. 2178 2179 If SOMETHING is "passphrase caching with gpg-agent for commit and/or 2180 tag signing", then you’ll also need to synchronize ‘$GPG_AGENT_INFO’. 2181 2182 2183 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 2184 2185 A.2.6 Expanding a file to show the diff causes it to disappear 2186 -------------------------------------------------------------- 2187 2188 This is probably caused by a change of a ‘diff.*’ Git variable. You 2189 probably set that variable for a reason, and should therefore only undo 2190 that setting in Magit by customizing ‘magit-git-global-arguments’. 2191 2192 2193 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 2194 2195 A.2.7 Point is wrong in the ‘COMMIT_EDITMSG’ buffer 2196 --------------------------------------------------- 2197 2198 Neither Magit nor ‘git-commit‘ fiddle with point in the buffer used to 2199 write commit messages, so something else must be doing it. 2200 2201 You have probably globally enabled a mode which does restore point in 2202 file-visiting buffers. It might be a bit surprising, but when you write 2203 a commit message, then you are actually editing a file. 2204 2205 So you have to figure out which package is doing. ‘saveplace’, 2206 ‘pointback’, and ‘session’ are likely candidates. These snippets might 2207 help: 2208 2209 (setq session-name-disable-regexp "\\(?:\\`'\\.git/[A-Z_]+\\'\\)") 2210 2211 (with-eval-after-load 'pointback 2212 (lambda () 2213 (when (or git-commit-mode git-rebase-mode) 2214 (pointback-mode -1)))) 2215 2216 2217 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 2218 2219 A.2.8 The mode-line information isn’t always up-to-date 2220 ------------------------------------------------------- 2221 2222 Magit is not responsible for the version control information that is 2223 being displayed in the mode-line and looks something like ‘Git-master’. 2224 The built-in "Version Control" package, also known as "VC", updates that 2225 information, and can be told to do so more often: 2226 2227 (setq auto-revert-check-vc-info t) 2228 2229 But doing so isn’t good for performance. For more (overly 2230 optimistic) information see *note (emacs)VC Mode Line::. 2231 2232 If you don’t really care about seeing this information in the 2233 mode-line, but just don’t want to see _incorrect_ information, then 2234 consider simply not displaying it in the mode-line: 2235 2236 (setq-default mode-line-format 2237 (delete '(vc-mode vc-mode) mode-line-format)) 2238 2239 2240 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 2241 2242 A.2.9 A branch and tag sharing the same name breaks SOMETHING 2243 ------------------------------------------------------------- 2244 2245 Or more generally, ambiguous refnames break SOMETHING. 2246 2247 Magit assumes that refs are named non-ambiguously across the 2248 "refs/heads/", "refs/tags/", and "refs/remotes/" namespaces (i.e., all 2249 the names remain unique when those prefixes are stripped). We consider 2250 ambiguous refnames unsupported and recommend that you use a 2251 non-ambiguous naming scheme. However, if you do work with a repository 2252 that has ambiguous refnames, please report any issues you encounter so 2253 that we can investigate whether there is a simple fix. 2254 2255 2256 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 2257 2258 A.2.10 My Git hooks work on the command-line but not inside Magit 2259 ----------------------------------------------------------------- 2260 2261 When Magit calls ‘git’ it adds a few global arguments including 2262 ‘--literal-pathspecs’ and the ‘git’ process started by Magit then passes 2263 that setting on to other ‘git’ process it starts itself. It does so by 2264 setting the environment variable ‘GIT_LITERAL_PATHSPECS’, not by calling 2265 subprocesses with the ‘--literal-pathspecs’ argument. You can therefore 2266 override this setting in hook scripts using ‘unset 2267 GIT_LITERAL_PATHSPECS’. 2268 2269 2270 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 2271 2272 A.2.11 ‘git-commit-mode’ isn’t used when committing from the command-line 2273 ------------------------------------------------------------------------- 2274 2275 The reason for this is that ‘git-commit.el’ has not been loaded yet 2276 and/or that the server has not been started yet. These things have 2277 always already been taken care of when you commit from Magit because in 2278 order to do so, Magit has to be loaded and doing that involves loading 2279 ‘git-commit’ and starting the server. 2280 2281 If you want to commit from the command-line, then you have to take 2282 care of these things yourself. Your ‘init.el’ file should contain: 2283 2284 (require 'git-commit) 2285 (server-mode) 2286 2287 Instead of ‘(require ’git-commit)‘ you may also use: 2288 2289 (load "/path/to/magit-autoloads.el") 2290 2291 You might want to do that because loading ‘git-commit’ causes large 2292 parts of Magit to be loaded. 2293 2294 There are also some variations of ‘(server-mode)’ that you might want 2295 to try. Personally I use: 2296 2297 (use-package server 2298 :config (or (server-running-p) (server-mode))) 2299 2300 Now you can use: 2301 2302 $ emacs& 2303 $ EDITOR=emacsclient git commit 2304 2305 However you cannot use: 2306 2307 $ killall emacs 2308 $ EDITOR="emacsclient --alternate-editor emacs" git commit 2309 2310 This will actually end up using ‘emacs’, not ‘emacsclient’. If you 2311 do this, then you can still edit the commit message but 2312 ‘git-commit-mode’ won’t be used and you have to exit ‘emacs’ to finish 2313 the process. 2314 2315 Tautology ahead. If you want to be able to use ‘emacsclient’ to 2316 connect to a running ‘emacs’ instance, even though no ‘emacs’ instance 2317 is running, then you cannot use ‘emacsclient’ directly. 2318 2319 Instead you have to create a script that does something like this: 2320 2321 Try to use ‘emacsclient’ (without using ‘--alternate-editor’). If 2322 that succeeds, do nothing else. Otherwise start ‘emacs &’ (and 2323 ‘init.el’ must call ‘server-start’) and try to use ‘emacsclient’ again. 2324 2325 2326 File: magit.info, Node: Point ends up inside invisible text when jumping to a file-visiting buffer, Next: I am unable to stage when using Tramp from MS Windows, Prev: git-commit-mode isn't used when committing from the command-line, Up: FAQ - Issues and Errors 2327 2328 A.2.12 Point ends up inside invisible text when jumping to a file-visiting buffer 2329 --------------------------------------------------------------------------------- 2330 2331 This can happen when you type ‘RET’ on a hunk to visit the respective 2332 file at the respective position. One solution to this problem is to use 2333 ‘global-reveal-mode’. It makes sure that text around point is always 2334 visible. If that is too drastic for your taste, then you may instead 2335 use ‘magit-diff-visit-file-hook’ to reveal the text, possibly using 2336 ‘reveal-post-command’ or for Org buffers ‘org-reveal’. 2337 2338 2339 File: magit.info, Node: I am unable to stage when using Tramp from MS Windows, Next: I am no longer able to save popup defaults, Prev: Point ends up inside invisible text when jumping to a file-visiting buffer, Up: FAQ - Issues and Errors 2340 2341 A.2.13 I am unable to stage when using Tramp from MS Windows 2342 ------------------------------------------------------------ 2343 2344 Magit may be unable to stage (or otherwise apply) individual hunks when 2345 you are connected to remote machine using Tramp and the local machine 2346 uses MS Windows. 2347 2348 There appears to be a problem with ‘process-send-eof’ in this 2349 scenario, as mentioned at the end of ‘tramp-tests.el’. I have contacted 2350 the Tramp maintainer about this. For now this unfortunately means that 2351 it just doesn’t work and we cannot do anything about it. If you have 2352 more information, then please comment on 2353 <https://github.com/magit/magit/issues/3624>. 2354 2355 2356 File: magit.info, Node: I am no longer able to save popup defaults, Prev: I am unable to stage when using Tramp from MS Windows, Up: FAQ - Issues and Errors 2357 2358 A.2.14 I am no longer able to save popup defaults 2359 ------------------------------------------------- 2360 2361 Magit used to use Magit-Popup to implement the transient popup menus. 2362 Now it used Transient instead, which is Magit-Popup’s successor. 2363 2364 In the older Magit-Popup menus, it was possible to save user settings 2365 (e.g. setting the gpg signing key for commits) by using ‘C-c C-c’ in 2366 the popup buffer. This would dismiss the popup, but save the settings 2367 as the defaults for future popups. 2368 2369 When switching to Transient menus, this functionality is now 2370 available via ‘C-x C-s’ instead; the ‘C-x’ prefix has other options as 2371 well when using Transient, which will be displayed when it is typed. 2372 See <https://magit.vc/manual/transient/Saving-Values.html#Saving-Values> 2373 for more details. 2374 2375 2376 File: magit.info, Node: Debugging Tools, Next: Keystroke Index, Prev: FAQ, Up: Top 2377 2378 B Debugging Tools 2379 ***************** 2380 2381 Magit and its dependencies provide a few debugging tools, and we 2382 appreciate it very much if you use those tools before reporting an 2383 issue. Please include all relevant output when reporting an issue. 2384 2385 ‘M-x magit-version’ (‘magit-version’) 2386 2387 This command shows the currently used versions of Magit, Git, and 2388 Emacs in the echo area. Non-interactively this just returns the 2389 Magit version. 2390 2391 ‘M-x magit-emacs-Q-command’ (‘magit-emacs-Q-command’) 2392 2393 This command shows a debugging shell command in the echo area and 2394 adds it to the kill ring. Paste that command into a shell and run 2395 it. 2396 2397 This shell command starts ‘emacs’ with only ‘magit’ and its 2398 dependencies loaded. Neither your configuration nor other 2399 installed packages are loaded. This makes it easier to determine 2400 whether some issue lays with Magit or something else. 2401 2402 If you run Magit from its Git repository, then you should be able 2403 to use ‘make emacs-Q’ instead of the output of this command. 2404 2405 ‘M-x magit-toggle-verbose-refresh’ (‘magit-toggle-verbose-refresh’) 2406 2407 This command toggles whether Magit refreshes buffers verbosely. 2408 Enabling this helps figuring out which sections are bottlenecks. 2409 The additional output can be found in the ‘*Messages*’ buffer. 2410 2411 ‘M-x magit-debug-git-executable’ (‘magit-debug-git-executable’) 2412 2413 This command displays a buffer containing information about the 2414 available and used ‘git’ executable(s), and can be useful when 2415 investigating ‘exec-path’ issues. 2416 2417 Also see *note Git Executable::. 2418 2419 ‘M-x with-editor-debug’ (‘with-editor-debug’) 2420 2421 This command displays a buffer containing information about the 2422 available and used ‘emacsclient’ executable(s), and can be useful 2423 when investigating why Magit (or rather ‘with-editor’) cannot find 2424 an appropriate ‘emacsclient’ executable. 2425 2426 Also see *note (with-editor)Debugging::. 2427 2428 Please also see the *note FAQ::. 2429 2430 2431 File: magit.info, Node: Keystroke Index, Next: Command Index, Prev: Debugging Tools, Up: Top 2432 2433 Appendix C Keystroke Index 2434 ************************** 2435 2436 2437 * Menu: 2438 2439 * !: Running Git Manually. 2440 (line 12) 2441 * ! !: Running Git Manually. 2442 (line 17) 2443 * ! a: Running Git Manually. 2444 (line 59) 2445 * ! b: Running Git Manually. 2446 (line 63) 2447 * ! g: Running Git Manually. 2448 (line 67) 2449 * ! k: Running Git Manually. 2450 (line 55) 2451 * ! p: Running Git Manually. 2452 (line 26) 2453 * ! s: Running Git Manually. 2454 (line 36) 2455 * ! S: Running Git Manually. 2456 (line 41) 2457 * $: Viewing Git Output. (line 16) 2458 * +: Log Buffer. (line 72) 2459 * + <1>: Refreshing Diffs. (line 69) 2460 * -: Log Buffer. (line 76) 2461 * - <1>: Refreshing Diffs. (line 65) 2462 * 0: Refreshing Diffs. (line 73) 2463 * 1: Section Visibility. (line 26) 2464 * 2: Section Visibility. (line 27) 2465 * 3: Section Visibility. (line 28) 2466 * 4: Section Visibility. (line 29) 2467 * :: Running Git Manually. 2468 (line 25) 2469 * =: Log Buffer. (line 66) 2470 * ^: Section Movement. (line 31) 2471 * a: Applying. (line 33) 2472 * A: Cherry Picking. (line 8) 2473 * A A: Cherry Picking. (line 17) 2474 * A a: Cherry Picking. (line 24) 2475 * A A <1>: Cherry Picking. (line 90) 2476 * A a <1>: Cherry Picking. (line 98) 2477 * A d: Cherry Picking. (line 54) 2478 * A h: Cherry Picking. (line 42) 2479 * A n: Cherry Picking. (line 65) 2480 * A s: Cherry Picking. (line 76) 2481 * A s <1>: Cherry Picking. (line 94) 2482 * B: Bisecting. (line 8) 2483 * b: Blaming. (line 102) 2484 * b <1>: Branch Commands. (line 12) 2485 * b <2>: Editing Rebase Sequences. 2486 (line 85) 2487 * B B: Bisecting. (line 16) 2488 * B b: Bisecting. (line 34) 2489 * b b: Branch Commands. (line 49) 2490 * b C: Branch Commands. (line 29) 2491 * b c: Branch Commands. (line 67) 2492 * B g: Bisecting. (line 39) 2493 * B k: Bisecting. (line 51) 2494 * b k: Branch Commands. (line 147) 2495 * b l: Branch Commands. (line 74) 2496 * B m: Bisecting. (line 44) 2497 * b n: Branch Commands. (line 57) 2498 * B r: Bisecting. (line 57) 2499 * b r: Branch Commands. (line 153) 2500 * B s: Bisecting. (line 27) 2501 * b s: Branch Commands. (line 97) 2502 * b S: Branch Commands. (line 125) 2503 * b x: Branch Commands. (line 131) 2504 * c: Blaming. (line 135) 2505 * C: Cloning Repository. (line 20) 2506 * c <1>: Initiating a Commit. (line 8) 2507 * c <2>: Editing Rebase Sequences. 2508 (line 72) 2509 * c a: Initiating a Commit. (line 19) 2510 * c A: Initiating a Commit. (line 67) 2511 * C b: Cloning Repository. (line 41) 2512 * C C: Cloning Repository. (line 29) 2513 * c c: Initiating a Commit. (line 14) 2514 * C d: Cloning Repository. (line 54) 2515 * C e: Cloning Repository. (line 61) 2516 * c e: Initiating a Commit. (line 23) 2517 * c f: Initiating a Commit. (line 43) 2518 * c F: Initiating a Commit. (line 51) 2519 * C m: Cloning Repository. (line 46) 2520 * C s: Cloning Repository. (line 34) 2521 * c s: Initiating a Commit. (line 55) 2522 * c S: Initiating a Commit. (line 63) 2523 * c w: Initiating a Commit. (line 33) 2524 * C-<return>: Visiting Files and Blobs from a Diff. 2525 (line 51) 2526 * C-<tab>: Section Visibility. (line 13) 2527 * C-c C-a: Commit Pseudo Headers. 2528 (line 17) 2529 * C-c C-b: Log Buffer. (line 21) 2530 * C-c C-b <1>: Refreshing Diffs. (line 91) 2531 * C-c C-c: Transient Commands. (line 18) 2532 * C-c C-c <1>: Select from Log. (line 20) 2533 * C-c C-c <2>: Editing Commit Messages. 2534 (line 17) 2535 * C-c C-c <3>: Editing Rebase Sequences. 2536 (line 6) 2537 * C-c C-d: Refreshing Diffs. (line 81) 2538 * C-c C-d <1>: Editing Commit Messages. 2539 (line 58) 2540 * C-c C-e: Commands Available in Diffs. 2541 (line 25) 2542 * C-c C-f: Log Buffer. (line 25) 2543 * C-c C-f <1>: Refreshing Diffs. (line 95) 2544 * C-c C-i: Commit Pseudo Headers. 2545 (line 13) 2546 * C-c C-k: Select from Log. (line 26) 2547 * C-c C-k <1>: Editing Commit Messages. 2548 (line 22) 2549 * C-c C-k <2>: Editing Rebase Sequences. 2550 (line 11) 2551 * C-c C-n: Log Buffer. (line 29) 2552 * C-c C-o: Commit Pseudo Headers. 2553 (line 33) 2554 * C-c C-p: Commit Pseudo Headers. 2555 (line 37) 2556 * C-c C-r: Commit Pseudo Headers. 2557 (line 21) 2558 * C-c C-s: Commit Pseudo Headers. 2559 (line 25) 2560 * C-c C-t: Commands Available in Diffs. 2561 (line 14) 2562 * C-c C-t <1>: Commit Pseudo Headers. 2563 (line 29) 2564 * C-c C-w: Using the Revision Stack. 2565 (line 6) 2566 * C-c M-g: Commands for Buffers Visiting Files. 2567 (line 21) 2568 * C-c M-g B: Blaming. (line 18) 2569 * C-c M-g b: Blaming. (line 29) 2570 * C-c M-g B <1>: Commands for Buffers Visiting Files. 2571 (line 93) 2572 * C-c M-g B b: Blaming. (line 30) 2573 * C-c M-g B e: Blaming. (line 64) 2574 * C-c M-g B f: Blaming. (line 55) 2575 * C-c M-g B r: Blaming. (line 46) 2576 * C-c M-g c: Commands for Buffers Visiting Files. 2577 (line 38) 2578 * C-c M-g D: Commands for Buffers Visiting Files. 2579 (line 45) 2580 * C-c M-g d: Commands for Buffers Visiting Files. 2581 (line 56) 2582 * C-c M-g e: Blaming. (line 63) 2583 * C-c M-g e <1>: Commands for Buffers Visiting Files. 2584 (line 106) 2585 * C-c M-g f: Blaming. (line 54) 2586 * C-c M-g L: Commands for Buffers Visiting Files. 2587 (line 66) 2588 * C-c M-g l: Commands for Buffers Visiting Files. 2589 (line 77) 2590 * C-c M-g p: Commands for Buffers Visiting Files. 2591 (line 116) 2592 * C-c M-g r: Blaming. (line 45) 2593 * C-c M-g s: Commands for Buffers Visiting Files. 2594 (line 29) 2595 * C-c M-g t: Commands for Buffers Visiting Files. 2596 (line 84) 2597 * C-c M-g u: Commands for Buffers Visiting Files. 2598 (line 33) 2599 * C-c M-i: Commit Pseudo Headers. 2600 (line 42) 2601 * C-c M-s: Editing Commit Messages. 2602 (line 34) 2603 * C-w: Common Commands. (line 22) 2604 * C-x g: Status Buffer. (line 22) 2605 * C-x u: Editing Rebase Sequences. 2606 (line 94) 2607 * d: Diffing. (line 21) 2608 * D: Refreshing Diffs. (line 11) 2609 * d c: Diffing. (line 69) 2610 * d d: Diffing. (line 27) 2611 * D f: Refreshing Diffs. (line 46) 2612 * D F: Refreshing Diffs. (line 51) 2613 * D g: Refreshing Diffs. (line 17) 2614 * d p: Diffing. (line 61) 2615 * d r: Diffing. (line 31) 2616 * D r: Refreshing Diffs. (line 41) 2617 * d s: Diffing. (line 51) 2618 * D s: Refreshing Diffs. (line 22) 2619 * d t: Diffing. (line 74) 2620 * D t: Refreshing Diffs. (line 37) 2621 * d u: Diffing. (line 57) 2622 * d w: Diffing. (line 45) 2623 * D w: Refreshing Diffs. (line 29) 2624 * DEL: Log Buffer. (line 56) 2625 * DEL <1>: Commands Available in Diffs. 2626 (line 60) 2627 * DEL <2>: Blaming. (line 89) 2628 * DEL <3>: Editing Rebase Sequences. 2629 (line 28) 2630 * e: Ediffing. (line 9) 2631 * E: Ediffing. (line 21) 2632 * e <1>: Editing Rebase Sequences. 2633 (line 55) 2634 * E c: Ediffing. (line 65) 2635 * E i: Ediffing. (line 57) 2636 * E m: Ediffing. (line 35) 2637 * E r: Ediffing. (line 26) 2638 * E s: Ediffing. (line 48) 2639 * E u: Ediffing. (line 53) 2640 * E w: Ediffing. (line 61) 2641 * E z: Ediffing. (line 69) 2642 * f: Editing Rebase Sequences. 2643 (line 63) 2644 * f <1>: Fetching. (line 9) 2645 * F: Pulling. (line 9) 2646 * f a: Fetching. (line 50) 2647 * f C: Branch Commands. (line 30) 2648 * F C: Branch Commands. (line 31) 2649 * f e: Fetching. (line 36) 2650 * F e: Pulling. (line 30) 2651 * f m: Fetching. (line 54) 2652 * f o: Fetching. (line 40) 2653 * f p: Fetching. (line 15) 2654 * F p: Pulling. (line 14) 2655 * f r: Fetching. (line 45) 2656 * f u: Fetching. (line 23) 2657 * F u: Pulling. (line 22) 2658 * g: Automatic Refreshing of Magit Buffers. 2659 (line 25) 2660 * G: Automatic Refreshing of Magit Buffers. 2661 (line 34) 2662 * H: Section Types and Values. 2663 (line 13) 2664 * I: Creating Repository. (line 6) 2665 * j: Log Buffer. (line 35) 2666 * j <1>: Commands Available in Diffs. 2667 (line 45) 2668 * k: Viewing Git Output. (line 24) 2669 * k <1>: Applying. (line 40) 2670 * k <2>: Editing Rebase Sequences. 2671 (line 68) 2672 * k <3>: Stashing. (line 96) 2673 * l: Logging. (line 29) 2674 * L: Refreshing Logs. (line 11) 2675 * L <1>: Log Buffer. (line 6) 2676 * L <2>: Log Margin. (line 57) 2677 * l <1>: Editing Rebase Sequences. 2678 (line 115) 2679 * l a: Logging. (line 60) 2680 * l b: Logging. (line 56) 2681 * L d: Log Margin. (line 74) 2682 * L g: Refreshing Logs. (line 17) 2683 * l h: Logging. (line 48) 2684 * l H: Reflog. (line 19) 2685 * l l: Logging. (line 35) 2686 * l L: Logging. (line 52) 2687 * L L: Log Margin. (line 66) 2688 * L l: Log Margin. (line 70) 2689 * l o: Logging. (line 41) 2690 * l O: Reflog. (line 15) 2691 * l r: Reflog. (line 11) 2692 * L s: Refreshing Logs. (line 22) 2693 * L t: Refreshing Logs. (line 37) 2694 * L w: Refreshing Logs. (line 29) 2695 * m: Merging. (line 9) 2696 * M: Remote Commands. (line 13) 2697 * m a: Merging. (line 45) 2698 * m a <1>: Merging. (line 95) 2699 * M a: Remote Commands. (line 50) 2700 * M C: Remote Commands. (line 33) 2701 * m e: Merging. (line 31) 2702 * m i: Merging. (line 58) 2703 * M k: Remote Commands. (line 65) 2704 * m m: Merging. (line 18) 2705 * m m <1>: Merging. (line 89) 2706 * m n: Merging. (line 38) 2707 * m p: Merging. (line 81) 2708 * M p: Remote Commands. (line 69) 2709 * M P: Remote Commands. (line 74) 2710 * M r: Remote Commands. (line 55) 2711 * m s: Merging. (line 72) 2712 * M u: Remote Commands. (line 60) 2713 * M-1: Section Visibility. (line 33) 2714 * M-2: Section Visibility. (line 34) 2715 * M-3: Section Visibility. (line 35) 2716 * M-4: Section Visibility. (line 36) 2717 * M-<tab>: Section Visibility. (line 17) 2718 * M-n: Section Movement. (line 26) 2719 * M-n <1>: Editing Commit Messages. 2720 (line 44) 2721 * M-n <2>: Editing Rebase Sequences. 2722 (line 47) 2723 * M-p: Section Movement. (line 20) 2724 * M-p <1>: Editing Commit Messages. 2725 (line 38) 2726 * M-p <2>: Editing Rebase Sequences. 2727 (line 43) 2728 * M-w: Blaming. (line 127) 2729 * M-w <1>: Common Commands. (line 40) 2730 * M-x magit-debug-git-executable: Git Executable. (line 56) 2731 * M-x magit-debug-git-executable <1>: Debugging Tools. (line 36) 2732 * M-x magit-describe-section-briefly: Matching Sections. (line 6) 2733 * M-x magit-emacs-Q-command: Debugging Tools. (line 16) 2734 * M-x magit-reset-index: Staging and Unstaging. 2735 (line 87) 2736 * M-x magit-reverse-in-index: Staging and Unstaging. 2737 (line 62) 2738 * M-x magit-stage-file: Staging from File-Visiting Buffers. 2739 (line 10) 2740 * M-x magit-toggle-buffer-lock: Modes and Buffers. (line 17) 2741 * M-x magit-toggle-verbose-refresh: Debugging Tools. (line 30) 2742 * M-x magit-unstage-file: Staging from File-Visiting Buffers. 2743 (line 18) 2744 * M-x magit-version: Git Executable. (line 61) 2745 * M-x magit-version <1>: Debugging Tools. (line 10) 2746 * M-x magit-wip-commit: Wip Modes. (line 88) 2747 * M-x with-editor-debug: Debugging Tools. (line 44) 2748 * MM: Editing Rebase Sequences. 2749 (line 125) 2750 * Mt: Editing Rebase Sequences. 2751 (line 132) 2752 * n: Section Movement. (line 16) 2753 * n <1>: Blaming. (line 106) 2754 * N: Blaming. (line 110) 2755 * n <2>: Editing Rebase Sequences. 2756 (line 39) 2757 * n <3>: Minor Mode for Buffers Visiting Blobs. 2758 (line 16) 2759 * o: Submodule Transient. (line 6) 2760 * O: Subtree. (line 8) 2761 * o a: Submodule Transient. (line 20) 2762 * o d: Submodule Transient. (line 50) 2763 * O e: Subtree. (line 42) 2764 * O e p: Subtree. (line 54) 2765 * O e s: Subtree. (line 59) 2766 * o f: Submodule Transient. (line 58) 2767 * O i: Subtree. (line 13) 2768 * O i a: Subtree. (line 25) 2769 * O i c: Subtree. (line 30) 2770 * O i f: Subtree. (line 38) 2771 * O i m: Subtree. (line 34) 2772 * o l: Submodule Transient. (line 54) 2773 * o p: Submodule Transient. (line 34) 2774 * o r: Submodule Transient. (line 27) 2775 * o s: Submodule Transient. (line 44) 2776 * o u: Submodule Transient. (line 39) 2777 * p: Section Movement. (line 10) 2778 * p <1>: Blaming. (line 114) 2779 * P: Blaming. (line 118) 2780 * p <2>: Editing Rebase Sequences. 2781 (line 35) 2782 * P <1>: Pushing. (line 9) 2783 * p <3>: Minor Mode for Buffers Visiting Blobs. 2784 (line 12) 2785 * P C: Branch Commands. (line 32) 2786 * P e: Pushing. (line 31) 2787 * P m: Pushing. (line 50) 2788 * P o: Pushing. (line 36) 2789 * P p: Pushing. (line 15) 2790 * P r: Pushing. (line 41) 2791 * P t: Pushing. (line 58) 2792 * P T: Pushing. (line 66) 2793 * P u: Pushing. (line 23) 2794 * q: Quitting Windows. (line 6) 2795 * q <1>: Log Buffer. (line 14) 2796 * q <2>: Blaming. (line 122) 2797 * q <3>: Minor Mode for Buffers Visiting Blobs. 2798 (line 20) 2799 * r: Rebasing. (line 9) 2800 * r <1>: Editing Rebase Sequences. 2801 (line 51) 2802 * r a: Rebasing. (line 123) 2803 * r e: Rebasing. (line 44) 2804 * r e <1>: Rebasing. (line 118) 2805 * r f: Rebasing. (line 84) 2806 * r i: Rebasing. (line 80) 2807 * r k: Rebasing. (line 99) 2808 * r m: Rebasing. (line 89) 2809 * r p: Rebasing. (line 28) 2810 * r r: Rebasing. (line 106) 2811 * r s: Rebasing. (line 50) 2812 * r s <1>: Rebasing. (line 113) 2813 * r u: Rebasing. (line 36) 2814 * r w: Rebasing. (line 94) 2815 * RET: References Buffer. (line 185) 2816 * RET <1>: Visiting Files and Blobs from a Diff. 2817 (line 8) 2818 * RET <2>: Blaming. (line 75) 2819 * RET <3>: Editing Rebase Sequences. 2820 (line 16) 2821 * s: Staging and Unstaging. 2822 (line 28) 2823 * S: Staging and Unstaging. 2824 (line 36) 2825 * s <1>: Editing Rebase Sequences. 2826 (line 59) 2827 * S-<tab>: Section Visibility. (line 22) 2828 * SPC: Log Buffer. (line 46) 2829 * SPC <1>: Commands Available in Diffs. 2830 (line 56) 2831 * SPC <2>: Blaming. (line 79) 2832 * SPC <3>: Editing Rebase Sequences. 2833 (line 21) 2834 * t: Editing Rebase Sequences. 2835 (line 119) 2836 * t <1>: Tagging. (line 8) 2837 * T: Notes. (line 8) 2838 * T a: Notes. (line 52) 2839 * T c: Notes. (line 47) 2840 * t k: Tagging. (line 39) 2841 * T m: Notes. (line 38) 2842 * t p: Tagging. (line 46) 2843 * T p: Notes. (line 30) 2844 * t r: Tagging. (line 19) 2845 * T r: Notes. (line 22) 2846 * t t: Tagging. (line 14) 2847 * T T: Notes. (line 14) 2848 * TAB: Section Visibility. (line 9) 2849 * u: Staging and Unstaging. 2850 (line 43) 2851 * U: Staging and Unstaging. 2852 (line 52) 2853 * v: Applying. (line 48) 2854 * V: Reverting. (line 6) 2855 * V A: Reverting. (line 31) 2856 * V a: Reverting. (line 39) 2857 * V s: Reverting. (line 35) 2858 * V V: Reverting. (line 15) 2859 * V v: Reverting. (line 21) 2860 * W: Plain Patches. (line 6) 2861 * w: Maildir Patches. (line 8) 2862 * w a: Plain Patches. (line 21) 2863 * w a <1>: Maildir Patches. (line 25) 2864 * w a <2>: Maildir Patches. (line 43) 2865 * W c: Plain Patches. (line 12) 2866 * w m: Maildir Patches. (line 21) 2867 * W s: Plain Patches. (line 28) 2868 * w s: Maildir Patches. (line 38) 2869 * w w: Maildir Patches. (line 14) 2870 * w w <1>: Maildir Patches. (line 34) 2871 * x: Editing Rebase Sequences. 2872 (line 76) 2873 * x <1>: Resetting. (line 8) 2874 * X f: Resetting. (line 50) 2875 * X h: Resetting. (line 26) 2876 * X i: Resetting. (line 37) 2877 * X k: Resetting. (line 31) 2878 * X m: Resetting. (line 15) 2879 * X s: Resetting. (line 20) 2880 * X w: Resetting. (line 44) 2881 * X w <1>: Wip Modes. (line 66) 2882 * Y: Cherries. (line 17) 2883 * y: References Buffer. (line 6) 2884 * y <1>: Editing Rebase Sequences. 2885 (line 90) 2886 * y c: References Buffer. (line 26) 2887 * y o: References Buffer. (line 32) 2888 * y r: References Buffer. (line 37) 2889 * y y: References Buffer. (line 21) 2890 * z: Stashing. (line 8) 2891 * Z: Worktree. (line 8) 2892 * z a: Stashing. (line 59) 2893 * z b: Stashing. (line 81) 2894 * z B: Stashing. (line 86) 2895 * Z b: Worktree. (line 13) 2896 * Z c: Worktree. (line 17) 2897 * z f: Stashing. (line 92) 2898 * Z g: Worktree. (line 30) 2899 * z i: Stashing. (line 21) 2900 * z I: Stashing. (line 47) 2901 * z k: Stashing. (line 72) 2902 * Z k: Worktree. (line 25) 2903 * z l: Stashing. (line 100) 2904 * Z m: Worktree. (line 21) 2905 * z p: Stashing. (line 65) 2906 * z v: Stashing. (line 77) 2907 * z w: Stashing. (line 26) 2908 * z W: Stashing. (line 52) 2909 * z x: Stashing. (line 33) 2910 * z z: Stashing. (line 14) 2911 * z Z: Stashing. (line 40) 2912 2913 2914 File: magit.info, Node: Command Index, Next: Function Index, Prev: Keystroke Index, Up: Top 2915 2916 Appendix D Command Index 2917 ************************ 2918 2919 2920 * Menu: 2921 2922 * forward-line: Editing Rebase Sequences. 2923 (line 39) 2924 * git-commit-ack: Commit Pseudo Headers. 2925 (line 17) 2926 * git-commit-cc: Commit Pseudo Headers. 2927 (line 33) 2928 * git-commit-insert-pseudo-header: Commit Pseudo Headers. 2929 (line 13) 2930 * git-commit-next-message: Editing Commit Messages. 2931 (line 44) 2932 * git-commit-prev-message: Editing Commit Messages. 2933 (line 38) 2934 * git-commit-reported: Commit Pseudo Headers. 2935 (line 37) 2936 * git-commit-review: Commit Pseudo Headers. 2937 (line 21) 2938 * git-commit-save-message: Editing Commit Messages. 2939 (line 34) 2940 * git-commit-signoff: Commit Pseudo Headers. 2941 (line 25) 2942 * git-commit-suggested: Commit Pseudo Headers. 2943 (line 42) 2944 * git-commit-test: Commit Pseudo Headers. 2945 (line 29) 2946 * git-rebase-backward-line: Editing Rebase Sequences. 2947 (line 35) 2948 * git-rebase-break: Editing Rebase Sequences. 2949 (line 85) 2950 * git-rebase-edit: Editing Rebase Sequences. 2951 (line 55) 2952 * git-rebase-exec: Editing Rebase Sequences. 2953 (line 76) 2954 * git-rebase-fixup: Editing Rebase Sequences. 2955 (line 63) 2956 * git-rebase-insert: Editing Rebase Sequences. 2957 (line 90) 2958 * git-rebase-kill-line: Editing Rebase Sequences. 2959 (line 68) 2960 * git-rebase-label: Editing Rebase Sequences. 2961 (line 115) 2962 * git-rebase-merge: Editing Rebase Sequences. 2963 (line 125) 2964 * git-rebase-merge-toggle-editmsg: Editing Rebase Sequences. 2965 (line 132) 2966 * git-rebase-move-line-down: Editing Rebase Sequences. 2967 (line 47) 2968 * git-rebase-move-line-up: Editing Rebase Sequences. 2969 (line 43) 2970 * git-rebase-pick: Editing Rebase Sequences. 2971 (line 72) 2972 * git-rebase-reset: Editing Rebase Sequences. 2973 (line 119) 2974 * git-rebase-reword: Editing Rebase Sequences. 2975 (line 51) 2976 * git-rebase-show-commit: Editing Rebase Sequences. 2977 (line 16) 2978 * git-rebase-show-or-scroll-down: Editing Rebase Sequences. 2979 (line 28) 2980 * git-rebase-show-or-scroll-up: Editing Rebase Sequences. 2981 (line 21) 2982 * git-rebase-squash: Editing Rebase Sequences. 2983 (line 59) 2984 * git-rebase-undo: Editing Rebase Sequences. 2985 (line 94) 2986 * ido-enter-magit-status: Status Buffer. (line 99) 2987 * magit-am: Maildir Patches. (line 8) 2988 * magit-am-abort: Maildir Patches. (line 43) 2989 * magit-am-apply-maildir: Maildir Patches. (line 21) 2990 * magit-am-apply-patches: Maildir Patches. (line 14) 2991 * magit-am-continue: Maildir Patches. (line 34) 2992 * magit-am-skip: Maildir Patches. (line 38) 2993 * magit-apply: Applying. (line 33) 2994 * magit-bisect: Bisecting. (line 8) 2995 * magit-bisect-bad: Bisecting. (line 34) 2996 * magit-bisect-good: Bisecting. (line 39) 2997 * magit-bisect-mark: Bisecting. (line 44) 2998 * magit-bisect-reset: Bisecting. (line 57) 2999 * magit-bisect-run: Bisecting. (line 27) 3000 * magit-bisect-skip: Bisecting. (line 51) 3001 * magit-bisect-start: Bisecting. (line 16) 3002 * magit-blame: Blaming. (line 18) 3003 * magit-blame <1>: Blaming. (line 102) 3004 * magit-blame <2>: Commands for Buffers Visiting Files. 3005 (line 93) 3006 * magit-blame-addition: Blaming. (line 29) 3007 * magit-blame-addition <1>: Blaming. (line 30) 3008 * magit-blame-copy-hash: Blaming. (line 127) 3009 * magit-blame-cycle-style: Blaming. (line 135) 3010 * magit-blame-echo: Blaming. (line 63) 3011 * magit-blame-echo <1>: Blaming. (line 64) 3012 * magit-blame-next-chunk: Blaming. (line 106) 3013 * magit-blame-next-chunk-same-commit: Blaming. (line 110) 3014 * magit-blame-previous-chunk: Blaming. (line 114) 3015 * magit-blame-previous-chunk-same-commit: Blaming. (line 118) 3016 * magit-blame-quit: Blaming. (line 122) 3017 * magit-blame-removal: Blaming. (line 45) 3018 * magit-blame-removal <1>: Blaming. (line 46) 3019 * magit-blame-reverse: Blaming. (line 54) 3020 * magit-blame-reverse <1>: Blaming. (line 55) 3021 * magit-blob-next: Minor Mode for Buffers Visiting Blobs. 3022 (line 16) 3023 * magit-blob-previous: Commands for Buffers Visiting Files. 3024 (line 116) 3025 * magit-blob-previous <1>: Minor Mode for Buffers Visiting Blobs. 3026 (line 12) 3027 * magit-branch: Branch Commands. (line 12) 3028 * magit-branch-and-checkout: Branch Commands. (line 67) 3029 * magit-branch-checkout: Branch Commands. (line 74) 3030 * magit-branch-configure: Branch Commands. (line 29) 3031 * magit-branch-configure <1>: Branch Commands. (line 30) 3032 * magit-branch-configure <2>: Branch Commands. (line 31) 3033 * magit-branch-configure <3>: Branch Commands. (line 32) 3034 * magit-branch-create: Branch Commands. (line 57) 3035 * magit-branch-delete: Branch Commands. (line 147) 3036 * magit-branch-or-checkout: Branch Commands. (line 267) 3037 * magit-branch-orphan: Branch Commands. (line 262) 3038 * magit-branch-rename: Branch Commands. (line 153) 3039 * magit-branch-reset: Branch Commands. (line 131) 3040 * magit-branch-shelve: Auxiliary Branch Commands. 3041 (line 9) 3042 * magit-branch-spinoff: Branch Commands. (line 97) 3043 * magit-branch-spinout: Branch Commands. (line 125) 3044 * magit-branch-unshelve: Auxiliary Branch Commands. 3045 (line 20) 3046 * magit-bundle: Bundle. (line 8) 3047 * magit-checkout: Branch Commands. (line 49) 3048 * magit-cherry: Cherries. (line 17) 3049 * magit-cherry-apply: Cherry Picking. (line 24) 3050 * magit-cherry-copy: Cherry Picking. (line 17) 3051 * magit-cherry-donate: Cherry Picking. (line 54) 3052 * magit-cherry-harvest: Cherry Picking. (line 42) 3053 * magit-cherry-pick: Cherry Picking. (line 8) 3054 * magit-cherry-spinoff: Cherry Picking. (line 76) 3055 * magit-cherry-spinout: Cherry Picking. (line 65) 3056 * magit-clone: Cloning Repository. (line 20) 3057 * magit-clone-bare: Cloning Repository. (line 41) 3058 * magit-clone-mirror: Cloning Repository. (line 46) 3059 * magit-clone-regular: Cloning Repository. (line 29) 3060 * magit-clone-shallow: Cloning Repository. (line 34) 3061 * magit-clone-shallow-exclude: Cloning Repository. (line 61) 3062 * magit-clone-shallow-since: Cloning Repository. (line 54) 3063 * magit-commit: Initiating a Commit. (line 8) 3064 * magit-commit <1>: Commands for Buffers Visiting Files. 3065 (line 38) 3066 * magit-commit-amend: Initiating a Commit. (line 19) 3067 * magit-commit-augment: Initiating a Commit. (line 67) 3068 * magit-commit-create: Initiating a Commit. (line 14) 3069 * magit-commit-extend: Initiating a Commit. (line 23) 3070 * magit-commit-fixup: Initiating a Commit. (line 43) 3071 * magit-commit-instant-fixup: Initiating a Commit. (line 51) 3072 * magit-commit-instant-squash: Initiating a Commit. (line 63) 3073 * magit-commit-reword: Initiating a Commit. (line 33) 3074 * magit-commit-squash: Initiating a Commit. (line 55) 3075 * magit-copy-buffer-revision: Common Commands. (line 40) 3076 * magit-copy-section-value: Common Commands. (line 22) 3077 * magit-cycle-margin-style: Log Margin. (line 70) 3078 * magit-debug-git-executable: Git Executable. (line 56) 3079 * magit-debug-git-executable <1>: Debugging Tools. (line 36) 3080 * magit-describe-section: Section Types and Values. 3081 (line 13) 3082 * magit-describe-section-briefly: Section Types and Values. 3083 (line 18) 3084 * magit-describe-section-briefly <1>: Matching Sections. (line 6) 3085 * magit-diff: Diffing. (line 21) 3086 * magit-diff <1>: Commands for Buffers Visiting Files. 3087 (line 45) 3088 * magit-diff-buffer-file: Commands for Buffers Visiting Files. 3089 (line 56) 3090 * magit-diff-default-context: Refreshing Diffs. (line 73) 3091 * magit-diff-dwim: Diffing. (line 27) 3092 * magit-diff-edit-hunk-commit: Commands Available in Diffs. 3093 (line 25) 3094 * magit-diff-flip-revs: Refreshing Diffs. (line 46) 3095 * magit-diff-less-context: Refreshing Diffs. (line 65) 3096 * magit-diff-more-context: Refreshing Diffs. (line 69) 3097 * magit-diff-paths: Diffing. (line 61) 3098 * magit-diff-range: Diffing. (line 31) 3099 * magit-diff-refresh: Refreshing Diffs. (line 11) 3100 * magit-diff-refresh <1>: Refreshing Diffs. (line 17) 3101 * magit-diff-save-default-arguments: Refreshing Diffs. (line 29) 3102 * magit-diff-set-default-arguments: Refreshing Diffs. (line 22) 3103 * magit-diff-show-or-scroll-down: Log Buffer. (line 56) 3104 * magit-diff-show-or-scroll-down <1>: Blaming. (line 89) 3105 * magit-diff-show-or-scroll-up: Log Buffer. (line 46) 3106 * magit-diff-show-or-scroll-up <1>: Blaming. (line 79) 3107 * magit-diff-staged: Diffing. (line 51) 3108 * magit-diff-switch-range-type: Refreshing Diffs. (line 41) 3109 * magit-diff-toggle-file-filter: Refreshing Diffs. (line 51) 3110 * magit-diff-toggle-refine-hunk: Refreshing Diffs. (line 37) 3111 * magit-diff-trace-definition: Commands Available in Diffs. 3112 (line 14) 3113 * magit-diff-unstaged: Diffing. (line 57) 3114 * magit-diff-visit-file: Visiting Files and Blobs from a Diff. 3115 (line 8) 3116 * magit-diff-visit-file-other-frame: Visiting Files and Blobs from a Diff. 3117 (line 74) 3118 * magit-diff-visit-file-other-window: Visiting Files and Blobs from a Diff. 3119 (line 73) 3120 * magit-diff-visit-file-worktree: Visiting Files and Blobs from a Diff. 3121 (line 51) 3122 * magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs from a Diff. 3123 (line 76) 3124 * magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs from a Diff. 3125 (line 75) 3126 * magit-diff-while-committing: Refreshing Diffs. (line 81) 3127 * magit-diff-while-committing <1>: Editing Commit Messages. 3128 (line 58) 3129 * magit-diff-working-tree: Diffing. (line 45) 3130 * magit-discard: Applying. (line 40) 3131 * magit-dispatch: Transient Commands. (line 18) 3132 * magit-display-repository-buffer: Common Commands. (line 9) 3133 * magit-ediff: Ediffing. (line 21) 3134 * magit-ediff-compare: Ediffing. (line 26) 3135 * magit-ediff-dwim: Ediffing. (line 9) 3136 * magit-ediff-resolve: Ediffing. (line 35) 3137 * magit-ediff-show-commit: Ediffing. (line 65) 3138 * magit-ediff-show-staged: Ediffing. (line 57) 3139 * magit-ediff-show-stash: Ediffing. (line 69) 3140 * magit-ediff-show-unstaged: Ediffing. (line 53) 3141 * magit-ediff-show-working-tree: Ediffing. (line 61) 3142 * magit-ediff-stage: Ediffing. (line 48) 3143 * magit-edit-line-commit: Commands for Buffers Visiting Files. 3144 (line 106) 3145 * magit-emacs-Q-command: Debugging Tools. (line 16) 3146 * magit-fetch: Fetching. (line 9) 3147 * magit-fetch-all: Fetching. (line 50) 3148 * magit-fetch-branch: Fetching. (line 40) 3149 * magit-fetch-from-pushremote: Fetching. (line 15) 3150 * magit-fetch-from-upstream: Fetching. (line 23) 3151 * magit-fetch-modules: Submodule Transient. (line 58) 3152 * magit-fetch-other: Fetching. (line 36) 3153 * magit-fetch-refspec: Fetching. (line 45) 3154 * magit-file-checkout: Resetting. (line 50) 3155 * magit-file-checkout <1>: Commands for Buffers Visiting Files. 3156 (line 135) 3157 * magit-file-delete: Commands for Buffers Visiting Files. 3158 (line 127) 3159 * magit-file-dispatch: Commands for Buffers Visiting Files. 3160 (line 21) 3161 * magit-file-rename: Commands for Buffers Visiting Files. 3162 (line 123) 3163 * magit-file-untrack: Commands for Buffers Visiting Files. 3164 (line 131) 3165 * magit-find-file: General-Purpose Visit Commands. 3166 (line 9) 3167 * magit-find-file-other-frame: General-Purpose Visit Commands. 3168 (line 21) 3169 * magit-find-file-other-window: General-Purpose Visit Commands. 3170 (line 15) 3171 * magit-git-command: Running Git Manually. 3172 (line 25) 3173 * magit-git-command <1>: Running Git Manually. 3174 (line 26) 3175 * magit-git-command-topdir: Running Git Manually. 3176 (line 17) 3177 * magit-go-backward: Log Buffer. (line 21) 3178 * magit-go-backward <1>: Refreshing Diffs. (line 91) 3179 * magit-go-forward: Log Buffer. (line 25) 3180 * magit-go-forward <1>: Refreshing Diffs. (line 95) 3181 * magit-init: Creating Repository. (line 6) 3182 * magit-jump-to-diffstat-or-diff: Commands Available in Diffs. 3183 (line 45) 3184 * magit-kill-this-buffer: Minor Mode for Buffers Visiting Blobs. 3185 (line 20) 3186 * magit-list-repositories: Repository List. (line 6) 3187 * magit-list-submodules: Listing Submodules. (line 13) 3188 * magit-list-submodules <1>: Submodule Transient. (line 54) 3189 * magit-log: Logging. (line 29) 3190 * magit-log <1>: Commands for Buffers Visiting Files. 3191 (line 66) 3192 * magit-log-all: Logging. (line 60) 3193 * magit-log-all-branches: Logging. (line 56) 3194 * magit-log-branches: Logging. (line 52) 3195 * magit-log-buffer-file: Commands for Buffers Visiting Files. 3196 (line 77) 3197 * magit-log-bury-buffer: Log Buffer. (line 14) 3198 * magit-log-current: Logging. (line 35) 3199 * magit-log-double-commit-limit: Log Buffer. (line 72) 3200 * magit-log-half-commit-limit: Log Buffer. (line 76) 3201 * magit-log-head: Logging. (line 48) 3202 * magit-log-move-to-parent: Log Buffer. (line 29) 3203 * magit-log-move-to-revision: Log Buffer. (line 35) 3204 * magit-log-other: Logging. (line 41) 3205 * magit-log-refresh: Refreshing Logs. (line 11) 3206 * magit-log-refresh <1>: Refreshing Logs. (line 17) 3207 * magit-log-refresh <2>: Log Buffer. (line 6) 3208 * magit-log-save-default-arguments: Refreshing Logs. (line 29) 3209 * magit-log-select-pick: Select from Log. (line 20) 3210 * magit-log-select-quit: Select from Log. (line 26) 3211 * magit-log-set-default-arguments: Refreshing Logs. (line 22) 3212 * magit-log-toggle-commit-limit: Log Buffer. (line 66) 3213 * magit-log-trace-definition: Commands for Buffers Visiting Files. 3214 (line 84) 3215 * magit-margin-settings: Log Margin. (line 57) 3216 * magit-merge: Merging. (line 9) 3217 * magit-merge <1>: Merging. (line 89) 3218 * magit-merge-abort: Merging. (line 95) 3219 * magit-merge-absorb: Merging. (line 45) 3220 * magit-merge-editmsg: Merging. (line 31) 3221 * magit-merge-into: Merging. (line 58) 3222 * magit-merge-nocommit: Merging. (line 38) 3223 * magit-merge-plain: Merging. (line 18) 3224 * magit-merge-preview: Merging. (line 81) 3225 * magit-merge-squash: Merging. (line 72) 3226 * magit-mode-bury-buffer: Quitting Windows. (line 6) 3227 * magit-notes: Notes. (line 8) 3228 * magit-notes-edit: Notes. (line 14) 3229 * magit-notes-merge: Notes. (line 38) 3230 * magit-notes-merge-abort: Notes. (line 52) 3231 * magit-notes-merge-commit: Notes. (line 47) 3232 * magit-notes-prune: Notes. (line 30) 3233 * magit-notes-remove: Notes. (line 22) 3234 * magit-patch: Plain Patches. (line 6) 3235 * magit-patch-apply: Plain Patches. (line 21) 3236 * magit-patch-apply <1>: Maildir Patches. (line 25) 3237 * magit-patch-create: Plain Patches. (line 12) 3238 * magit-patch-save: Plain Patches. (line 28) 3239 * magit-pop-revision-stack: Using the Revision Stack. 3240 (line 6) 3241 * magit-process: Viewing Git Output. (line 16) 3242 * magit-process-kill: Viewing Git Output. (line 24) 3243 * magit-pull: Pulling. (line 9) 3244 * magit-pull-branch: Pulling. (line 30) 3245 * magit-pull-from-pushremote: Pulling. (line 14) 3246 * magit-pull-from-upstream: Pulling. (line 22) 3247 * magit-push: Pushing. (line 9) 3248 * magit-push-current: Pushing. (line 31) 3249 * magit-push-current-to-pushremote: Pushing. (line 15) 3250 * magit-push-current-to-upstream: Pushing. (line 23) 3251 * magit-push-implicitly args: Pushing. (line 83) 3252 * magit-push-matching: Pushing. (line 50) 3253 * magit-push-other: Pushing. (line 36) 3254 * magit-push-refspecs: Pushing. (line 41) 3255 * magit-push-tag: Pushing. (line 66) 3256 * magit-push-tags: Pushing. (line 58) 3257 * magit-push-to-remote remote args: Pushing. (line 101) 3258 * magit-rebase: Rebasing. (line 9) 3259 * magit-rebase-abort: Rebasing. (line 123) 3260 * magit-rebase-autosquash: Rebasing. (line 84) 3261 * magit-rebase-branch: Rebasing. (line 44) 3262 * magit-rebase-continue: Rebasing. (line 106) 3263 * magit-rebase-edit: Rebasing. (line 118) 3264 * magit-rebase-edit-commit: Rebasing. (line 89) 3265 * magit-rebase-interactive: Rebasing. (line 80) 3266 * magit-rebase-onto-pushremote: Rebasing. (line 28) 3267 * magit-rebase-onto-upstream: Rebasing. (line 36) 3268 * magit-rebase-remove-commit: Rebasing. (line 99) 3269 * magit-rebase-reword-commit: Rebasing. (line 94) 3270 * magit-rebase-skip: Rebasing. (line 113) 3271 * magit-rebase-subset: Rebasing. (line 50) 3272 * magit-reflog-current: Reflog. (line 11) 3273 * magit-reflog-head: Reflog. (line 19) 3274 * magit-reflog-other: Reflog. (line 15) 3275 * magit-refresh: Automatic Refreshing of Magit Buffers. 3276 (line 25) 3277 * magit-refresh-all: Automatic Refreshing of Magit Buffers. 3278 (line 34) 3279 * magit-refs-set-show-commit-count: References Buffer. (line 37) 3280 * magit-remote: Remote Commands. (line 13) 3281 * magit-remote-add: Remote Commands. (line 50) 3282 * magit-remote-configure: Remote Commands. (line 33) 3283 * magit-remote-prune: Remote Commands. (line 69) 3284 * magit-remote-prune-refspecs: Remote Commands. (line 74) 3285 * magit-remote-remove: Remote Commands. (line 65) 3286 * magit-remote-rename: Remote Commands. (line 55) 3287 * magit-remote-set-url: Remote Commands. (line 60) 3288 * magit-reset-hard: Resetting. (line 26) 3289 * magit-reset-index: Staging and Unstaging. 3290 (line 87) 3291 * magit-reset-index <1>: Resetting. (line 37) 3292 * magit-reset-keep: Resetting. (line 31) 3293 * magit-reset-mixed: Resetting. (line 15) 3294 * magit-reset-quickly: Resetting. (line 8) 3295 * magit-reset-soft: Resetting. (line 20) 3296 * magit-reset-worktree: Resetting. (line 44) 3297 * magit-reset-worktree <1>: Wip Modes. (line 66) 3298 * magit-reverse: Applying. (line 48) 3299 * magit-reverse-in-index: Staging and Unstaging. 3300 (line 62) 3301 * magit-revert: Reverting. (line 6) 3302 * magit-revert-and-commit: Reverting. (line 15) 3303 * magit-revert-no-commit: Reverting. (line 21) 3304 * magit-run: Running Git Manually. 3305 (line 12) 3306 * magit-run-git-gui: Running Git Manually. 3307 (line 67) 3308 * magit-run-gitk: Running Git Manually. 3309 (line 55) 3310 * magit-run-gitk-all: Running Git Manually. 3311 (line 59) 3312 * magit-run-gitk-branches: Running Git Manually. 3313 (line 63) 3314 * magit-section-backward: Section Movement. (line 10) 3315 * magit-section-backward-siblings: Section Movement. (line 20) 3316 * magit-section-cycle: Section Visibility. (line 13) 3317 * magit-section-cycle-diffs: Section Visibility. (line 17) 3318 * magit-section-cycle-global: Section Visibility. (line 22) 3319 * magit-section-forward: Section Movement. (line 16) 3320 * magit-section-forward-siblings: Section Movement. (line 26) 3321 * magit-section-hide: Section Visibility. (line 49) 3322 * magit-section-hide-children: Section Visibility. (line 64) 3323 * magit-section-show: Section Visibility. (line 45) 3324 * magit-section-show-children: Section Visibility. (line 58) 3325 * magit-section-show-headings: Section Visibility. (line 53) 3326 * magit-section-show-level-1: Section Visibility. (line 26) 3327 * magit-section-show-level-1-all: Section Visibility. (line 33) 3328 * magit-section-show-level-2: Section Visibility. (line 27) 3329 * magit-section-show-level-2-all: Section Visibility. (line 34) 3330 * magit-section-show-level-3: Section Visibility. (line 28) 3331 * magit-section-show-level-3-all: Section Visibility. (line 35) 3332 * magit-section-show-level-4: Section Visibility. (line 29) 3333 * magit-section-show-level-4-all: Section Visibility. (line 36) 3334 * magit-section-toggle: Section Visibility. (line 9) 3335 * magit-section-toggle-children: Section Visibility. (line 68) 3336 * magit-section-up: Section Movement. (line 31) 3337 * magit-sequence-abort: Cherry Picking. (line 98) 3338 * magit-sequence-abort <1>: Reverting. (line 39) 3339 * magit-sequence-continue: Cherry Picking. (line 90) 3340 * magit-sequence-continue <1>: Reverting. (line 31) 3341 * magit-sequence-skip: Cherry Picking. (line 94) 3342 * magit-sequence-skip <1>: Reverting. (line 35) 3343 * magit-shell-command: Running Git Manually. 3344 (line 41) 3345 * magit-shell-command-topdir: Running Git Manually. 3346 (line 36) 3347 * magit-show-commit: Diffing. (line 69) 3348 * magit-show-commit <1>: Blaming. (line 75) 3349 * magit-show-refs: References Buffer. (line 6) 3350 * magit-show-refs-current: References Buffer. (line 26) 3351 * magit-show-refs-head: References Buffer. (line 21) 3352 * magit-show-refs-other: References Buffer. (line 32) 3353 * magit-snapshot-both: Stashing. (line 40) 3354 * magit-snapshot-index: Stashing. (line 47) 3355 * magit-snapshot-worktree: Stashing. (line 52) 3356 * magit-stage: Staging and Unstaging. 3357 (line 28) 3358 * magit-stage-file: Staging from File-Visiting Buffers. 3359 (line 10) 3360 * magit-stage-file <1>: Commands for Buffers Visiting Files. 3361 (line 29) 3362 * magit-stage-modified: Staging and Unstaging. 3363 (line 36) 3364 * magit-stash: Stashing. (line 8) 3365 * magit-stash-apply: Stashing. (line 59) 3366 * magit-stash-both: Stashing. (line 14) 3367 * magit-stash-branch: Stashing. (line 81) 3368 * magit-stash-branch-here: Stashing. (line 86) 3369 * magit-stash-clear: Stashing. (line 96) 3370 * magit-stash-drop: Stashing. (line 72) 3371 * magit-stash-format-patch: Stashing. (line 92) 3372 * magit-stash-index: Stashing. (line 21) 3373 * magit-stash-keep-index: Stashing. (line 33) 3374 * magit-stash-list: Stashing. (line 100) 3375 * magit-stash-pop: Stashing. (line 65) 3376 * magit-stash-show: Diffing. (line 74) 3377 * magit-stash-show <1>: Stashing. (line 77) 3378 * magit-stash-worktree: Stashing. (line 26) 3379 * magit-status: Status Buffer. (line 22) 3380 * magit-status-quick: Status Buffer. (line 72) 3381 * magit-submodule: Submodule Transient. (line 6) 3382 * magit-submodule-add: Submodule Transient. (line 20) 3383 * magit-submodule-fetch: Fetching. (line 54) 3384 * magit-submodule-populate: Submodule Transient. (line 34) 3385 * magit-submodule-register: Submodule Transient. (line 27) 3386 * magit-submodule-synchronize: Submodule Transient. (line 44) 3387 * magit-submodule-unpopulate: Submodule Transient. (line 50) 3388 * magit-submodule-update: Submodule Transient. (line 39) 3389 * magit-subtree: Subtree. (line 8) 3390 * magit-subtree-add: Subtree. (line 25) 3391 * magit-subtree-add-commit: Subtree. (line 30) 3392 * magit-subtree-export: Subtree. (line 42) 3393 * magit-subtree-import: Subtree. (line 13) 3394 * magit-subtree-merge: Subtree. (line 34) 3395 * magit-subtree-pull: Subtree. (line 38) 3396 * magit-subtree-push: Subtree. (line 54) 3397 * magit-subtree-split: Subtree. (line 59) 3398 * magit-switch-to-repository-buffer: Common Commands. (line 6) 3399 * magit-switch-to-repository-buffer-other-frame: Common Commands. 3400 (line 8) 3401 * magit-switch-to-repository-buffer-other-window: Common Commands. 3402 (line 7) 3403 * magit-tag: Tagging. (line 8) 3404 * magit-tag-create: Tagging. (line 14) 3405 * magit-tag-delete: Tagging. (line 39) 3406 * magit-tag-prune: Tagging. (line 46) 3407 * magit-tag-release: Tagging. (line 19) 3408 * magit-toggle-buffer-lock: Modes and Buffers. (line 17) 3409 * magit-toggle-margin: Refreshing Logs. (line 37) 3410 * magit-toggle-margin <1>: Log Margin. (line 66) 3411 * magit-toggle-margin-details: Log Margin. (line 74) 3412 * magit-toggle-verbose-refresh: Debugging Tools. (line 30) 3413 * magit-unstage: Staging and Unstaging. 3414 (line 43) 3415 * magit-unstage-all: Staging and Unstaging. 3416 (line 52) 3417 * magit-unstage-file: Staging from File-Visiting Buffers. 3418 (line 18) 3419 * magit-unstage-file <1>: Commands for Buffers Visiting Files. 3420 (line 33) 3421 * magit-version: Git Executable. (line 61) 3422 * magit-version <1>: Debugging Tools. (line 10) 3423 * magit-visit-ref: References Buffer. (line 185) 3424 * magit-wip-commit: Wip Modes. (line 88) 3425 * magit-wip-log: Wip Modes. (line 48) 3426 * magit-wip-log-current: Wip Modes. (line 57) 3427 * magit-worktree: Worktree. (line 8) 3428 * magit-worktree-branch: Worktree. (line 17) 3429 * magit-worktree-checkout: Worktree. (line 13) 3430 * magit-worktree-delete: Worktree. (line 25) 3431 * magit-worktree-move: Worktree. (line 21) 3432 * magit-worktree-status: Worktree. (line 30) 3433 * scroll-down: Commands Available in Diffs. 3434 (line 60) 3435 * scroll-up: Commands Available in Diffs. 3436 (line 56) 3437 * with-editor-cancel: Editing Commit Messages. 3438 (line 22) 3439 * with-editor-cancel <1>: Editing Rebase Sequences. 3440 (line 11) 3441 * with-editor-debug: Debugging Tools. (line 44) 3442 * with-editor-finish: Editing Commit Messages. 3443 (line 17) 3444 * with-editor-finish <1>: Editing Rebase Sequences. 3445 (line 6) 3446 3447 3448 File: magit.info, Node: Function Index, Next: Variable Index, Prev: Command Index, Up: Top 3449 3450 Appendix E Function Index 3451 ************************* 3452 3453 3454 * Menu: 3455 3456 * bug-reference-mode: Commit Mode and Hooks. 3457 (line 56) 3458 * git-commit-check-style-conventions: Commit Message Conventions. 3459 (line 40) 3460 * git-commit-propertize-diff: Commit Mode and Hooks. 3461 (line 47) 3462 * git-commit-save-message: Commit Mode and Hooks. 3463 (line 28) 3464 * git-commit-setup-changelog-support: Commit Mode and Hooks. 3465 (line 32) 3466 * git-commit-turn-on-auto-fill: Commit Mode and Hooks. 3467 (line 37) 3468 * git-commit-turn-on-flyspell: Commit Mode and Hooks. 3469 (line 42) 3470 * ido-enter-magit-status: Status Buffer. (line 99) 3471 * magit-add-section-hook: Section Hooks. (line 20) 3472 * magit-after-save-refresh-status: Automatic Refreshing of Magit Buffers. 3473 (line 59) 3474 * magit-branch-or-checkout: Branch Commands. (line 267) 3475 * magit-branch-orphan: Branch Commands. (line 262) 3476 * magit-branch-shelve: Auxiliary Branch Commands. 3477 (line 9) 3478 * magit-branch-unshelve: Auxiliary Branch Commands. 3479 (line 20) 3480 * magit-builtin-completing-read: Support for Completion Frameworks. 3481 (line 42) 3482 * magit-bundle: Bundle. (line 8) 3483 * magit-call-git: Calling Git for Effect. 3484 (line 28) 3485 * magit-call-process: Calling Git for Effect. 3486 (line 32) 3487 * magit-cancel-section: Creating Sections. (line 71) 3488 * magit-completing-read: Support for Completion Frameworks. 3489 (line 60) 3490 * magit-current-section: Section Selection. (line 6) 3491 * magit-define-section-jumper: Creating Sections. (line 77) 3492 * magit-describe-section-briefly: Section Types and Values. 3493 (line 18) 3494 * magit-diff-scope: Matching Sections. (line 118) 3495 * magit-diff-type: Matching Sections. (line 95) 3496 * magit-diff-visit-file-other-frame: Visiting Files and Blobs from a Diff. 3497 (line 74) 3498 * magit-diff-visit-file-other-window: Visiting Files and Blobs from a Diff. 3499 (line 73) 3500 * magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs from a Diff. 3501 (line 76) 3502 * magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs from a Diff. 3503 (line 75) 3504 * magit-disable-section-inserter: Per-Repository Configuration. 3505 (line 31) 3506 * magit-display-buffer: Switching Buffers. (line 6) 3507 * magit-display-buffer-fullcolumn-most-v1: Switching Buffers. (line 75) 3508 * magit-display-buffer-fullframe-status-topleft-v1: Switching Buffers. 3509 (line 65) 3510 * magit-display-buffer-fullframe-status-v1: Switching Buffers. 3511 (line 59) 3512 * magit-display-buffer-same-window-except-diff-v1: Switching Buffers. 3513 (line 53) 3514 * magit-display-buffer-traditional: Switching Buffers. (line 45) 3515 * magit-display-repository-buffer: Common Commands. (line 9) 3516 * magit-file-checkout: Commands for Buffers Visiting Files. 3517 (line 135) 3518 * magit-file-delete: Commands for Buffers Visiting Files. 3519 (line 127) 3520 * magit-file-rename: Commands for Buffers Visiting Files. 3521 (line 123) 3522 * magit-file-untrack: Commands for Buffers Visiting Files. 3523 (line 131) 3524 * magit-find-file: General-Purpose Visit Commands. 3525 (line 9) 3526 * magit-find-file-other-frame: General-Purpose Visit Commands. 3527 (line 21) 3528 * magit-find-file-other-window: General-Purpose Visit Commands. 3529 (line 15) 3530 * magit-generate-buffer-name-default-function: Naming Buffers. 3531 (line 17) 3532 * magit-get-section: Matching Sections. (line 16) 3533 * magit-git: Calling Git for Effect. 3534 (line 50) 3535 * magit-git-exit-code: Getting a Value from Git. 3536 (line 10) 3537 * magit-git-failure: Getting a Value from Git. 3538 (line 19) 3539 * magit-git-false: Getting a Value from Git. 3540 (line 29) 3541 * magit-git-insert: Getting a Value from Git. 3542 (line 34) 3543 * magit-git-items: Getting a Value from Git. 3544 (line 49) 3545 * magit-git-lines: Getting a Value from Git. 3546 (line 44) 3547 * magit-git-str: Getting a Value from Git. 3548 (line 87) 3549 * magit-git-string: Getting a Value from Git. 3550 (line 38) 3551 * magit-git-success: Getting a Value from Git. 3552 (line 14) 3553 * magit-git-true: Getting a Value from Git. 3554 (line 24) 3555 * magit-git-wash: Calling Git for Effect. 3556 (line 55) 3557 * magit-hunk-set-window-start: Section Movement. (line 51) 3558 * magit-ido-completing-read: Support for Completion Frameworks. 3559 (line 48) 3560 * magit-insert-am-sequence: Status Sections. (line 28) 3561 * magit-insert-assumed-unchanged-files: Status Sections. (line 117) 3562 * magit-insert-bisect-log: Status Sections. (line 46) 3563 * magit-insert-bisect-output: Status Sections. (line 38) 3564 * magit-insert-bisect-rest: Status Sections. (line 42) 3565 * magit-insert-diff-filter-header: Status Header Sections. 3566 (line 38) 3567 * magit-insert-error-header: Status Header Sections. 3568 (line 28) 3569 * magit-insert-head-branch-header: Status Header Sections. 3570 (line 42) 3571 * magit-insert-heading: Creating Sections. (line 42) 3572 * magit-insert-ignored-files: Status Sections. (line 100) 3573 * magit-insert-local-branches: References Sections. (line 17) 3574 * magit-insert-merge-log: Status Sections. (line 18) 3575 * magit-insert-modules: Status Module Sections. 3576 (line 12) 3577 * magit-insert-modules-overview: Status Module Sections. 3578 (line 33) 3579 * magit-insert-modules-unpulled-from-pushremote: Status Module Sections. 3580 (line 50) 3581 * magit-insert-modules-unpulled-from-upstream: Status Module Sections. 3582 (line 44) 3583 * magit-insert-modules-unpushed-to-pushremote: Status Module Sections. 3584 (line 62) 3585 * magit-insert-modules-unpushed-to-upstream: Status Module Sections. 3586 (line 56) 3587 * magit-insert-push-branch-header: Status Header Sections. 3588 (line 51) 3589 * magit-insert-rebase-sequence: Status Sections. (line 23) 3590 * magit-insert-recent-commits: Status Sections. (line 131) 3591 * magit-insert-remote-branches: References Sections. (line 21) 3592 * magit-insert-remote-header: Status Header Sections. 3593 (line 67) 3594 * magit-insert-repo-header: Status Header Sections. 3595 (line 63) 3596 * magit-insert-section: Creating Sections. (line 6) 3597 * magit-insert-sequencer-sequence: Status Sections. (line 33) 3598 * magit-insert-skip-worktree-files: Status Sections. (line 110) 3599 * magit-insert-staged-changes: Status Sections. (line 63) 3600 * magit-insert-stashes: Status Sections. (line 67) 3601 * magit-insert-status-headers: Status Header Sections. 3602 (line 12) 3603 * magit-insert-tags: References Sections. (line 25) 3604 * magit-insert-tags-header: Status Header Sections. 3605 (line 56) 3606 * magit-insert-tracked-files: Status Sections. (line 96) 3607 * magit-insert-unpulled-cherries: Status Sections. (line 142) 3608 * magit-insert-unpulled-from-pushremote: Status Sections. (line 79) 3609 * magit-insert-unpulled-from-upstream: Status Sections. (line 74) 3610 * magit-insert-unpulled-or-recent-commits: Status Sections. (line 124) 3611 * magit-insert-unpushed-cherries: Status Sections. (line 149) 3612 * magit-insert-unpushed-to-pushremote: Status Sections. (line 89) 3613 * magit-insert-unpushed-to-upstream: Status Sections. (line 84) 3614 * magit-insert-unstaged-changes: Status Sections. (line 59) 3615 * magit-insert-untracked-files: Status Sections. (line 50) 3616 * magit-insert-upstream-branch-header: Status Header Sections. 3617 (line 46) 3618 * magit-insert-user-header: Status Header Sections. 3619 (line 75) 3620 * magit-list-repositories: Repository List. (line 6) 3621 * magit-list-submodules: Listing Submodules. (line 13) 3622 * magit-log-maybe-show-more-commits: Section Movement. (line 66) 3623 * magit-log-maybe-update-blob-buffer: Section Movement. (line 82) 3624 * magit-log-maybe-update-revision-buffer: Section Movement. (line 74) 3625 * magit-maybe-set-dedicated: Switching Buffers. (line 100) 3626 * magit-mode-display-buffer: Refreshing Buffers. (line 33) 3627 * magit-mode-quit-window: Quitting Windows. (line 34) 3628 * magit-mode-setup: Refreshing Buffers. (line 17) 3629 * magit-process-file: Getting a Value from Git. 3630 (line 67) 3631 * magit-process-git: Getting a Value from Git. 3632 (line 59) 3633 * magit-push-implicitly: Pushing. (line 83) 3634 * magit-push-to-remote: Pushing. (line 101) 3635 * magit-region-sections: Section Selection. (line 10) 3636 * magit-region-values: Section Selection. (line 37) 3637 * magit-repolist-column-branch: Repository List. (line 50) 3638 * magit-repolist-column-branches: Repository List. (line 59) 3639 * magit-repolist-column-flag: Repository List. (line 67) 3640 * magit-repolist-column-ident: Repository List. (line 36) 3641 * magit-repolist-column-path: Repository List. (line 41) 3642 * magit-repolist-column-stashes: Repository List. (line 63) 3643 * magit-repolist-column-unpulled-from-pushremote: Repository List. 3644 (line 87) 3645 * magit-repolist-column-unpulled-from-upstream: Repository List. 3646 (line 82) 3647 * magit-repolist-column-unpushed-to-pushremote: Repository List. 3648 (line 97) 3649 * magit-repolist-column-unpushed-to-upstream: Repository List. 3650 (line 92) 3651 * magit-repolist-column-upstream: Repository List. (line 54) 3652 * magit-repolist-column-version: Repository List. (line 45) 3653 * magit-restore-window-configuration: Quitting Windows. (line 23) 3654 * magit-run-git: Calling Git for Effect. 3655 (line 36) 3656 * magit-run-git-async: Calling Git for Effect. 3657 (line 65) 3658 * magit-run-git-with-editor: Calling Git for Effect. 3659 (line 78) 3660 * magit-run-git-with-input: Calling Git for Effect. 3661 (line 40) 3662 * magit-save-window-configuration: Switching Buffers. (line 89) 3663 * magit-section-case: Matching Sections. (line 71) 3664 * magit-section-hide: Section Visibility. (line 49) 3665 * magit-section-hide-children: Section Visibility. (line 64) 3666 * magit-section-ident: Matching Sections. (line 11) 3667 * magit-section-match: Matching Sections. (line 21) 3668 * magit-section-set-window-start: Section Movement. (line 59) 3669 * magit-section-show: Section Visibility. (line 45) 3670 * magit-section-show-children: Section Visibility. (line 58) 3671 * magit-section-show-headings: Section Visibility. (line 53) 3672 * magit-section-toggle-children: Section Visibility. (line 68) 3673 * magit-section-value-if: Matching Sections. (line 61) 3674 * magit-start-git: Calling Git for Effect. 3675 (line 90) 3676 * magit-start-process: Calling Git for Effect. 3677 (line 109) 3678 * magit-stashes-maybe-update-stash-buffer: Section Movement. (line 106) 3679 * magit-status-maybe-update-blob-buffer: Section Movement. (line 100) 3680 * magit-status-maybe-update-revision-buffer: Section Movement. 3681 (line 88) 3682 * magit-status-maybe-update-stash-buffer: Section Movement. (line 94) 3683 * magit-status-quick: Status Buffer. (line 72) 3684 * magit-switch-to-repository-buffer: Common Commands. (line 6) 3685 * magit-switch-to-repository-buffer-other-frame: Common Commands. 3686 (line 8) 3687 * magit-switch-to-repository-buffer-other-window: Common Commands. 3688 (line 7) 3689 * magit-wip-log: Wip Modes. (line 48) 3690 * magit-wip-log-current: Wip Modes. (line 57) 3691 * with-editor-usage-message: Commit Mode and Hooks. 3692 (line 60) 3693 3694 3695 File: magit.info, Node: Variable Index, Prev: Function Index, Up: Top 3696 3697 Appendix F Variable Index 3698 ************************* 3699 3700 3701 * Menu: 3702 3703 * auto-revert-buffer-list-filter: Automatic Reverting of File-Visiting Buffers. 3704 (line 81) 3705 * auto-revert-interval: Automatic Reverting of File-Visiting Buffers. 3706 (line 76) 3707 * auto-revert-mode: Automatic Reverting of File-Visiting Buffers. 3708 (line 62) 3709 * auto-revert-stop-on-user-input: Automatic Reverting of File-Visiting Buffers. 3710 (line 71) 3711 * auto-revert-use-notify: Automatic Reverting of File-Visiting Buffers. 3712 (line 49) 3713 * auto-revert-verbose: Automatic Reverting of File-Visiting Buffers. 3714 (line 103) 3715 * branch.autoSetupMerge: Branch Git Variables. 3716 (line 81) 3717 * branch.autoSetupRebase: Branch Git Variables. 3718 (line 98) 3719 * branch.NAME.description: Branch Git Variables. 3720 (line 48) 3721 * branch.NAME.merge: Branch Git Variables. 3722 (line 10) 3723 * branch.NAME.pushRemote: Branch Git Variables. 3724 (line 34) 3725 * branch.NAME.rebase: Branch Git Variables. 3726 (line 22) 3727 * branch.NAME.remote: Branch Git Variables. 3728 (line 16) 3729 * core.notesRef: Notes. (line 60) 3730 * git-commit-fill-column: Commit Message Conventions. 3731 (line 19) 3732 * git-commit-finish-query-functions: Commit Message Conventions. 3733 (line 24) 3734 * git-commit-known-pseudo-headers: Commit Pseudo Headers. 3735 (line 9) 3736 * git-commit-major-mode: Commit Mode and Hooks. 3737 (line 12) 3738 * git-commit-setup-hook: Commit Mode and Hooks. 3739 (line 22) 3740 * git-commit-setup-hook <1>: Commit Mode and Hooks. 3741 (line 64) 3742 * git-commit-style-convention-checks: Commit Message Conventions. 3743 (line 46) 3744 * git-commit-summary-max-length: Commit Message Conventions. 3745 (line 13) 3746 * git-rebase-auto-advance: Editing Rebase Sequences. 3747 (line 99) 3748 * git-rebase-confirm-cancel: Editing Rebase Sequences. 3749 (line 107) 3750 * git-rebase-show-instructions: Editing Rebase Sequences. 3751 (line 103) 3752 * global-auto-revert-mode: Automatic Reverting of File-Visiting Buffers. 3753 (line 22) 3754 * magit-auto-revert-immediately: Automatic Reverting of File-Visiting Buffers. 3755 (line 32) 3756 * magit-auto-revert-mode: Automatic Reverting of File-Visiting Buffers. 3757 (line 17) 3758 * magit-auto-revert-tracked-only: Automatic Reverting of File-Visiting Buffers. 3759 (line 55) 3760 * magit-bisect-show-graph: Bisecting. (line 65) 3761 * magit-blame-disable-modes: Blaming. (line 165) 3762 * magit-blame-echo-style: Blaming. (line 148) 3763 * magit-blame-goto-chunk-hook: Blaming. (line 171) 3764 * magit-blame-read-only: Blaming. (line 160) 3765 * magit-blame-styles: Blaming. (line 143) 3766 * magit-blame-time-format: Blaming. (line 155) 3767 * magit-branch-adjust-remote-upstream-alist: Branch Commands. (line 210) 3768 * magit-branch-direct-configure: Branch Commands. (line 20) 3769 * magit-branch-prefer-remote-upstream: Branch Commands. (line 165) 3770 * magit-branch-read-upstream-first: Branch Commands. (line 159) 3771 * magit-buffer-name-format: Naming Buffers. (line 27) 3772 * magit-bury-buffer-function: Quitting Windows. (line 14) 3773 * magit-cherry-margin: Cherries. (line 22) 3774 * magit-clone-always-transient: Cloning Repository. (line 12) 3775 * magit-clone-default-directory: Cloning Repository. (line 90) 3776 * magit-clone-name-alist: Cloning Repository. (line 103) 3777 * magit-clone-set-remote-head: Cloning Repository. (line 68) 3778 * magit-clone-set-remote.pushDefault: Cloning Repository. (line 78) 3779 * magit-clone-url-format: Cloning Repository. (line 124) 3780 * magit-commit-ask-to-stage: Initiating a Commit. (line 75) 3781 * magit-commit-diff-inhibit-same-window: Initiating a Commit. (line 113) 3782 * magit-commit-extend-override-date: Initiating a Commit. (line 84) 3783 * magit-commit-reword-override-date: Initiating a Commit. (line 88) 3784 * magit-commit-show-diff: Initiating a Commit. (line 80) 3785 * magit-commit-squash-confirm: Initiating a Commit. (line 92) 3786 * magit-completing-read-function: Support for Completion Frameworks. 3787 (line 27) 3788 * magit-define-global-key-bindings: Default Bindings. (line 6) 3789 * magit-diff-adjust-tab-width: Diff Options. (line 21) 3790 * magit-diff-buffer-file-locked: Commands for Buffers Visiting Files. 3791 (line 61) 3792 * magit-diff-extra-stat-arguments: Diff Options. (line 128) 3793 * magit-diff-hide-trailing-cr-characters: Diff Options. (line 90) 3794 * magit-diff-highlight-hunk-region-functions: Diff Options. (line 94) 3795 * magit-diff-highlight-indentation: Diff Options. (line 75) 3796 * magit-diff-highlight-trailing: Diff Options. (line 70) 3797 * magit-diff-paint-whitespace: Diff Options. (line 43) 3798 * magit-diff-paint-whitespace-lines: Diff Options. (line 60) 3799 * magit-diff-refine-hunk: Diff Options. (line 6) 3800 * magit-diff-refine-ignore-whitespace: Diff Options. (line 16) 3801 * magit-diff-unmarked-lines-keep-foreground: Diff Options. (line 120) 3802 * magit-diff-visit-previous-blob: Visiting Files and Blobs from a Diff. 3803 (line 39) 3804 * magit-direct-use-buffer-arguments: Transient Arguments and Buffer Variables. 3805 (line 73) 3806 * magit-display-buffer-function: Switching Buffers. (line 27) 3807 * magit-display-buffer-noselect: Switching Buffers. (line 18) 3808 * magit-dwim-selection: Completion and Confirmation. 3809 (line 42) 3810 * magit-ediff-dwim-show-on-hunks: Ediffing. (line 73) 3811 * magit-ediff-quit-hook: Ediffing. (line 88) 3812 * magit-ediff-show-stash-with-index: Ediffing. (line 81) 3813 * magit-generate-buffer-name-function: Naming Buffers. (line 6) 3814 * magit-git-debug: Viewing Git Output. (line 28) 3815 * magit-git-debug <1>: Getting a Value from Git. 3816 (line 79) 3817 * magit-git-executable: Git Executable. (line 26) 3818 * magit-git-global-arguments: Global Git Arguments. 3819 (line 6) 3820 * magit-keep-region-overlay: The Selection. (line 52) 3821 * magit-list-refs-sortby: Additional Completion Options. 3822 (line 6) 3823 * magit-log-auto-more: Log Buffer. (line 80) 3824 * magit-log-buffer-file-locked: Commands for Buffers Visiting Files. 3825 (line 88) 3826 * magit-log-margin: Log Margin. (line 12) 3827 * magit-log-margin-show-committer-date: Log Margin. (line 49) 3828 * magit-log-section-commit-count: Status Sections. (line 136) 3829 * magit-log-select-margin: Select from Log. (line 30) 3830 * magit-log-show-refname-after-summary: Log Buffer. (line 86) 3831 * magit-log-trace-definition-function: Commands Available in Diffs. 3832 (line 18) 3833 * magit-module-sections-hook: Status Module Sections. 3834 (line 20) 3835 * magit-module-sections-nested: Status Module Sections. 3836 (line 24) 3837 * magit-no-confirm: Action Confirmation. (line 18) 3838 * magit-pop-revision-stack-format: Using the Revision Stack. 3839 (line 35) 3840 * magit-post-commit-hook: Initiating a Commit. (line 101) 3841 * magit-post-display-buffer-hook: Switching Buffers. (line 95) 3842 * magit-pre-display-buffer-hook: Switching Buffers. (line 84) 3843 * magit-prefer-remote-upstream: Branch Git Variables. 3844 (line 126) 3845 * magit-prefix-use-buffer-arguments: Transient Arguments and Buffer Variables. 3846 (line 64) 3847 * magit-process-extreme-logging: Viewing Git Output. (line 47) 3848 * magit-process-raise-error: Calling Git for Effect. 3849 (line 136) 3850 * magit-pull-or-fetch: Fetching. (line 59) 3851 * magit-reflog-margin: Reflog. (line 23) 3852 * magit-refresh-args: Refreshing Buffers. (line 55) 3853 * magit-refresh-buffer-hook: Automatic Refreshing of Magit Buffers. 3854 (line 43) 3855 * magit-refresh-function: Refreshing Buffers. (line 49) 3856 * magit-refresh-status-buffer: Automatic Refreshing of Magit Buffers. 3857 (line 49) 3858 * magit-refs-filter-alist: References Buffer. (line 163) 3859 * magit-refs-focus-column-width: References Buffer. (line 86) 3860 * magit-refs-margin: References Buffer. (line 101) 3861 * magit-refs-margin-for-tags: References Buffer. (line 129) 3862 * magit-refs-pad-commit-counts: References Buffer. (line 53) 3863 * magit-refs-primary-column-width: References Buffer. (line 73) 3864 * magit-refs-sections-hook: References Sections. (line 13) 3865 * magit-refs-show-commit-count: References Buffer. (line 41) 3866 * magit-refs-show-remote-prefix: References Buffer. (line 66) 3867 * magit-remote-add-set-remote.pushDefault: Remote Commands. (line 92) 3868 * magit-remote-direct-configure: Remote Commands. (line 21) 3869 * magit-remote-git-executable: Git Executable. (line 33) 3870 * magit-repolist-columns: Repository List. (line 14) 3871 * magit-repository-directories: Status Buffer. (line 58) 3872 * magit-revision-filter-files-on-follow: Revision Buffer. (line 64) 3873 * magit-revision-insert-related-refs: Revision Buffer. (line 6) 3874 * magit-revision-show-gravatars: Revision Buffer. (line 19) 3875 * magit-revision-use-hash-sections: Revision Buffer. (line 36) 3876 * magit-root-section: Matching Sections. (line 87) 3877 * magit-save-repository-buffers: Automatic Saving of File-Visiting Buffers. 3878 (line 13) 3879 * magit-section-cache-visibility: Section Visibility. (line 95) 3880 * magit-section-initial-visibility-alist: Section Visibility. (line 78) 3881 * magit-section-movement-hook: Section Movement. (line 46) 3882 * magit-section-set-visibility-hook: Section Visibility. (line 106) 3883 * magit-section-show-child-count: Section Options. (line 9) 3884 * magit-section-visibility-indicator: Section Visibility. (line 124) 3885 * magit-shell-command-verbose-prompt: Running Git Manually. 3886 (line 48) 3887 * magit-stashes-margin: Stashing. (line 104) 3888 * magit-status-headers-hook: Status Header Sections. 3889 (line 18) 3890 * magit-status-margin: Status Options. (line 10) 3891 * magit-status-refresh-hook: Status Options. (line 6) 3892 * magit-status-sections-hook: Status Sections. (line 10) 3893 * magit-submodule-list-columns: Listing Submodules. (line 21) 3894 * magit-this-process: Calling Git for Effect. 3895 (line 131) 3896 * magit-uniquify-buffer-names: Naming Buffers. (line 74) 3897 * magit-unstage-committed: Staging and Unstaging. 3898 (line 56) 3899 * magit-update-other-window-delay: Section Movement. (line 112) 3900 * magit-visit-ref-behavior: References Buffer. (line 196) 3901 * magit-wip-after-apply-mode: Legacy Wip Modes. (line 19) 3902 * magit-wip-after-apply-mode-lighter: Legacy Wip Modes. (line 59) 3903 * magit-wip-after-save-local-mode-lighter: Legacy Wip Modes. (line 55) 3904 * magit-wip-after-save-mode: Legacy Wip Modes. (line 13) 3905 * magit-wip-before-change-mode: Legacy Wip Modes. (line 33) 3906 * magit-wip-before-change-mode-lighter: Legacy Wip Modes. (line 63) 3907 * magit-wip-initial-backup-mode: Legacy Wip Modes. (line 38) 3908 * magit-wip-initial-backup-mode-lighter: Legacy Wip Modes. (line 67) 3909 * magit-wip-merge-branch: Wip Graph. (line 6) 3910 * magit-wip-mode: Wip Modes. (line 30) 3911 * magit-wip-mode-lighter: Wip Modes. (line 104) 3912 * magit-wip-namespace: Wip Modes. (line 96) 3913 * notes.displayRef: Notes. (line 65) 3914 * pull.rebase: Branch Git Variables. 3915 (line 57) 3916 * remote.NAME.fetch: Remote Git Variables. 3917 (line 15) 3918 * remote.NAME.push: Remote Git Variables. 3919 (line 26) 3920 * remote.NAME.pushurl: Remote Git Variables. 3921 (line 20) 3922 * remote.NAME.tagOpts: Remote Git Variables. 3923 (line 31) 3924 * remote.NAME.url: Remote Git Variables. 3925 (line 10) 3926 * remote.pushDefault: Branch Git Variables. 3927 (line 71) 3928