config

Personal configuration.
git clone git://code.dwrz.net/config
Log | Files | Refs

magit.info (540295B)


      1 This is magit.info, produced by makeinfo version 6.7 from magit.texi.
      2 
      3      Copyright (C) 2015-2024 Jonas Bernoulli
      4      <emacs.magit@jonas.bernoulli.dev>
      5 
      6      You can redistribute this document and/or modify it under the terms
      7      of the GNU General Public License as published by the Free Software
      8      Foundation, either version 3 of the License, or (at your option)
      9      any later version.
     10 
     11      This document is distributed in the hope that it will be useful,
     12      but WITHOUT ANY WARRANTY; without even the implied warranty of
     13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14      General Public License for more details.
     15 
     16 INFO-DIR-SECTION Emacs
     17 START-INFO-DIR-ENTRY
     18 * Magit: (magit).       Using Git from Emacs with Magit.
     19 END-INFO-DIR-ENTRY
     20 
     21 
     22 File: magit.info,  Node: Top,  Next: Introduction,  Up: (dir)
     23 
     24 Magit User Manual
     25 *****************
     26 
     27 Magit is an interface to the version control system Git, implemented as
     28 an Emacs package.  Magit aspires to be a complete Git porcelain.  While
     29 we cannot (yet) claim that Magit wraps and improves upon each and every
     30 Git command, it is complete enough to allow even experienced Git users
     31 to perform almost all of their daily version control tasks directly from
     32 within Emacs.  While many fine Git clients exist, only Magit and Git
     33 itself deserve to be called porcelains.
     34 
     35 This manual is for Magit version 3.3.0.50-git.
     36 
     37      Copyright (C) 2015-2024 Jonas Bernoulli
     38      <emacs.magit@jonas.bernoulli.dev>
     39 
     40      You can redistribute this document and/or modify it under the terms
     41      of the GNU General Public License as published by the Free Software
     42      Foundation, either version 3 of the License, or (at your option)
     43      any later version.
     44 
     45      This document is distributed in the hope that it will be useful,
     46      but WITHOUT ANY WARRANTY; without even the implied warranty of
     47      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     48      General Public License for more details.
     49 
     50 * Menu:
     51 
     52 * Introduction::
     53 * Installation::
     54 * Getting Started::
     55 * Interface Concepts::
     56 * Inspecting::
     57 * Manipulating::
     58 * Transferring::
     59 * Miscellaneous::
     60 * Customizing::
     61 * Plumbing::
     62 * FAQ::
     63 * Debugging Tools::
     64 * Keystroke Index::
     65 * Function and Command Index::
     66 * Variable Index::
     67 
     68 — The Detailed Node Listing —
     69 
     70 Installation
     71 
     72 * Installing from Melpa::
     73 * Installing from the Git Repository::
     74 * Post-Installation Tasks::
     75 
     76 Interface Concepts
     77 
     78 * Modes and Buffers::
     79 * Sections::
     80 * Transient Commands::
     81 * Transient Arguments and Buffer Variables::
     82 * Completion, Confirmation and the Selection: Completion Confirmation and the Selection.
     83 * Mouse Support::
     84 * Running Git::
     85 
     86 Modes and Buffers
     87 
     88 * Switching Buffers::
     89 * Naming Buffers::
     90 * Quitting Windows::
     91 * Automatic Refreshing of Magit Buffers::
     92 * Automatic Saving of File-Visiting Buffers::
     93 * Automatic Reverting of File-Visiting Buffers::
     94 
     95 
     96 Sections
     97 
     98 * Section Movement::
     99 * Section Visibility::
    100 * Section Hooks::
    101 * Section Types and Values::
    102 * Section Options::
    103 
    104 
    105 Completion, Confirmation and the Selection
    106 
    107 * Action Confirmation::
    108 * Completion and Confirmation::
    109 * The Selection::
    110 * The hunk-internal region::
    111 * Support for Completion Frameworks::
    112 * Additional Completion Options::
    113 
    114 
    115 Running Git
    116 
    117 * Viewing Git Output::
    118 * Git Process Status::
    119 * Running Git Manually::
    120 * Git Executable::
    121 * Global Git Arguments::
    122 
    123 
    124 Inspecting
    125 
    126 * Status Buffer::
    127 * Repository List::
    128 * Logging::
    129 * Diffing::
    130 * Ediffing::
    131 * References Buffer::
    132 * Bisecting::
    133 * Visiting Files and Blobs::
    134 * Blaming::
    135 
    136 Status Buffer
    137 
    138 * Status Sections::
    139 * Status Header Sections::
    140 * Status Module Sections::
    141 * Status Options::
    142 
    143 
    144 Logging
    145 
    146 * Refreshing Logs::
    147 * Log Buffer::
    148 * Log Margin::
    149 * Select from Log::
    150 * Reflog::
    151 * Cherries::
    152 
    153 
    154 Diffing
    155 
    156 * Refreshing Diffs::
    157 * Commands Available in Diffs::
    158 * Diff Options::
    159 * Revision Buffer::
    160 
    161 
    162 References Buffer
    163 
    164 * References Sections::
    165 
    166 
    167 Visiting Files and Blobs
    168 
    169 * General-Purpose Visit Commands::
    170 * Visiting Files and Blobs from a Diff::
    171 
    172 
    173 Manipulating
    174 
    175 * Creating Repository::
    176 * Cloning Repository::
    177 * Staging and Unstaging::
    178 * Applying::
    179 * Committing::
    180 * Branching::
    181 * Merging::
    182 * Resolving Conflicts::
    183 * Rebasing::
    184 * Cherry Picking::
    185 * Resetting::
    186 * Stashing::
    187 
    188 Staging and Unstaging
    189 
    190 * Staging from File-Visiting Buffers::
    191 
    192 
    193 Committing
    194 
    195 * Initiating a Commit::
    196 * Editing Commit Messages::
    197 
    198 
    199 Branching
    200 
    201 * The Two Remotes::
    202 * Branch Commands::
    203 * Branch Git Variables::
    204 * Auxiliary Branch Commands::
    205 
    206 
    207 Rebasing
    208 
    209 * Editing Rebase Sequences::
    210 * Information About In-Progress Rebase::
    211 
    212 
    213 Cherry Picking
    214 
    215 * Reverting::
    216 
    217 
    218 Transferring
    219 
    220 * Remotes::
    221 * Fetching::
    222 * Pulling::
    223 * Pushing::
    224 * Plain Patches::
    225 * Maildir Patches::
    226 
    227 Remotes
    228 
    229 * Remote Commands::
    230 * Remote Git Variables::
    231 
    232 
    233 Miscellaneous
    234 
    235 * Tagging::
    236 * Notes::
    237 * Submodules::
    238 * Subtree::
    239 * Worktree::
    240 * Sparse checkouts::
    241 * Bundle::
    242 * Common Commands::
    243 * Wip Modes::
    244 * Commands for Buffers Visiting Files::
    245 * Minor Mode for Buffers Visiting Blobs::
    246 
    247 Submodules
    248 
    249 * Listing Submodules::
    250 * Submodule Transient::
    251 
    252 
    253 Wip Modes
    254 
    255 * Wip Graph::
    256 * Legacy Wip Modes::
    257 
    258 
    259 Customizing
    260 
    261 * Per-Repository Configuration::
    262 * Essential Settings::
    263 
    264 Essential Settings
    265 
    266 * Safety::
    267 * Performance::
    268 * Global Bindings::
    269 
    270 
    271 Plumbing
    272 
    273 * Calling Git::
    274 * Section Plumbing::
    275 * Refreshing Buffers::
    276 * Conventions::
    277 
    278 Calling Git
    279 
    280 * Getting a Value from Git::
    281 * Calling Git for Effect::
    282 
    283 
    284 Section Plumbing
    285 
    286 * Creating Sections::
    287 * Section Selection::
    288 * Matching Sections::
    289 
    290 
    291 Conventions
    292 
    293 * Theming Faces::
    294 
    295 
    296 FAQ
    297 
    298 * FAQ - How to ...?::
    299 * FAQ - Issues and Errors::
    300 
    301 FAQ - How to ...?
    302 
    303 * How to pronounce Magit?::
    304 * How to show git's output?::
    305 * How to install the gitman info manual?::
    306 * How to show diffs for gpg-encrypted files?::
    307 * How does branching and pushing work?::
    308 * Should I disable VC?::
    309 
    310 
    311 FAQ - Issues and Errors
    312 
    313 * Magit is slow::
    314 * I changed several thousand files at once and now Magit is unusable::
    315 * I am having problems committing::
    316 * I am using MS Windows and cannot push with Magit::
    317 * I am using macOS and SOMETHING works in shell, but not in Magit: I am using macOS and SOMETHING works in shell but not in Magit.
    318 * Expanding a file to show the diff causes it to disappear::
    319 * Point is wrong in the COMMIT_EDITMSG buffer::
    320 * The mode-line information isn't always up-to-date::
    321 * A branch and tag sharing the same name breaks SOMETHING::
    322 * My Git hooks work on the command-line but not inside Magit::
    323 * git-commit-mode isn't used when committing from the command-line::
    324 * Point ends up inside invisible text when jumping to a file-visiting buffer::
    325 * I am no longer able to save popup defaults::
    326 
    327 
    328 
    329 
    330 File: magit.info,  Node: Introduction,  Next: Installation,  Prev: Top,  Up: Top
    331 
    332 1 Introduction
    333 **************
    334 
    335 Magit is an interface to the version control system Git, implemented as
    336 an Emacs package.  Magit aspires to be a complete Git porcelain.  While
    337 we cannot (yet) claim that Magit wraps and improves upon each and every
    338 Git command, it is complete enough to allow even experienced Git users
    339 to perform almost all of their daily version control tasks directly from
    340 within Emacs.  While many fine Git clients exist, only Magit and Git
    341 itself deserve to be called porcelains.
    342 
    343    Staging and otherwise applying changes is one of the most important
    344 features in a Git porcelain and here Magit outshines anything else,
    345 including Git itself.  Git’s own staging interface (‘git add --patch’)
    346 is so cumbersome that many users only use it in exceptional cases.  In
    347 Magit staging a hunk or even just part of a hunk is as trivial as
    348 staging all changes made to a file.
    349 
    350    The most visible part of Magit’s interface is the status buffer,
    351 which displays information about the current repository.  Its content is
    352 created by running several Git commands and making their output
    353 actionable.  Among other things, it displays information about the
    354 current branch, lists unpulled and unpushed changes and contains
    355 sections displaying the staged and unstaged changes.  That might sound
    356 noisy, but, since sections are collapsible, it’s not.
    357 
    358    To stage or unstage a change one places the cursor on the change and
    359 then types ‘s’ or ‘u’.  The change can be a file or a hunk, or when the
    360 region is active (i.e., when there is a selection) several files or
    361 hunks, or even just part of a hunk.  The change or changes that these
    362 commands - and many others - would act on are highlighted.
    363 
    364    Magit also implements several other "apply variants" in addition to
    365 staging and unstaging.  One can discard or reverse a change, or apply it
    366 to the working tree.  Git’s own porcelain only supports this for staging
    367 and unstaging and you would have to do something like ‘git diff ... |
    368 ??? | git apply ...’ to discard, revert, or apply a single hunk on the
    369 command line.  In fact that’s exactly what Magit does internally (which
    370 is what lead to the term "apply variants").
    371 
    372    Magit isn’t just for Git experts, but it does assume some prior
    373 experience with Git as well as Emacs.  That being said, many users have
    374 reported that using Magit was what finally taught them what Git is
    375 capable of and how to use it to its fullest.  Other users wished they
    376 had switched to Emacs sooner so that they would have gotten their hands
    377 on Magit earlier.
    378 
    379    While one has to know the basic features of Emacs to be able to make
    380 full use of Magit, acquiring just enough Emacs skills doesn’t take long
    381 and is worth it, even for users who prefer other editors.  Vim users are
    382 advised to give Evil (https://github.com/emacs-evil/evil), the
    383 "Extensible VI Layer for Emacs", and Spacemacs
    384 (https://github.com/syl20bnr/spacemacs), an "Emacs starter-kit focused
    385 on Evil" a try.
    386 
    387    Magit provides a consistent and efficient Git porcelain.  After a
    388 short learning period, you will be able to perform most of your daily
    389 version control tasks faster than you would on the command line.  You
    390 will likely also start using features that seemed too daunting in the
    391 past.
    392 
    393    Magit fully embraces Git.  It exposes many advanced features using a
    394 simple but flexible interface instead of only wrapping the trivial ones
    395 like many GUI clients do.  Of course Magit supports logging, cloning,
    396 pushing, and other commands that usually don’t fail in spectacular ways;
    397 but it also supports tasks that often cannot be completed in a single
    398 step.  Magit fully supports tasks such as merging, rebasing,
    399 cherry-picking, reverting, and blaming by not only providing a command
    400 to initiate these tasks but also by displaying context sensitive
    401 information along the way and providing commands that are useful for
    402 resolving conflicts and resuming the sequence after doing so.
    403 
    404    Magit wraps and in many cases improves upon at least the following
    405 Git porcelain commands: ‘add’, ‘am’, ‘bisect’, ‘blame’, ‘branch’,
    406 ‘checkout’, ‘cherry’, ‘cherry-pick’, ‘clean’, ‘clone’, ‘commit’,
    407 ‘config’, ‘describe’, ‘diff’, ‘fetch’, ‘format-patch’, ‘init’, ‘log’,
    408 ‘merge’, ‘merge-tree’, ‘mv’, ‘notes’, ‘pull’, ‘rebase’, ‘reflog’,
    409 ‘remote’, ‘request-pull’, ‘reset’, ‘revert’, ‘rm’, ‘show’, ‘stash’,
    410 ‘submodule’, ‘subtree’, ‘tag’, and ‘worktree.’ Many more Magit porcelain
    411 commands are implemented on top of Git plumbing commands.
    412 
    413 
    414 File: magit.info,  Node: Installation,  Next: Getting Started,  Prev: Introduction,  Up: Top
    415 
    416 2 Installation
    417 **************
    418 
    419 Magit can be installed using Emacs’ package manager or manually from its
    420 development repository.
    421 
    422 * Menu:
    423 
    424 * Installing from Melpa::
    425 * Installing from the Git Repository::
    426 * Post-Installation Tasks::
    427 
    428 
    429 File: magit.info,  Node: Installing from Melpa,  Next: Installing from the Git Repository,  Up: Installation
    430 
    431 2.1 Installing from Melpa
    432 =========================
    433 
    434 Magit is available from Melpa and Melpa-Stable.  If you haven’t used
    435 Emacs’ package manager before, then it is high time you familiarize
    436 yourself with it by reading the documentation in the Emacs manual, see
    437 *note (emacs)Packages::.  Then add one of the archives to
    438 ‘package-archives’:
    439 
    440    • To use Melpa:
    441 
    442      (require 'package)
    443      (add-to-list 'package-archives
    444                   '("melpa" . "https://melpa.org/packages/") t)
    445 
    446    • To use Melpa-Stable:
    447 
    448      (require 'package)
    449      (add-to-list 'package-archives
    450                   '("melpa-stable" . "https://stable.melpa.org/packages/") t)
    451 
    452    Once you have added your preferred archive, you need to update the
    453 local package list using:
    454 
    455      M-x package-refresh-contents RET
    456 
    457    Once you have done that, you can install Magit and its dependencies
    458 using:
    459 
    460      M-x package-install RET magit RET
    461 
    462    Now see *note Post-Installation Tasks::.
    463 
    464 
    465 File: magit.info,  Node: Installing from the Git Repository,  Next: Post-Installation Tasks,  Prev: Installing from Melpa,  Up: Installation
    466 
    467 2.2 Installing from the Git Repository
    468 ======================================
    469 
    470 Magit depends on the ‘compat’, ‘dash’, ‘transient’ and ‘with-editor’
    471 libraries which are available from Melpa and Melpa-Stable.  Install them
    472 using ‘M-x package-install RET <package> RET’.  Of course you may also
    473 install them manually from their repository.
    474 
    475    Then clone the Magit repository:
    476 
    477      $ git clone https://github.com/magit/magit.git ~/.emacs.d/site-lisp/magit
    478      $ cd ~/.emacs.d/site-lisp/magit
    479 
    480    Then compile the libraries and generate the info manuals:
    481 
    482      $ make
    483 
    484    If you haven’t installed ‘compat’, ‘dash’, ‘transient’ and
    485 ‘with-editor’ from Melpa or at ‘/path/to/magit/../<package>’, then you
    486 have to tell ‘make’ where to find them.  To do so create the file
    487 ‘/path/to/magit/config.mk’ with the following content before running
    488 ‘make’:
    489 
    490      LOAD_PATH  = -L ~/.emacs.d/site-lisp/magit/lisp
    491      LOAD_PATH += -L ~/.emacs.d/site-lisp/dash
    492      LOAD_PATH += -L ~/.emacs.d/site-lisp/transient/lisp
    493      LOAD_PATH += -L ~/.emacs.d/site-lisp/with-editor/lisp
    494      LOAD_PATH += -L ~/.emacs.d/site-lisp/compat
    495 
    496    Finally add this to your init file:
    497 
    498      (add-to-list 'load-path "~/.emacs.d/site-lisp/magit/lisp")
    499      (require 'magit)
    500 
    501      (with-eval-after-load 'info
    502        (info-initialize)
    503        (add-to-list 'Info-directory-list
    504                     "~/.emacs.d/site-lisp/magit/Documentation/"))
    505 
    506    Of course if you installed the dependencies manually as well, then
    507 you have to tell Emacs about them too, by prefixing the above with:
    508 
    509      (add-to-list 'load-path "~/.emacs.d/site-lisp/dash")
    510      (add-to-list 'load-path "~/.emacs.d/site-lisp/transient/lisp")
    511      (add-to-list 'load-path "~/.emacs.d/site-lisp/with-editor")
    512 
    513    Note that you have to add the ‘lisp’ subdirectory to the ‘load-path’,
    514 not the top-level of the repository, and that elements of ‘load-path’
    515 should not end with a slash, while those of ‘Info-directory-list’
    516 should.
    517 
    518    Instead of requiring the feature ‘magit’, you could load just the
    519 autoload definitions, by loading the file ‘magit-autoloads.el’.
    520 
    521      (load "/path/to/magit/lisp/magit-autoloads")
    522 
    523    Instead of running Magit directly from the repository by adding that
    524 to the ‘load-path’, you might want to instead install it in some other
    525 directory using ‘sudo make install’ and setting ‘load-path’ accordingly.
    526 
    527    To update Magit use:
    528 
    529      $ git pull
    530      $ make
    531 
    532    At times it might be necessary to run ‘make clean all’ instead.
    533 
    534    To view all available targets use ‘make help’.
    535 
    536    Now see *note Post-Installation Tasks::.
    537 
    538 
    539 File: magit.info,  Node: Post-Installation Tasks,  Prev: Installing from the Git Repository,  Up: Installation
    540 
    541 2.3 Post-Installation Tasks
    542 ===========================
    543 
    544 After installing Magit you should verify that you are indeed using the
    545 Magit, Git, and Emacs releases you think you are using.  It’s best to
    546 restart Emacs before doing so, to make sure you are not using an
    547 outdated value for ‘load-path’.
    548 
    549      M-x magit-version RET
    550 
    551    should display something like
    552 
    553      Magit 2.8.0, Git 2.10.2, Emacs 25.1.1, gnu/linux
    554 
    555    Then you might also want to read about options that many users likely
    556 want to customize.  See *note Essential Settings::.
    557 
    558    To be able to follow cross references to Git manpages found in this
    559 manual, you might also have to manually install the ‘gitman’ info
    560 manual, or advice ‘Info-follow-nearest-node’ to instead open the actual
    561 manpage.  See *note How to install the gitman info manual?::.
    562 
    563    If you are completely new to Magit then see *note Getting Started::.
    564 
    565    If you run into problems, then please see the *note FAQ::.  Also see
    566 the *note Debugging Tools::.
    567 
    568    And last but not least please consider making a donation, to ensure
    569 that I can keep working on Magit.  See <https://magit.vc/donations>.
    570 for various donation options.
    571 
    572 
    573 File: magit.info,  Node: Getting Started,  Next: Interface Concepts,  Prev: Installation,  Up: Top
    574 
    575 3 Getting Started
    576 *****************
    577 
    578 This short tutorial describes the most essential features that many
    579 Magitians use on a daily basis.  It only scratches the surface but
    580 should be enough to get you started.
    581 
    582    IMPORTANT: It is safest if you clone some repository just for this
    583 tutorial.  Alternatively you can use an existing local repository, but
    584 if you do that, then you should commit all uncommitted changes before
    585 proceeding.
    586 
    587    Type ‘C-x g’ to display information about the current Git repository
    588 in a dedicated buffer, called the status buffer.
    589 
    590    Most Magit commands are commonly invoked from the status buffer.  It
    591 can be considered the primary interface for interacting with Git using
    592 Magit.  Many other Magit buffers may exist at a given time, but they are
    593 often created from this buffer.
    594 
    595    Depending on what state your repository is in, this buffer may
    596 contain sections titled "Staged changes", "Unstaged changes", "Unmerged
    597 into origin/master", "Unpushed to origin/master", and many others.
    598 
    599    Since we are starting from a safe state, which you can easily return
    600 to (by doing a ‘git reset --hard PRE-MAGIT-STATE’), there currently are
    601 no staged or unstaged changes.  Edit some files and save the changes.
    602 Then go back to the status buffer, while at the same time refreshing it,
    603 by typing ‘C-x g’.  (When the status buffer, or any Magit buffer for
    604 that matter, is the current buffer, then you can also use just ‘g’ to
    605 refresh it).
    606 
    607    Move between sections using ‘p’ and ‘n’.  Note that the bodies of
    608 some sections are hidden.  Type ‘TAB’ to expand or collapse the section
    609 at point.  You can also use ‘C-tab’ to cycle the visibility of the
    610 current section and its children.  Move to a file section inside the
    611 section named "Unstaged changes" and type ‘s’ to stage the changes you
    612 have made to that file.  That file now appears under "Staged changes".
    613 
    614    Magit can stage and unstage individual hunks, not just complete
    615 files.  Move to the file you have just staged, expand it using ‘TAB’,
    616 move to one of the hunks using ‘n’, and unstage just that by typing ‘u’.
    617 Note how the staging (‘s’) and unstaging (‘u’) commands operate on the
    618 change at point.  Many other commands behave the same way.
    619 
    620    You can also un-/stage just part of a hunk.  Inside the body of a
    621 hunk section (move there using ‘C-n’), set the mark using ‘C-SPC’ and
    622 move down until some added and/or removed lines fall inside the region
    623 but not all of them.  Again type ‘s’ to stage.
    624 
    625    It is also possible to un-/stage multiple files at once.  Move to a
    626 file section, type ‘C-SPC’, move to the next file using ‘n’, and then
    627 ‘s’ to stage both files.  Note that both the mark and point have to be
    628 on the headings of sibling sections for this to work.  If the region
    629 looks like it does in other buffers, then it doesn’t select Magit
    630 sections that can be acted on as a unit.
    631 
    632    And then of course you want to commit your changes.  Type ‘c’.  This
    633 shows the available commit commands and arguments in a buffer at the
    634 bottom of the frame.  Each command and argument is prefixed with the key
    635 that invokes/sets it.  Do not worry about this for now.  We want to
    636 create a "normal" commit, which is done by typing ‘c’ again.
    637 
    638    Now two new buffers appear.  One is for writing the commit message,
    639 the other shows a diff with the changes that you are about to commit.
    640 Write a message and then type ‘C-c C-c’ to actually create the commit.
    641 
    642    You probably don’t want to push the commit you just created because
    643 you just committed some random changes, but if that is not the case you
    644 could push it by typing ‘P’ to show all the available push commands and
    645 arguments and then ‘p’ to push to a branch with the same name as the
    646 local branch onto the remote configured as the push-remote.  (If the
    647 push-remote is not configured yet, then you would first be prompted for
    648 the remote to push to.)
    649 
    650    So far we have mentioned the commit and push menu commands.  These
    651 are probably among the menus you will be using the most, but many others
    652 exist.  To show a menu that lists all other menus (as well as the
    653 various apply commands and some other essential commands), type ‘h’.
    654 Try a few.  (Such menus are also called "transient prefix commands" or
    655 just "transients".)
    656 
    657    The key bindings in that menu correspond to the bindings in Magit
    658 buffers, including but not limited to the status buffer.  So you could
    659 type ‘h d’ to bring up the diff menu, but once you remember that "d"
    660 stands for "diff", you would usually do so by just typing ‘d’.
    661 
    662    This "prefix of prefixes" is useful even once you have memorized all
    663 the bindings, as it can provide easy access to Magit commands from
    664 non-Magit buffers.  So, by default, it is globally bound to ‘C-x M-g’.
    665 
    666    A similar menu featuring (for the most part) commands that act on
    667 just the file being visited in the current buffer, is globally bound to
    668 ‘C-c M-g’.  That binding can also be used in buffers, which do not visit
    669 a file, but then only a subset of the commands is available.
    670 
    671    The global key bindings mentioned in the previous two paragraphs are
    672 quite inconvenient.  We recommend using ‘C-c g’ and ‘C-c f’ instead, but
    673 cannot use those key sequences by default because they are strictly
    674 reserved for bindings added by the user.  See *note Global Bindings::,
    675 if you want to explicitly opt-in to the recommended key bindings.
    676 
    677    Magit also provides context menus and other mouse commands, see *note
    678 Mouse Support::.
    679 
    680    It is not necessary that you do so now, but if you stick with Magit,
    681 then it is highly recommended that you read the next section too.
    682 
    683 
    684 File: magit.info,  Node: Interface Concepts,  Next: Inspecting,  Prev: Getting Started,  Up: Top
    685 
    686 4 Interface Concepts
    687 ********************
    688 
    689 * Menu:
    690 
    691 * Modes and Buffers::
    692 * Sections::
    693 * Transient Commands::
    694 * Transient Arguments and Buffer Variables::
    695 * Completion, Confirmation and the Selection: Completion Confirmation and the Selection.
    696 * Mouse Support::
    697 * Running Git::
    698 
    699 
    700 File: magit.info,  Node: Modes and Buffers,  Next: Sections,  Up: Interface Concepts
    701 
    702 4.1 Modes and Buffers
    703 =====================
    704 
    705 Magit provides several major-modes.  For each of these modes there
    706 usually exists only one buffer per repository.  Separate modes and thus
    707 buffers exist for commits, diffs, logs, and some other things.
    708 
    709    Besides these special purpose buffers, there also exists an overview
    710 buffer, called the *status buffer*.  It’s usually from this buffer that
    711 the user invokes Git commands, or creates or visits other buffers.
    712 
    713    In this manual we often speak about "Magit buffers".  By that we mean
    714 buffers whose major-modes derive from ‘magit-mode’.
    715 
    716 ‘M-x magit-toggle-buffer-lock’
    717      This command locks the current buffer to its value or if the buffer
    718      is already locked, then it unlocks it.
    719 
    720      Locking a buffer to its value prevents it from being reused to
    721      display another value.  The name of a locked buffer contains its
    722      value, which allows telling it apart from other locked buffers and
    723      the unlocked buffer.
    724 
    725      Not all Magit buffers can be locked to their values; for example,
    726      it wouldn’t make sense to lock a status buffer.
    727 
    728      There can only be a single unlocked buffer using a certain
    729      major-mode per repository.  So when a buffer is being unlocked and
    730      another unlocked buffer already exists for that mode and
    731      repository, then the former buffer is instead deleted and the
    732      latter is displayed in its place.
    733 
    734 * Menu:
    735 
    736 * Switching Buffers::
    737 * Naming Buffers::
    738 * Quitting Windows::
    739 * Automatic Refreshing of Magit Buffers::
    740 * Automatic Saving of File-Visiting Buffers::
    741 * Automatic Reverting of File-Visiting Buffers::
    742 
    743 
    744 File: magit.info,  Node: Switching Buffers,  Next: Naming Buffers,  Up: Modes and Buffers
    745 
    746 4.1.1 Switching Buffers
    747 -----------------------
    748 
    749  -- Function: magit-display-buffer buffer &optional display-function
    750      This function is a wrapper around ‘display-buffer’ and is used to
    751      display any Magit buffer.  It displays BUFFER in some window and,
    752      unlike ‘display-buffer’, also selects that window, provided
    753      ‘magit-display-buffer-noselect’ is ‘nil’.  It also runs the hooks
    754      mentioned below.
    755 
    756      If optional DISPLAY-FUNCTION is non-nil, then that is used to
    757      display the buffer.  Usually that is ‘nil’ and the function
    758      specified by ‘magit-display-buffer-function’ is used.
    759 
    760  -- Variable: magit-display-buffer-noselect
    761      When this is non-nil, then ‘magit-display-buffer’ only displays the
    762      buffer but forgoes also selecting the window.  This variable should
    763      not be set globally, it is only intended to be let-bound, by code
    764      that automatically updates "the other window".  This is used for
    765      example when the revision buffer is updated when you move inside
    766      the log buffer.
    767 
    768  -- User Option: magit-display-buffer-function
    769      The function specified here is called by ‘magit-display-buffer’
    770      with one argument, a buffer, to actually display that buffer.  This
    771      function should call ‘display-buffer’ with that buffer as first and
    772      a list of display actions as second argument.
    773 
    774      Magit provides several functions, listed below, that are suitable
    775      values for this option.  If you want to use different rules, then a
    776      good way of doing that is to start with a copy of one of these
    777      functions and then adjust it to your needs.
    778 
    779      Instead of using a wrapper around ‘display-buffer’, that function
    780      itself can be used here, in which case the display actions have to
    781      be specified by adding them to ‘display-buffer-alist’ instead.
    782 
    783      To learn about display actions, see *note (elisp)Choosing Window::.
    784 
    785  -- Function: magit-display-buffer-traditional buffer
    786      This function is the current default value of the option
    787      ‘magit-display-buffer-function’.  Before that option and this
    788      function were added, the behavior was hard-coded in many places all
    789      over the code base but now all the rules are contained in this one
    790      function (except for the "noselect" special case mentioned above).
    791 
    792  -- Function: magit-display-buffer-same-window-except-diff-v1
    793      This function displays most buffers in the currently selected
    794      window.  If a buffer’s mode derives from ‘magit-diff-mode’ or
    795      ‘magit-process-mode’, it is displayed in another window.
    796 
    797  -- Function: magit-display-buffer-fullframe-status-v1
    798      This function fills the entire frame when displaying a status
    799      buffer.  Otherwise, it behaves like
    800      ‘magit-display-buffer-traditional’.
    801 
    802  -- Function: magit-display-buffer-fullframe-status-topleft-v1
    803      This function fills the entire frame when displaying a status
    804      buffer.  It behaves like ‘magit-display-buffer-fullframe-status-v1’
    805      except that it displays buffers that derive from ‘magit-diff-mode’
    806      or ‘magit-process-mode’ to the top or left of the current buffer
    807      rather than to the bottom or right.  As a result, Magit buffers
    808      tend to pop up on the same side as they would if
    809      ‘magit-display-buffer-traditional’ were in use.
    810 
    811  -- Function: magit-display-buffer-fullcolumn-most-v1
    812      This function displays most buffers so that they fill the entire
    813      height of the frame.  However, the buffer is displayed in another
    814      window if (1) the buffer’s mode derives from ‘magit-process-mode’,
    815      or (2) the buffer’s mode derives from ‘magit-diff-mode’, provided
    816      that the mode of the current buffer derives from ‘magit-log-mode’
    817      or ‘magit-cherry-mode’.
    818 
    819  -- User Option: magit-pre-display-buffer-hook
    820      This hook is run by ‘magit-display-buffer’ before displaying the
    821      buffer.
    822 
    823  -- Function: magit-save-window-configuration
    824      This function saves the current window configuration.  Later when
    825      the buffer is buried, it may be restored by
    826      ‘magit-restore-window-configuration’.
    827 
    828  -- User Option: magit-post-display-buffer-hook
    829      This hook is run by ‘magit-display-buffer’ after displaying the
    830      buffer.
    831 
    832  -- Function: magit-maybe-set-dedicated
    833      This function remembers if a new window had to be created to
    834      display the buffer, or whether an existing window was reused.  This
    835      information is later used by ‘magit-mode-quit-window’, to determine
    836      whether the window should be deleted when its last Magit buffer is
    837      buried.
    838 
    839 
    840 File: magit.info,  Node: Naming Buffers,  Next: Quitting Windows,  Prev: Switching Buffers,  Up: Modes and Buffers
    841 
    842 4.1.2 Naming Buffers
    843 --------------------
    844 
    845  -- User Option: magit-generate-buffer-name-function
    846      The function used to generate the names of Magit buffers.
    847 
    848      Such a function should take the options
    849      ‘magit-uniquify-buffer-names’ as well as ‘magit-buffer-name-format’
    850      into account.  If it doesn’t, then should be clearly stated in the
    851      doc-string.  And if it supports %-sequences beyond those mentioned
    852      in the doc-string of the option ‘magit-buffer-name-format’, then
    853      its own doc-string should describe the additions.
    854 
    855  -- Function: magit-generate-buffer-name-default-function mode
    856      This function returns a buffer name suitable for a buffer whose
    857      major-mode is MODE and which shows information about the repository
    858      in which ‘default-directory’ is located.
    859 
    860      This function uses ‘magit-buffer-name-format’ and supporting all of
    861      the %-sequences mentioned the documentation of that option.  It
    862      also respects the option ‘magit-uniquify-buffer-names’.
    863 
    864  -- User Option: magit-buffer-name-format
    865      The format string used to name Magit buffers.
    866 
    867      At least the following %-sequences are supported:
    868 
    869         • ‘%m’
    870 
    871           The name of the major-mode, but with the ‘-mode’ suffix
    872           removed.
    873 
    874         • ‘%M’
    875 
    876           Like ‘%m’ but abbreviate ‘magit-status-mode’ as ‘magit’.
    877 
    878         • ‘%v’
    879 
    880           The value the buffer is locked to, in parentheses, or an empty
    881           string if the buffer is not locked to a value.
    882 
    883         • ‘%V’
    884 
    885           Like ‘%v’, but the string is prefixed with a space, unless it
    886           is an empty string.
    887 
    888         • ‘%t’
    889 
    890           The top-level directory of the working tree of the repository,
    891           or if ‘magit-uniquify-buffer-names’ is non-nil an abbreviation
    892           of that.
    893 
    894         • ‘%x’
    895 
    896           If ‘magit-uniquify-buffer-names’ is nil "*", otherwise the
    897           empty string.  Due to limitations of the ‘uniquify’ package,
    898           buffer names must end with the path.
    899 
    900      The value should always contain ‘%m’ or ‘%M’, ‘%v’ or ‘%V’, and
    901      ‘%t’.  If ‘magit-uniquify-buffer-names’ is non-nil, then the value
    902      must end with ‘%t’ or ‘%t%x’.  See issue #2841.
    903 
    904  -- User Option: magit-uniquify-buffer-names
    905      This option controls whether the names of Magit buffers are
    906      uniquified.  If the names are not being uniquified, then they
    907      contain the full path of the top-level of the working tree of the
    908      corresponding repository.  If they are being uniquified, then they
    909      end with the basename of the top-level, or if that would conflict
    910      with the name used for other buffers, then the names of all these
    911      buffers are adjusted until they no longer conflict.
    912 
    913      This is done using the ‘uniquify’ package; customize its options to
    914      control how buffer names are uniquified.
    915 
    916 
    917 File: magit.info,  Node: Quitting Windows,  Next: Automatic Refreshing of Magit Buffers,  Prev: Naming Buffers,  Up: Modes and Buffers
    918 
    919 4.1.3 Quitting Windows
    920 ----------------------
    921 
    922 ‘q’ (‘magit-mode-bury-buffer’)
    923      This command buries or kills the current Magit buffer.  The
    924      function specified by option ‘magit-bury-buffer-function’ is used
    925      to bury the buffer when called without a prefix argument or to kill
    926      it when called with a single prefix argument.
    927 
    928      When called with two or more prefix arguments then it always kills
    929      all Magit buffers, associated with the current project, including
    930      the current buffer.
    931 
    932  -- User Option: magit-bury-buffer-function
    933      The function used to actually bury or kill the current buffer.
    934 
    935      ‘magit-mode-bury-buffer’ calls this function with one argument.  If
    936      the argument is non-nil, then the function has to kill the current
    937      buffer.  Otherwise it has to bury it alive.  The default value
    938      currently is ‘magit-mode-quit-window’.
    939 
    940  -- Function: magit-restore-window-configuration kill-buffer
    941      Bury or kill the current buffer using ‘quit-window’, which is
    942      called with KILL-BUFFER as first and the selected window as second
    943      argument.
    944 
    945      Then restore the window configuration that existed right before the
    946      current buffer was displayed in the selected frame.  Unfortunately
    947      that also means that point gets adjusted in all the buffers, which
    948      are being displayed in the selected frame.
    949 
    950  -- Function: magit-mode-quit-window kill-buffer
    951      Bury or kill the current buffer using ‘quit-window’, which is
    952      called with KILL-BUFFER as first and the selected window as second
    953      argument.
    954 
    955      Then, if the window was originally created to display a Magit
    956      buffer and the buried buffer was the last remaining Magit buffer
    957      that was ever displayed in the window, then that is deleted.
    958 
    959 
    960 File: magit.info,  Node: Automatic Refreshing of Magit Buffers,  Next: Automatic Saving of File-Visiting Buffers,  Prev: Quitting Windows,  Up: Modes and Buffers
    961 
    962 4.1.4 Automatic Refreshing of Magit Buffers
    963 -------------------------------------------
    964 
    965 After running a command which may change the state of the current
    966 repository, the current Magit buffer and the corresponding status buffer
    967 are refreshed.  The status buffer can be automatically refreshed
    968 whenever a buffer is saved to a file inside the respective repository by
    969 adding a hook, like so:
    970 
    971      (with-eval-after-load 'magit-mode
    972        (add-hook 'after-save-hook 'magit-after-save-refresh-status t))
    973 
    974    Automatically refreshing Magit buffers ensures that the displayed
    975 information is up-to-date most of the time but can lead to a noticeable
    976 delay in big repositories.  Other Magit buffers are not refreshed to
    977 keep the delay to a minimum and also because doing so can sometimes be
    978 undesirable.
    979 
    980    Buffers can also be refreshed explicitly, which is useful in buffers
    981 that weren’t current during the last refresh and after changes were made
    982 to the repository outside of Magit.
    983 
    984 ‘g’ (‘magit-refresh’)
    985      This command refreshes the current buffer if its major mode derives
    986      from ‘magit-mode’ as well as the corresponding status buffer.
    987 
    988      If the option ‘magit-revert-buffers’ calls for it, then it also
    989      reverts all unmodified buffers that visit files being tracked in
    990      the current repository.
    991 
    992 ‘G’ (‘magit-refresh-all’)
    993      This command refreshes all Magit buffers belonging to the current
    994      repository and also reverts all unmodified buffers that visit files
    995      being tracked in the current repository.
    996 
    997      The file-visiting buffers are always reverted, even if
    998      ‘magit-revert-buffers’ is nil.
    999 
   1000  -- User Option: magit-refresh-buffer-hook
   1001      This hook is run in each Magit buffer that was refreshed during the
   1002      current refresh - normally the current buffer and the status
   1003      buffer.
   1004 
   1005  -- User Option: magit-refresh-status-buffer
   1006      When this option is non-nil, then the status buffer is
   1007      automatically refreshed after running git for side-effects, in
   1008      addition to the current Magit buffer, which is always refreshed
   1009      automatically.
   1010 
   1011      Only set this to nil after exhausting all other options to improve
   1012      performance.
   1013 
   1014  -- Function: magit-after-save-refresh-status
   1015      This function is intended to be added to ‘after-save-hook’.  After
   1016      doing that the corresponding status buffer is refreshed whenever a
   1017      buffer is saved to a file inside a repository.
   1018 
   1019      Note that refreshing a Magit buffer is done by re-creating its
   1020      contents from scratch, which can be slow in large repositories.  If
   1021      you are not satisfied with Magit’s performance, then you should
   1022      obviously not add this function to that hook.
   1023 
   1024 
   1025 File: magit.info,  Node: Automatic Saving of File-Visiting Buffers,  Next: Automatic Reverting of File-Visiting Buffers,  Prev: Automatic Refreshing of Magit Buffers,  Up: Modes and Buffers
   1026 
   1027 4.1.5 Automatic Saving of File-Visiting Buffers
   1028 -----------------------------------------------
   1029 
   1030 File-visiting buffers are by default saved at certain points in time.
   1031 This doesn’t guarantee that Magit buffers are always up-to-date, but,
   1032 provided one only edits files by editing them in Emacs and uses only
   1033 Magit to interact with Git, one can be fairly confident.  When in doubt
   1034 or after outside changes, type ‘g’ (‘magit-refresh’) to save and refresh
   1035 explicitly.
   1036 
   1037  -- User Option: magit-save-repository-buffers
   1038      This option controls whether file-visiting buffers are saved before
   1039      certain events.
   1040 
   1041      If this is non-nil then all modified file-visiting buffers
   1042      belonging to the current repository may be saved before running
   1043      commands, before creating new Magit buffers, and before explicitly
   1044      refreshing such buffers.  If this is ‘dontask’ then this is done
   1045      without user intervention.  If it is ‘t’ then the user has to
   1046      confirm each save.
   1047 
   1048 
   1049 File: magit.info,  Node: Automatic Reverting of File-Visiting Buffers,  Prev: Automatic Saving of File-Visiting Buffers,  Up: Modes and Buffers
   1050 
   1051 4.1.6 Automatic Reverting of File-Visiting Buffers
   1052 --------------------------------------------------
   1053 
   1054 By default Magit automatically reverts buffers that are visiting files
   1055 that are being tracked in a Git repository, after they have changed on
   1056 disk.  When using Magit one often changes files on disk by running Git,
   1057 i.e., "outside Emacs", making this a rather important feature.
   1058 
   1059    For example, if you discard a change in the status buffer, then that
   1060 is done by running ‘git apply --reverse ...’, and Emacs considers the
   1061 file to have "changed on disk".  If Magit did not automatically revert
   1062 the buffer, then you would have to type ‘M-x revert-buffer RET RET’ in
   1063 the visiting buffer before you could continue making changes.
   1064 
   1065  -- User Option: magit-auto-revert-mode
   1066      When this mode is enabled, then buffers that visit tracked files
   1067      are automatically reverted after the visited files change on disk.
   1068 
   1069  -- User Option: global-auto-revert-mode
   1070      When this mode is enabled, then any file-visiting buffer is
   1071      automatically reverted after the visited file changes on disk.
   1072 
   1073      If you like buffers that visit tracked files to be automatically
   1074      reverted, then you might also like any buffer to be reverted, not
   1075      just those visiting tracked files.  If that is the case, then
   1076      enable this mode _instead of_ ‘magit-auto-revert-mode’.
   1077 
   1078  -- User Option: magit-auto-revert-immediately
   1079      This option controls whether Magit reverts buffers immediately.
   1080 
   1081      If this is non-nil and either ‘global-auto-revert-mode’ or
   1082      ‘magit-auto-revert-mode’ is enabled, then Magit immediately reverts
   1083      buffers by explicitly calling ‘auto-revert-buffers’ after running
   1084      Git for side-effects.
   1085 
   1086      If ‘auto-revert-use-notify’ is non-nil (and file notifications are
   1087      actually supported), then ‘magit-auto-revert-immediately’ does not
   1088      have to be non-nil, because the reverts happen immediately anyway.
   1089 
   1090      If ‘magit-auto-revert-immediately’ and ‘auto-revert-use-notify’ are
   1091      both ‘nil’, then reverts happen after ‘auto-revert-interval’
   1092      seconds of user inactivity.  That is not desirable.
   1093 
   1094  -- User Option: auto-revert-use-notify
   1095      This option controls whether file notification functions should be
   1096      used.  Note that this variable unfortunately defaults to ‘t’ even
   1097      on systems on which file notifications cannot be used.
   1098 
   1099  -- User Option: magit-auto-revert-tracked-only
   1100      This option controls whether ‘magit-auto-revert-mode’ only reverts
   1101      tracked files or all files that are located inside Git
   1102      repositories, including untracked files and files located inside
   1103      Git’s control directory.
   1104 
   1105  -- User Option: auto-revert-mode
   1106      The global mode ‘magit-auto-revert-mode’ works by turning on this
   1107      local mode in the appropriate buffers (but
   1108      ‘global-auto-revert-mode’ is implemented differently).  You can
   1109      also turn it on or off manually, which might be necessary if Magit
   1110      does not notice that a previously untracked file now is being
   1111      tracked or vice-versa.
   1112 
   1113  -- User Option: auto-revert-stop-on-user-input
   1114      This option controls whether the arrival of user input suspends the
   1115      automatic reverts for ‘auto-revert-interval’ seconds.
   1116 
   1117  -- User Option: auto-revert-interval
   1118      This option controls how many seconds Emacs waits for before
   1119      resuming suspended reverts.
   1120 
   1121  -- User Option: auto-revert-buffer-list-filter
   1122      This option specifies an additional filter used by
   1123      ‘auto-revert-buffers’ to determine whether a buffer should be
   1124      reverted or not.
   1125 
   1126      This option is provided by Magit, which also advises
   1127      ‘auto-revert-buffers’ to respect it.  Magit users who do not turn
   1128      on the local mode ‘auto-revert-mode’ themselves, are best served by
   1129      setting the value to ‘magit-auto-revert-repository-buffer-p’.
   1130 
   1131      However the default is nil, so as not to disturb users who do use
   1132      the local mode directly.  If you experience delays when running
   1133      Magit commands, then you should consider using one of the
   1134      predicates provided by Magit - especially if you also use Tramp.
   1135 
   1136      Users who do turn on ‘auto-revert-mode’ in buffers in which Magit
   1137      doesn’t do that for them, should likely not use any filter.  Users
   1138      who turn on ‘global-auto-revert-mode’, do not have to worry about
   1139      this option, because it is disregarded if the global mode is
   1140      enabled.
   1141 
   1142  -- User Option: auto-revert-verbose
   1143      This option controls whether Emacs reports when a buffer has been
   1144      reverted.
   1145 
   1146    The options with the ‘auto-revert-’ prefix are located in the Custom
   1147 group named ‘auto-revert’.  The other, Magit-specific, options are
   1148 located in the ‘magit’ group.
   1149 
   1150 * Menu:
   1151 
   1152 * Risk of Reverting Automatically::
   1153 
   1154 
   1155 File: magit.info,  Node: Risk of Reverting Automatically,  Up: Automatic Reverting of File-Visiting Buffers
   1156 
   1157 Risk of Reverting Automatically
   1158 ...............................
   1159 
   1160 For the vast majority of users, automatically reverting file-visiting
   1161 buffers after they have changed on disk is harmless.
   1162 
   1163    If a buffer is modified (i.e., it contains changes that haven’t been
   1164 saved yet), then Emacs will refuse to automatically revert it.  If you
   1165 save a previously modified buffer, then that results in what is seen by
   1166 Git as an uncommitted change.  Git will then refuse to carry out any
   1167 commands that would cause these changes to be lost.  In other words, if
   1168 there is anything that could be lost, then either Git or Emacs will
   1169 refuse to discard the changes.
   1170 
   1171    However, if you use file-visiting buffers as a sort of ad hoc
   1172 "staging area", then the automatic reverts could potentially cause data
   1173 loss.  So far I have heard from only one user who uses such a workflow.
   1174 
   1175    An example: You visit some file in a buffer, edit it, and save the
   1176 changes.  Then, outside of Emacs (or at least not using Magit or by
   1177 saving the buffer) you change the file on disk again.  At this point the
   1178 buffer is the only place where the intermediate version still exists.
   1179 You have saved the changes to disk, but that has since been overwritten.
   1180 Meanwhile Emacs considers the buffer to be unmodified (because you have
   1181 not made any changes to it since you last saved it to the visited file)
   1182 and therefore would not object to it being automatically reverted.  At
   1183 this point an Auto-Revert mode would kick in.  It would check whether
   1184 the buffer is modified and since that is not the case it would revert
   1185 it.  The intermediate version would be lost.  (Actually you could still
   1186 get it back using the ‘undo’ command.)
   1187 
   1188    If your workflow depends on Emacs preserving the intermediate version
   1189 in the buffer, then you have to disable all Auto-Revert modes.  But
   1190 please consider that such a workflow would be dangerous even without
   1191 using an Auto-Revert mode, and should therefore be avoided.  If Emacs
   1192 crashes or if you quit Emacs by mistake, then you would also lose the
   1193 buffer content.  There would be no autosave file still containing the
   1194 intermediate version (because that was deleted when you saved the
   1195 buffer) and you would not be asked whether you want to save the buffer
   1196 (because it isn’t modified).
   1197 
   1198 
   1199 File: magit.info,  Node: Sections,  Next: Transient Commands,  Prev: Modes and Buffers,  Up: Interface Concepts
   1200 
   1201 4.2 Sections
   1202 ============
   1203 
   1204 Magit buffers are organized into nested sections, which can be collapsed
   1205 and expanded, similar to how sections are handled in Org mode.  Each
   1206 section also has a type, and some sections also have a value.  For each
   1207 section type there can also be a local keymap, shared by all sections of
   1208 that type.
   1209 
   1210    Taking advantage of the section value and type, many commands operate
   1211 on the current section, or when the region is active and selects
   1212 sections of the same type, all of the selected sections.  Commands that
   1213 only make sense for a particular section type (as opposed to just
   1214 behaving differently depending on the type) are usually bound in section
   1215 type keymaps.
   1216 
   1217 * Menu:
   1218 
   1219 * Section Movement::
   1220 * Section Visibility::
   1221 * Section Hooks::
   1222 * Section Types and Values::
   1223 * Section Options::
   1224 
   1225 
   1226 File: magit.info,  Node: Section Movement,  Next: Section Visibility,  Up: Sections
   1227 
   1228 4.2.1 Section Movement
   1229 ----------------------
   1230 
   1231 To move within a section use the usual keys (‘C-p’, ‘C-n’, ‘C-b’, ‘C-f’
   1232 etc), whose global bindings are not shadowed.  To move to another
   1233 section use the following commands.
   1234 
   1235 ‘p’ (‘magit-section-backward’)
   1236      When not at the beginning of a section, then move to the beginning
   1237      of the current section.  At the beginning of a section, instead
   1238      move to the beginning of the previous visible section.
   1239 
   1240 ‘n’ (‘magit-section-forward’)
   1241      Move to the beginning of the next visible section.
   1242 
   1243 ‘M-p’ (‘magit-section-backward-siblings’)
   1244      Move to the beginning of the previous sibling section.  If there is
   1245      no previous sibling section, then move to the parent section
   1246      instead.
   1247 
   1248 ‘M-n’ (‘magit-section-forward-siblings’)
   1249      Move to the beginning of the next sibling section.  If there is no
   1250      next sibling section, then move to the parent section instead.
   1251 
   1252 ‘^’ (‘magit-section-up’)
   1253      Move to the beginning of the parent of the current section.
   1254 
   1255    The above commands all call the hook ‘magit-section-movement-hook’.
   1256 Any of the functions listed below can be used as members of this hook.
   1257 
   1258    You might want to remove some of the functions that Magit adds using
   1259 ‘add-hook’.  In doing so you have to make sure you do not attempt to
   1260 remove function that haven’t even been added yet, for example:
   1261 
   1262      (with-eval-after-load 'magit-diff
   1263        (remove-hook 'magit-section-movement-hook
   1264                     'magit-hunk-set-window-start))
   1265 
   1266  -- Variable: magit-section-movement-hook
   1267      This hook is run by all of the above movement commands, after
   1268      arriving at the destination.
   1269 
   1270  -- Function: magit-hunk-set-window-start
   1271      This hook function ensures that the beginning of the current
   1272      section is visible, provided it is a ‘hunk’ section.  Otherwise, it
   1273      does nothing.
   1274 
   1275      Loading ‘magit-diff’ adds this function to the hook.
   1276 
   1277  -- Function: magit-section-set-window-start
   1278      This hook function ensures that the beginning of the current
   1279      section is visible, regardless of the section’s type.  If you add
   1280      this to ‘magit-section-movement-hook’, then you must remove the
   1281      hunk-only variant in turn.
   1282 
   1283  -- Function: magit-log-maybe-show-more-commits
   1284      This hook function only has an effect in log buffers, and ‘point’
   1285      is on the "show more" section.  If that is the case, then it
   1286      doubles the number of commits that are being shown.
   1287 
   1288      Loading ‘magit-log’ adds this function to the hook.
   1289 
   1290  -- Function: magit-log-maybe-update-revision-buffer
   1291      When moving inside a log buffer, then this function updates the
   1292      revision buffer, provided it is already being displayed in another
   1293      window of the same frame.
   1294 
   1295      Loading ‘magit-log’ adds this function to the hook.
   1296 
   1297  -- Function: magit-log-maybe-update-blob-buffer
   1298      When moving inside a log buffer and another window of the same
   1299      frame displays a blob buffer, then this function instead displays
   1300      the blob buffer for the commit at point in that window.
   1301 
   1302  -- Function: magit-status-maybe-update-revision-buffer
   1303      When moving inside a status buffer, then this function updates the
   1304      revision buffer, provided it is already being displayed in another
   1305      window of the same frame.
   1306 
   1307  -- Function: magit-status-maybe-update-stash-buffer
   1308      When moving inside a status buffer, then this function updates the
   1309      stash buffer, provided it is already being displayed in another
   1310      window of the same frame.
   1311 
   1312  -- Function: magit-status-maybe-update-blob-buffer
   1313      When moving inside a status buffer and another window of the same
   1314      frame displays a blob buffer, then this function instead displays
   1315      the blob buffer for the commit at point in that window.
   1316 
   1317  -- Function: magit-stashes-maybe-update-stash-buffer
   1318      When moving inside a buffer listing stashes, then this function
   1319      updates the stash buffer, provided it is already being displayed in
   1320      another window of the same frame.
   1321 
   1322  -- User Option: magit-update-other-window-delay
   1323      Delay before automatically updating the other window.
   1324 
   1325      When moving around in certain buffers, then certain other buffers,
   1326      which are being displayed in another window, may optionally be
   1327      updated to display information about the section at point.
   1328 
   1329      When holding down a key to move by more than just one section, then
   1330      that would update that buffer for each section on the way.  To
   1331      prevent that, updating the revision buffer is delayed, and this
   1332      option controls for how long.  For optimal experience you might
   1333      have to adjust this delay and/or the keyboard repeat rate and delay
   1334      of your graphical environment or operating system.
   1335 
   1336 
   1337 File: magit.info,  Node: Section Visibility,  Next: Section Hooks,  Prev: Section Movement,  Up: Sections
   1338 
   1339 4.2.2 Section Visibility
   1340 ------------------------
   1341 
   1342 Magit provides many commands for changing the visibility of sections,
   1343 but all you need to get started are the next two.
   1344 
   1345 ‘<TAB>’ (‘magit-section-toggle’)
   1346      Toggle the visibility of the body of the current section.
   1347 
   1348 ‘C-c <TAB>’ (‘magit-section-cycle’)
   1349 ‘C-<tab>’ (‘magit-section-cycle’)
   1350      Cycle the visibility of current section and its children.
   1351 
   1352      If this command is invoked using ‘C-<tab>’ and that is globally
   1353      bound to ‘tab-next’, then this command pivots to behave like that
   1354      command, and you must instead use ‘C-c TAB’ to cycle section
   1355      visibility.
   1356 
   1357      If you would like to keep using ‘C-<tab>’ to cycle section
   1358      visibility but also want to use ‘tab-bar-mode’, then you have to
   1359      prevent that mode from using this key and instead bind another key
   1360      to ‘tab-next’.  Because ‘tab-bar-mode’ does not use a mode map but
   1361      instead manipulates the global map, this involves advising
   1362      ‘tab-bar--define-keys’.
   1363 
   1364 ‘M-<tab>’ (‘magit-section-cycle-diffs’)
   1365      Cycle the visibility of diff-related sections in the current
   1366      buffer.
   1367 
   1368 ‘S-<tab>’ (‘magit-section-cycle-global’)
   1369      Cycle the visibility of all sections in the current buffer.
   1370 
   1371 ‘1’ (‘magit-section-show-level-1’)
   1372 ‘2’ (‘magit-section-show-level-2’)
   1373 ‘3’ (‘magit-section-show-level-3’)
   1374 ‘4’ (‘magit-section-show-level-4’)
   1375      Show sections surrounding the current section up to level N.
   1376 
   1377 ‘M-1’ (‘magit-section-show-level-1-all’)
   1378 ‘M-2’ (‘magit-section-show-level-2-all’)
   1379 ‘M-3’ (‘magit-section-show-level-3-all’)
   1380 ‘M-4’ (‘magit-section-show-level-4-all’)
   1381      Show all sections up to level N.
   1382 
   1383    Some functions, which are used to implement the above commands, are
   1384 also exposed as commands themselves.  By default no keys are bound to
   1385 these commands, as they are generally perceived to be much less useful.
   1386 But your mileage may vary.
   1387 
   1388  -- Command: magit-section-show
   1389      Show the body of the current section.
   1390 
   1391  -- Command: magit-section-hide
   1392      Hide the body of the current section.
   1393 
   1394  -- Command: magit-section-show-headings
   1395      Recursively show headings of children of the current section.  Only
   1396      show the headings.  Previously shown text-only bodies are hidden.
   1397 
   1398  -- Command: magit-section-show-children
   1399      Recursively show the bodies of children of the current section.
   1400      With a prefix argument show children down to the level of the
   1401      current section, and hide deeper children.
   1402 
   1403  -- Command: magit-section-hide-children
   1404      Recursively hide the bodies of children of the current section.
   1405 
   1406  -- Command: magit-section-toggle-children
   1407      Toggle visibility of bodies of children of the current section.
   1408 
   1409    When a buffer is first created then some sections are shown expanded
   1410 while others are not.  This is hard coded.  When a buffer is refreshed
   1411 then the previous visibility is preserved.  The initial visibility of
   1412 certain sections can also be overwritten using the hook
   1413 ‘magit-section-set-visibility-hook’.
   1414 
   1415  -- User Option: magit-section-initial-visibility-alist
   1416      This options can be used to override the initial visibility of
   1417      sections.  In the future it will also be used to define the
   1418      defaults, but currently a section’s default is still hardcoded.
   1419 
   1420      The value is an alist.  Each element maps a section type or lineage
   1421      to the initial visibility state for such sections.  The state has
   1422      to be one of ‘show’ or ‘hide’, or a function that returns one of
   1423      these symbols.  A function is called with the section as the only
   1424      argument.
   1425 
   1426      Use the command ‘magit-describe-section-briefly’ to determine a
   1427      section’s lineage or type.  The vector in the output is the section
   1428      lineage and the type is the first element of that vector.
   1429      Wildcards can be used, see ‘magit-section-match’.
   1430 
   1431  -- User Option: magit-section-cache-visibility
   1432      This option controls for which sections the previous visibility
   1433      state should be restored if a section disappears and later appears
   1434      again.  The value is a boolean or a list of section types.  If t,
   1435      then the visibility of all sections is cached.  Otherwise this is
   1436      only done for sections whose type matches one of the listed types.
   1437 
   1438      This requires that the function ‘magit-section-cached-visibility’
   1439      is a member of ‘magit-section-set-visibility-hook’.
   1440 
   1441  -- Variable: magit-section-set-visibility-hook
   1442      This hook is run when first creating a buffer and also when
   1443      refreshing an existing buffer, and is used to determine the
   1444      visibility of the section currently being inserted.
   1445 
   1446      Each function is called with one argument, the section being
   1447      inserted.  It should return ‘hide’ or ‘show’, or to leave the
   1448      visibility undefined ‘nil’.  If no function decides on the
   1449      visibility and the buffer is being refreshed, then the visibility
   1450      is preserved; or if the buffer is being created, then the hard
   1451      coded default is used.
   1452 
   1453      Usually this should only be used to set the initial visibility but
   1454      not during refreshes.  If ‘magit-insert-section--oldroot’ is
   1455      non-nil, then the buffer is being refreshed and these functions
   1456      should immediately return ‘nil’.
   1457 
   1458  -- User Option: magit-section-visibility-indicator
   1459      This option controls whether and how to indicate that a section can
   1460      be expanded/collapsed.
   1461 
   1462      If nil, then no visibility indicators are shown.  Otherwise the
   1463      value has to have one of these two forms:
   1464 
   1465         • ‘(EXPANDABLE-BITMAP . COLLAPSIBLE-BITMAP)’
   1466 
   1467           Both values have to be variables whose values are fringe
   1468           bitmaps.  In this case every section that can be expanded or
   1469           collapsed gets an indicator in the left fringe.
   1470 
   1471           To provide extra padding around the indicator, set
   1472           ‘left-fringe-width’ in ‘magit-mode-hook’, e.g.:
   1473 
   1474                (add-hook 'magit-mode-hook (lambda ()
   1475                                             (setq left-fringe-width 20)))
   1476 
   1477         • ‘(STRING . BOOLEAN)’
   1478 
   1479           In this case STRING (usually an ellipsis) is shown at the end
   1480           of the heading of every collapsed section.  Expanded sections
   1481           get no indicator.  The cdr controls whether the appearance of
   1482           these ellipsis take section highlighting into account.  Doing
   1483           so might potentially have an impact on performance, while not
   1484           doing so is kinda ugly.
   1485 
   1486 
   1487 File: magit.info,  Node: Section Hooks,  Next: Section Types and Values,  Prev: Section Visibility,  Up: Sections
   1488 
   1489 4.2.3 Section Hooks
   1490 -------------------
   1491 
   1492 Which sections are inserted into certain buffers is controlled with
   1493 hooks.  This includes the status and the refs buffers.  For other
   1494 buffers, e.g., log and diff buffers, this is not possible.  The command
   1495 ‘magit-describe-section’ can be used to see which hook (if any) was
   1496 responsible for inserting the section at point.
   1497 
   1498    For buffers whose sections can be customized by the user, a hook
   1499 variable called ‘magit-TYPE-sections-hook’ exists.  This hook should be
   1500 changed using ‘magit-add-section-hook’.  Avoid using ‘add-hooks’ or the
   1501 Custom interface.
   1502 
   1503    The various available section hook variables are described later in
   1504 this manual along with the appropriate "section inserter functions".
   1505 
   1506  -- Function: magit-add-section-hook hook function &optional at append
   1507           local
   1508      Add the function FUNCTION to the value of section hook HOOK.
   1509 
   1510      Add FUNCTION at the beginning of the hook list unless optional
   1511      APPEND is non-nil, in which case FUNCTION is added at the end.  If
   1512      FUNCTION already is a member then move it to the new location.
   1513 
   1514      If optional AT is non-nil and a member of the hook list, then add
   1515      FUNCTION next to that instead.  Add before or after AT, or replace
   1516      AT with FUNCTION depending on APPEND.  If APPEND is the symbol
   1517      ‘replace’, then replace AT with FUNCTION.  For any other non-nil
   1518      value place FUNCTION right after AT.  If nil, then place FUNCTION
   1519      right before AT.  If FUNCTION already is a member of the list but
   1520      AT is not, then leave FUNCTION where ever it already is.
   1521 
   1522      If optional LOCAL is non-nil, then modify the hook’s buffer-local
   1523      value rather than its global value.  This makes the hook local by
   1524      copying the default value.  That copy is then modified.
   1525 
   1526      HOOK should be a symbol.  If HOOK is void, it is first set to nil.
   1527      HOOK’s value must not be a single hook function.  FUNCTION should
   1528      be a function that takes no arguments and inserts one or multiple
   1529      sections at point, moving point forward.  FUNCTION may choose not
   1530      to insert its section(s), when doing so would not make sense.  It
   1531      should not be abused for other side-effects.
   1532 
   1533    To remove a function from a section hook, use ‘remove-hook’.
   1534 
   1535 
   1536 File: magit.info,  Node: Section Types and Values,  Next: Section Options,  Prev: Section Hooks,  Up: Sections
   1537 
   1538 4.2.4 Section Types and Values
   1539 ------------------------------
   1540 
   1541 Each section has a type, for example ‘hunk’, ‘file’, and ‘commit’.
   1542 Instances of certain section types also have a value.  The value of a
   1543 section of type ‘file’, for example, is a file name.
   1544 
   1545    Users usually do not have to worry about a section’s type and value,
   1546 but knowing them can be handy at times.
   1547 
   1548 ‘H’ (‘magit-describe-section’)
   1549      This command shows information about the section at point in a
   1550      separate buffer.
   1551 
   1552  -- Command: magit-describe-section-briefly
   1553      This command shows information about the section at point in the
   1554      echo area, as ‘#<magit-section VALUE [TYPE PARENT-TYPE...]
   1555      BEGINNING-END>’.
   1556 
   1557    Many commands behave differently depending on the type of the section
   1558 at point and/or somehow consume the value of that section.  But that is
   1559 only one of the reasons why the same key may do something different,
   1560 depending on what section is current.
   1561 
   1562    Additionally for each section type a keymap *might* be defined, named
   1563 ‘magit-TYPE-section-map’.  That keymap is used as text property keymap
   1564 of all text belonging to any section of the respective type.  If such a
   1565 map does not exist for a certain type, then you can define it yourself,
   1566 and it will automatically be used.
   1567 
   1568 
   1569 File: magit.info,  Node: Section Options,  Prev: Section Types and Values,  Up: Sections
   1570 
   1571 4.2.5 Section Options
   1572 ---------------------
   1573 
   1574 This section describes options that have an effect on more than just a
   1575 certain type of sections.  As you can see there are not many of those.
   1576 
   1577  -- User Option: magit-section-show-child-count
   1578      Whether to append the number of children to section headings.  This
   1579      only affects sections that could benefit from this information.
   1580 
   1581 
   1582 File: magit.info,  Node: Transient Commands,  Next: Transient Arguments and Buffer Variables,  Prev: Sections,  Up: Interface Concepts
   1583 
   1584 4.3 Transient Commands
   1585 ======================
   1586 
   1587 Many Magit commands are implemented as *transient* commands.  First the
   1588 user invokes a *prefix* command, which causes its *infix* arguments and
   1589 *suffix* commands to be displayed in the echo area.  The user then
   1590 optionally sets some infix arguments and finally invokes one of the
   1591 suffix commands.
   1592 
   1593    This is implemented in the library ‘transient’.  Earlier Magit
   1594 releases used the package ‘magit-popup’ and even earlier versions
   1595 library ‘magit-key-mode’.
   1596 
   1597    Transient is documented in *note (transient)Top::.
   1598 
   1599 ‘C-x M-g’ (‘magit-dispatch’)
   1600 ‘C-c g’ (‘magit-dispatch’)
   1601      This transient prefix command binds most of Magit’s other prefix
   1602      commands as suffix commands and displays them in a temporary buffer
   1603      until one of them is invoked.  Invoking such a sub-prefix causes
   1604      the suffixes of that command to be bound and displayed instead of
   1605      those of ‘magit-dispatch’.
   1606 
   1607      This command is also, or especially, useful outside Magit buffers,
   1608      so Magit by default binds it to ‘C-c M-g’ in the global keymap.
   1609      ‘C-c g’ would be a better binding, but we cannot use that by
   1610      default, because that key sequence is reserved for the user.  See
   1611      *note Global Bindings:: to learn more default and recommended key
   1612      bindings.
   1613 
   1614 
   1615 File: magit.info,  Node: Transient Arguments and Buffer Variables,  Next: Completion Confirmation and the Selection,  Prev: Transient Commands,  Up: Interface Concepts
   1616 
   1617 4.4 Transient Arguments and Buffer Variables
   1618 ============================================
   1619 
   1620 The infix arguments of many of Magit’s transient prefix commands cease
   1621 to have an effect once the ‘git’ command that is called with those
   1622 arguments has returned.  Commands that create a commit are a good
   1623 example for this.  If the user changes the arguments, then that only
   1624 affects the next invocation of a suffix command.  If the same transient
   1625 prefix command is later invoked again, then the arguments are initially
   1626 reset to the default value.  This default value can be set for the
   1627 current Emacs session or saved permanently, see *note (transient)Saving
   1628 Values::.  It is also possible to cycle through previously used sets of
   1629 arguments using ‘C-M-p’ and ‘C-M-n’, see *note (transient)Using
   1630 History::.
   1631 
   1632    However the infix arguments of many other transient commands continue
   1633 to have an effect even after the ‘git’ command that was called with
   1634 those arguments has returned.  The most important commands like this are
   1635 those that display a diff or log in a dedicated buffer.  Their arguments
   1636 obviously continue to have an effect for as long as the respective diff
   1637 or log is being displayed.  Furthermore the used arguments are stored in
   1638 buffer-local variables for future reference.
   1639 
   1640    For commands in the second group it isn’t always desirable to reset
   1641 their arguments to the global value when the transient prefix command is
   1642 invoked again.
   1643 
   1644    As mentioned above, it is possible to cycle through previously used
   1645 sets of arguments while a transient popup is visible.  That means that
   1646 we could always reset the infix arguments to the default because the set
   1647 of arguments that is active in the existing buffer is only a few ‘C-M-p’
   1648 away.  Magit can be configured to behave like that, but because I expect
   1649 that most users would not find that very convenient, it is not the
   1650 default.
   1651 
   1652    Also note that it is possible to change the diff and log arguments
   1653 used in the current buffer (including the status buffer, which contains
   1654 both diff and log sections) using the respective "refresh" transient
   1655 prefix commands on ‘D’ and ‘L’.  (‘d’ and ‘l’ on the other hand are
   1656 intended to change *what* diff or log is being displayed.  It is
   1657 possible to also change *how* the diff or log is being displayed at the
   1658 same time, but if you only want to do the latter, then you should use
   1659 the refresh variants.)  Because these secondary diff and log transient
   1660 prefixes are about *changing* the arguments used in the current buffer,
   1661 they *always* start out with the set of arguments that are currently in
   1662 effect in that buffer.
   1663 
   1664    Some commands are usually invoked directly even though they can also
   1665 be invoked as the suffix of a transient prefix command.  Most
   1666 prominently ‘magit-show-commit’ is usually invoked by typing ‘RET’ while
   1667 point is on a commit in a log, but it can also be invoked from the
   1668 ‘magit-diff’ transient prefix.
   1669 
   1670    When such a command is invoked directly, then it is important to
   1671 reuse the arguments as specified by the respective buffer-local values,
   1672 instead of using the default arguments.  Imagine you press ‘RET’ in a
   1673 log to display the commit at point in a different buffer and then use
   1674 ‘D’ to change how the diff is displayed in that buffer.  And then you
   1675 press ‘RET’ on another commit to show that instead and the diff
   1676 arguments are reset to the default.  Not cool; so Magit does not do that
   1677 by default.
   1678 
   1679  -- User Option: magit-prefix-use-buffer-arguments
   1680      This option controls whether the infix arguments initially shown in
   1681      certain transient prefix commands are based on the arguments that
   1682      are currently in effect in the buffer that their suffixes update.
   1683 
   1684      The ‘magit-diff’ and ‘magit-log’ transient prefix commands are
   1685      affected by this option.
   1686 
   1687  -- User Option: magit-direct-use-buffer-arguments
   1688      This option controls whether certain commands, when invoked
   1689      directly (i.e., not as the suffix of a transient prefix command),
   1690      use the arguments that are currently active in the buffer that they
   1691      are about to update.  The alternative is to use the default value
   1692      for these arguments, which might change the arguments that are used
   1693      in the buffer.
   1694 
   1695 Valid values for both of the above options are:
   1696 
   1697    • ‘always’: Always use the set of arguments that is currently active
   1698      in the respective buffer, provided that buffer exists of course.
   1699    • ‘selected’ or ‘t’: Use the set of arguments from the respective
   1700      buffer, but only if it is displayed in a window of the current
   1701      frame.  This is the default for both variables.
   1702    • ‘current’: Use the set of arguments from the respective buffer, but
   1703      only if it is the current buffer.
   1704    • ‘never’: Never use the set of arguments from the respective buffer.
   1705 
   1706 I am afraid it gets more complicated still:
   1707 
   1708    • The global diff and log arguments are set for each supported mode
   1709      individually.  The diff arguments for example have different values
   1710      in ‘magit-diff-mode’, ‘magit-revision-mode’,
   1711      ‘magit-merge-preview-mode’ and ‘magit-status-mode’ buffers.
   1712      Setting or saving the value for one mode does not change the value
   1713      for other modes.  The history however is shared.
   1714 
   1715    • When ‘magit-show-commit’ is invoked directly from a log buffer,
   1716      then the file filter is picked up from that buffer, not from the
   1717      revision buffer or the mode’s global diff arguments.
   1718 
   1719    • Even though they are suffixes of the diff prefix
   1720      ‘magit-show-commit’ and ‘magit-stash-show’ do not use the diff
   1721      buffer used by the diff commands, instead they use the dedicated
   1722      revision and stash buffers.
   1723 
   1724      At the time you invoke the diff prefix it is unknown to Magit which
   1725      of the suffix commands you are going to invoke.  While not certain,
   1726      more often than not users invoke one of the commands that use the
   1727      diff buffer, so the initial infix arguments are those used in that
   1728      buffer.  However if you invoke one of these commands directly, then
   1729      Magit knows that it should use the arguments from the revision
   1730      resp.  stash buffer.
   1731 
   1732    • The log prefix also features reflog commands, but these commands do
   1733      not use the log arguments.
   1734 
   1735    • If ‘magit-show-refs’ is invoked from a ‘magit-refs-mode’ buffer,
   1736      then it acts as a refresh prefix and therefore unconditionally uses
   1737      the buffer’s arguments as initial arguments.  If it is invoked
   1738      elsewhere with a prefix argument, then it acts as regular prefix
   1739      and therefore respects ‘magit-prefix-use-buffer-arguments’.  If it
   1740      is invoked elsewhere without a prefix argument, then it acts as a
   1741      direct command and therefore respects
   1742      ‘magit-direct-use-buffer-arguments’.
   1743 
   1744 
   1745 File: magit.info,  Node: Completion Confirmation and the Selection,  Next: Mouse Support,  Prev: Transient Arguments and Buffer Variables,  Up: Interface Concepts
   1746 
   1747 4.5 Completion, Confirmation and the Selection
   1748 ==============================================
   1749 
   1750 * Menu:
   1751 
   1752 * Action Confirmation::
   1753 * Completion and Confirmation::
   1754 * The Selection::
   1755 * The hunk-internal region::
   1756 * Support for Completion Frameworks::
   1757 * Additional Completion Options::
   1758 
   1759 
   1760 File: magit.info,  Node: Action Confirmation,  Next: Completion and Confirmation,  Up: Completion Confirmation and the Selection
   1761 
   1762 4.5.1 Action Confirmation
   1763 -------------------------
   1764 
   1765 By default many actions that could potentially lead to data loss have to
   1766 be confirmed.  This includes many very common actions, so this can
   1767 quickly become annoying.  Many of these actions can be undone and if you
   1768 have thought about how to undo certain mistakes, then it should be safe
   1769 to disable confirmation for the respective actions.
   1770 
   1771    The option ‘magit-no-confirm’ can be used to tell Magit to perform
   1772 certain actions without the user having to confirm them.  Note that
   1773 while this option can only be used to disable confirmation for a
   1774 specific set of actions, the next section explains another way of
   1775 telling Magit to ask fewer questions.
   1776 
   1777  -- User Option: magit-no-confirm
   1778      The value of this option is a list of symbols, representing actions
   1779      that do not have to be confirmed by the user before being carried
   1780      out.
   1781 
   1782      By default many potentially dangerous commands ask the user for
   1783      confirmation.  Each of the below symbols stands for an action
   1784      which, when invoked unintentionally or without being fully aware of
   1785      the consequences, could lead to tears.  In many cases there are
   1786      several commands that perform variations of a certain action, so we
   1787      don’t use the command names but more generic symbols.
   1788 
   1789         • Applying changes:
   1790 
   1791              • ‘discard’ Discarding one or more changes (i.e., hunks or
   1792                the complete diff for a file) loses that change,
   1793                obviously.
   1794 
   1795              • ‘reverse’ Reverting one or more changes can usually be
   1796                undone by reverting the reversion.
   1797 
   1798              • ‘stage-all-changes’, ‘unstage-all-changes’ When there are
   1799                both staged and unstaged changes, then un-/staging
   1800                everything would destroy that distinction.  Of course
   1801                that also applies when un-/staging a single change, but
   1802                then less is lost and one does that so often that having
   1803                to confirm every time would be unacceptable.
   1804 
   1805         • Files:
   1806 
   1807              • ‘delete’ When a file that isn’t yet tracked by Git is
   1808                deleted, then it is completely lost, not just the last
   1809                changes.  Very dangerous.
   1810 
   1811              • ‘trash’ Instead of deleting a file it can also be move to
   1812                the system trash.  Obviously much less dangerous than
   1813                deleting it.
   1814 
   1815                Also see option ‘magit-delete-by-moving-to-trash’.
   1816 
   1817              • ‘resurrect’ A deleted file can easily be resurrected by
   1818                "deleting" the deletion, which is done using the same
   1819                command that was used to delete the same file in the
   1820                first place.
   1821 
   1822              • ‘untrack’ Untracking a file can be undone by tracking it
   1823                again.
   1824 
   1825              • ‘rename’ Renaming a file can easily be undone.
   1826 
   1827         • Sequences:
   1828 
   1829              • ‘reset-bisect’ Aborting (known to Git as "resetting") a
   1830                bisect operation loses all information collected so far.
   1831 
   1832              • ‘abort-cherry-pick’ Aborting a cherry-pick throws away
   1833                all conflict resolutions which have already been carried
   1834                out by the user.
   1835 
   1836              • ‘abort-revert’ Aborting a revert throws away all conflict
   1837                resolutions which have already been carried out by the
   1838                user.
   1839 
   1840              • ‘abort-rebase’ Aborting a rebase throws away all already
   1841                modified commits, but it’s possible to restore those from
   1842                the reflog.
   1843 
   1844              • ‘abort-merge’ Aborting a merge throws away all conflict
   1845                resolutions which have already been carried out by the
   1846                user.
   1847 
   1848              • ‘merge-dirty’ Merging with a dirty worktree can make it
   1849                hard to go back to the state before the merge was
   1850                initiated.
   1851 
   1852         • References:
   1853 
   1854              • ‘delete-unmerged-branch’ Once a branch has been deleted,
   1855                it can only be restored using low-level recovery tools
   1856                provided by Git.  And even then the reflog is gone.  The
   1857                user always has to confirm the deletion of a branch by
   1858                accepting the default choice (or selecting another
   1859                branch), but when a branch has not been merged yet, also
   1860                make sure the user is aware of that.
   1861 
   1862              • ‘delete-pr-remote’ When deleting a branch that was
   1863                created from a pull-request and if no other branches
   1864                still exist on that remote, then ‘magit-branch-delete’
   1865                offers to delete the remote as well.  This should be safe
   1866                because it only happens if no other refs exist in the
   1867                remotes namespace, and you can recreate the remote if
   1868                necessary.
   1869 
   1870              • ‘drop-stashes’ Dropping a stash is dangerous because Git
   1871                stores stashes in the reflog.  Once a stash is removed,
   1872                there is no going back without using low-level recovery
   1873                tools provided by Git.  When a single stash is dropped,
   1874                then the user always has to confirm by accepting the
   1875                default (or selecting another).  This action only
   1876                concerns the deletion of multiple stashes at once.
   1877 
   1878         • Publishing:
   1879 
   1880              • ‘set-and-push’ When pushing to the upstream or the
   1881                push-remote and that isn’t actually configured yet, then
   1882                the user can first set the target.  If s/he confirms the
   1883                default too quickly, then s/he might end up pushing to
   1884                the wrong branch and if the remote repository is
   1885                configured to disallow fixing such mistakes, then that
   1886                can be quite embarrassing and annoying.
   1887 
   1888         • Edit published history:
   1889 
   1890           Without adding these symbols here, you will be warned before
   1891           editing commits that have already been pushed to one of the
   1892           branches listed in ‘magit-published-branches’.
   1893 
   1894              • ‘amend-published’ Affects most commands that amend to
   1895                "HEAD".
   1896 
   1897              • ‘rebase-published’ Affects commands that perform
   1898                interactive rebases.  This includes commands from the
   1899                commit transient that modify a commit other than "HEAD",
   1900                namely the various fixup and squash variants.
   1901 
   1902              • ‘edit-published’ Affects the commands
   1903                ‘magit-edit-line-commit’ and
   1904                ‘magit-diff-edit-hunk-commit’.  These two commands make
   1905                it quite easy to accidentally edit a published commit, so
   1906                you should think twice before configuring them not to ask
   1907                for confirmation.
   1908 
   1909           To disable confirmation completely, add all three symbols here
   1910           or set ‘magit-published-branches’ to ‘nil’.
   1911 
   1912         • Various:
   1913 
   1914              • ‘stash-apply-3way’ When a stash cannot be applied using
   1915                ‘git stash apply’, then Magit uses ‘git apply’ instead,
   1916                possibly using the ‘--3way’ argument, which isn’t always
   1917                perfectly safe.  See also ‘magit-stash-apply’.
   1918 
   1919              • ‘kill-process’ There seldom is a reason to kill a
   1920                process.
   1921 
   1922         • Global settings:
   1923 
   1924           Instead of adding all of the above symbols to the value of
   1925           this option, you can also set it to the atom ‘t’, which has
   1926           the same effect as adding all of the above symbols.  Doing
   1927           that most certainly is a bad idea, especially because other
   1928           symbols might be added in the future.  So even if you don’t
   1929           want to be asked for confirmation for any of these actions,
   1930           you are still better of adding all of the respective symbols
   1931           individually.
   1932 
   1933           When ‘magit-wip-before-change-mode’ is enabled, then the
   1934           following actions can be undone fairly easily: ‘discard’,
   1935           ‘reverse’, ‘stage-all-changes’, and ‘unstage-all-changes’.  If
   1936           and only if this mode is enabled, then ‘safe-with-wip’ has the
   1937           same effect as adding all of these symbols individually.
   1938 
   1939 
   1940 File: magit.info,  Node: Completion and Confirmation,  Next: The Selection,  Prev: Action Confirmation,  Up: Completion Confirmation and the Selection
   1941 
   1942 4.5.2 Completion and Confirmation
   1943 ---------------------------------
   1944 
   1945 Many Magit commands ask the user to select from a list of possible
   1946 things to act on, while offering the most likely choice as the default.
   1947 For many of these commands the default is the thing at point, provided
   1948 that it actually is a valid thing to act on.  For many commands that act
   1949 on a branch, the current branch serves as the default if there is no
   1950 branch at point.
   1951 
   1952    These commands combine asking for confirmation and asking for a
   1953 target to act on into a single action.  The user can confirm the default
   1954 target using ‘RET’ or abort using ‘C-g’.  This is similar to a
   1955 ‘y-or-n-p’ prompt, but the keys to confirm or abort differ.
   1956 
   1957    At the same time the user is also given the opportunity to select
   1958 another target, which is useful because for some commands and/or in some
   1959 situations you might want to select the action before selecting the
   1960 target by moving to it.
   1961 
   1962    However you might find that for some commands you always want to use
   1963 the default target, if any, or even that you want the command to act on
   1964 the default without requiring any confirmation at all.  The option
   1965 ‘magit-dwim-selection’ can be used to configure certain commands to that
   1966 effect.
   1967 
   1968    Note that when the region is active then many commands act on the
   1969 things that are selected using a mechanism based on the region, in many
   1970 cases after asking for confirmation.  This region-based mechanism is
   1971 called the "selection" and is described in detail in the next section.
   1972 When a selection exists that is valid for the invoked command, then that
   1973 command never offers to act on something else, and whether it asks for
   1974 confirmation is not controlled by this option.
   1975 
   1976    Also note that Magit asks for confirmation of certain actions that
   1977 are not coupled with completion (or the selection).  Such dialogs are
   1978 also not affected by this option and are described in the previous
   1979 section.
   1980 
   1981  -- User Option: magit-dwim-selection
   1982    This option can be used to tell certain commands to use the thing at
   1983 point instead of asking the user to select a candidate to act on, with
   1984 or without confirmation.
   1985 
   1986    The value has the form ‘((COMMAND nil|PROMPT DEFAULT)...)’.
   1987 
   1988    • COMMAND is the command that should not prompt for a choice.  To
   1989      have an effect, the command has to use the function
   1990      ‘magit-completing-read’ or a utility function which in turn uses
   1991      that function.
   1992 
   1993    • If the command uses ‘magit-completing-read’ multiple times, then
   1994      PROMPT can be used to only affect one of these uses.  PROMPT, if
   1995      non-nil, is a regular expression that is used to match against the
   1996      PROMPT argument passed to ‘magit-completing-read’.
   1997 
   1998    • DEFAULT specifies how to use the default.  If it is ‘t’, then the
   1999      DEFAULT argument passed to ‘magit-completing-read’ is used without
   2000      confirmation.  If it is ‘ask’, then the user is given a chance to
   2001      abort.  DEFAULT can also be ‘nil’, in which case the entry has no
   2002      effect.
   2003 
   2004 
   2005 File: magit.info,  Node: The Selection,  Next: The hunk-internal region,  Prev: Completion and Confirmation,  Up: Completion Confirmation and the Selection
   2006 
   2007 4.5.3 The Selection
   2008 -------------------
   2009 
   2010 If the region is active, then many Magit commands act on the things that
   2011 are selected using a mechanism based on the region instead of one single
   2012 thing.  When the region is not active, then these commands act on the
   2013 thing at point or read a single thing to act on.  This is described in
   2014 the previous section — this section only covers how multiple things are
   2015 selected, how that is visualized, and how certain commands behave when
   2016 that is the case.
   2017 
   2018    Magit’s mechanism for selecting multiple things, or rather sections
   2019 that represent these things, is based on the Emacs region, but the area
   2020 that Magit considers to be selected is typically larger than the region
   2021 and additional restrictions apply.
   2022 
   2023    Magit makes a distinction between a region that qualifies as forming
   2024 a valid Magit selection and a region that does not.  If the region does
   2025 not qualify, then it is displayed as it is in other Emacs buffers.  If
   2026 the region does qualify as a Magit selection, then the selection is
   2027 always visualized, while the region itself is only visualized if it
   2028 begins and ends on the same line.
   2029 
   2030    For a region to qualify as a Magit selection, it must begin in the
   2031 heading of one section and end in the heading of a sibling section.
   2032 Note that if the end of the region is at the very beginning of section
   2033 heading (i.e., at the very beginning of a line) then that section is
   2034 considered to be *inside* the selection.
   2035 
   2036    This is not consistent with how the region is normally treated in
   2037 Emacs — if the region ends at the beginning of a line, then that line is
   2038 outside the region.  Due to how Magit visualizes the selection, it
   2039 should be obvious that this difference exists.
   2040 
   2041    Not every command acts on every valid selection.  Some commands do
   2042 not even consider the location of point, others may act on the section
   2043 at point but not support acting on the selection, and even commands that
   2044 do support the selection of course only do so if it selects things that
   2045 they can act on.
   2046 
   2047    This is the main reason why the selection must include the section at
   2048 point.  Even if a selection exists, the invoked command may disregard
   2049 it, in which case it may act on the current section only.  It is much
   2050 safer to only act on the current section but not the other selected
   2051 sections than it is to act on the current section *instead* of the
   2052 selected sections.  The latter would be much more surprising and if the
   2053 current section always is part of the selection, then that cannot
   2054 happen.
   2055 
   2056  -- Variable: magit-keep-region-overlay
   2057      This variable controls whether the region is visualized as usual
   2058      even when a valid Magit selection or a hunk-internal region exists.
   2059      See the doc-string for more information.
   2060 
   2061 
   2062 File: magit.info,  Node: The hunk-internal region,  Next: Support for Completion Frameworks,  Prev: The Selection,  Up: Completion Confirmation and the Selection
   2063 
   2064 4.5.4 The hunk-internal region
   2065 ------------------------------
   2066 
   2067 Somewhat related to the Magit selection described in the previous
   2068 section is the hunk-internal region.
   2069 
   2070    Like the selection, the hunk-internal region is based on the Emacs
   2071 region but causes that region to not be visualized as it would in other
   2072 Emacs buffers, and includes the line on which the region ends even if it
   2073 ends at the very beginning of that line.
   2074 
   2075    Unlike the selection, which is based on a region that must begin in
   2076 the heading of one section and ends in the section of a sibling section,
   2077 the hunk-internal region must begin inside the *body* of a hunk section
   2078 and end in the body of the *same* section.
   2079 
   2080    The hunk-internal region is honored by "apply" commands, which can,
   2081 among other targets, act on a hunk.  If the hunk-internal region is
   2082 active, then such commands act only on the marked part of the hunk
   2083 instead of on the complete hunk.
   2084 
   2085 
   2086 File: magit.info,  Node: Support for Completion Frameworks,  Next: Additional Completion Options,  Prev: The hunk-internal region,  Up: Completion Confirmation and the Selection
   2087 
   2088 4.5.5 Support for Completion Frameworks
   2089 ---------------------------------------
   2090 
   2091 The built-in option ‘completing-read-function’ specifies the low-level
   2092 function used by ‘completing-read’ to ask a user to select from a list
   2093 of choices.  Its default value is ‘completing-read-default’.
   2094 Alternative completion frameworks typically activate themselves by
   2095 substituting their own implementation.
   2096 
   2097    Mostly for historic reasons Magit provides a similar option named
   2098 ‘magit-completing-read-function’, which only controls the low-level
   2099 function used by ‘magit-completing-read’.  This option also makes it
   2100 possible to use a different completing mechanism for Magit than for the
   2101 rest of Emacs, but doing that is not recommend.
   2102 
   2103    You most likely don’t have to customize the magit-specific option to
   2104 use an alternative completion framework.  For example, if you enable
   2105 ‘ivy-mode’, then Magit will respect that, and if you enable ‘helm-mode’,
   2106 then you are done too.
   2107 
   2108    However if you want to use Ido, then ‘ido-mode’ won’t do the trick.
   2109 You will also have to install the ‘ido-completing-read+’ package and use
   2110 ‘magit-ido-completing-read’ as ‘magit-completing-read-function’.
   2111 
   2112  -- User Option: magit-completing-read-function
   2113      The value of this variable is the low-level function used to
   2114      perform completion by code that uses ‘magit-completing-read’ (as
   2115      opposed to the built-in ‘completing-read’).
   2116 
   2117      The default value, ‘magit-builtin-completing-read’, is suitable for
   2118      the standard completion mechanism, ‘ivy-mode’, and ‘helm-mode’ at
   2119      least.
   2120 
   2121      The built-in ‘completing-read’ and ‘completing-read-default’ are
   2122      *not* suitable to be used here.  ‘magit-builtin-completing-read’
   2123      performs some additional work, and any function used in its place
   2124      has to do the same.
   2125 
   2126  -- Function: magit-builtin-completing-read prompt choices &optional
   2127           predicate require-match initial-input hist def
   2128      This function performs completion using the built-in
   2129      ‘completing-read’ and does some additional magit-specific work.
   2130 
   2131  -- Function: magit-ido-completing-read prompt choices &optional
   2132           predicate require-match initial-input hist def
   2133      This function performs completion using ‘ido-completing-read+’ from
   2134      the package by the same name (which you have to explicitly install)
   2135      and does some additional magit-specific work.
   2136 
   2137      We have to use ‘ido-completing-read+’ instead of the
   2138      ‘ido-completing-read’ that comes with Ido itself, because the
   2139      latter, while intended as a drop-in replacement, cannot serve that
   2140      purpose because it violates too many of the implicit conventions.
   2141 
   2142  -- Function: magit-completing-read prompt choices &optional predicate
   2143           require-match initial-input hist def fallback
   2144      This is the function that Magit commands use when they need the
   2145      user to select a single thing to act on.  The arguments have the
   2146      same meaning as for ‘completing-read’, except for FALLBACK, which
   2147      is unique to this function and is described below.
   2148 
   2149      Instead of asking the user to choose from a list of possible
   2150      candidates, this function may just return the default specified by
   2151      DEF, with or without requiring user confirmation.  Whether that is
   2152      the case depends on PROMPT, ‘this-command’ and
   2153      ‘magit-dwim-selection’.  See the documentation of the latter for
   2154      more information.
   2155 
   2156      If it does read a value in the minibuffer, then this function acts
   2157      similar to ‘completing-read’, except for the following:
   2158 
   2159         • COLLECTION must be a list of choices.  A function is not
   2160           supported.
   2161 
   2162         • If REQUIRE-MATCH is ‘nil’ and the user exits without a choice,
   2163           then ‘nil’ is returned instead of an empty string.
   2164 
   2165         • If REQUIRE-MATCH is non-nil and the users exits without a
   2166           choice, an user-error is raised.
   2167 
   2168         • FALLBACK specifies a secondary default that is only used if
   2169           the primary default DEF is ‘nil’.  The secondary default is
   2170           not subject to ‘magit-dwim-selection’ — if DEF is ‘nil’ but
   2171           FALLBACK is not, then this function always asks the user to
   2172           choose a candidate, just as if both defaults were ‘nil’.
   2173 
   2174         • ‘format-prompt’ is called on PROMPT and DEF (or FALLBACK if
   2175           DEF is ‘nil’).  This appends ": " to the prompt and may also
   2176           add the default to the prompt, using the format specified by
   2177           ‘minibuffer-default-prompt-format’ and depending on
   2178           ‘magit-completing-read-default-prompt-predicate’.
   2179 
   2180 
   2181 File: magit.info,  Node: Additional Completion Options,  Prev: Support for Completion Frameworks,  Up: Completion Confirmation and the Selection
   2182 
   2183 4.5.6 Additional Completion Options
   2184 -----------------------------------
   2185 
   2186  -- User Option: magit-list-refs-sortby
   2187      For many commands that read a ref or refs from the user, the value
   2188      of this option can be used to control the order of the refs.  Valid
   2189      values include any key accepted by the ‘--sort’ flag of ‘git
   2190      for-each-ref’.  By default, refs are sorted alphabetically by their
   2191      full name (e.g., "refs/heads/master").
   2192 
   2193 
   2194 File: magit.info,  Node: Mouse Support,  Next: Running Git,  Prev: Completion Confirmation and the Selection,  Up: Interface Concepts
   2195 
   2196 4.6 Mouse Support
   2197 =================
   2198 
   2199 Double clicking on a section heading toggles the visibility of its body,
   2200 if any.  Likewise clicking in the left fringe toggles the visibility of
   2201 the appropriate section.
   2202 
   2203    A context menu is provided but has to be enabled explicitly.  In
   2204 Emacs 28 and greater, enable the global mode ‘context-menu-mode’.  If
   2205 you use an older Emacs release, set
   2206 ‘magit-section-show-context-menu-for-emacs<28’.
   2207 
   2208 
   2209 File: magit.info,  Node: Running Git,  Prev: Mouse Support,  Up: Interface Concepts
   2210 
   2211 4.7 Running Git
   2212 ===============
   2213 
   2214 * Menu:
   2215 
   2216 * Viewing Git Output::
   2217 * Git Process Status::
   2218 * Running Git Manually::
   2219 * Git Executable::
   2220 * Global Git Arguments::
   2221 
   2222 
   2223 File: magit.info,  Node: Viewing Git Output,  Next: Git Process Status,  Up: Running Git
   2224 
   2225 4.7.1 Viewing Git Output
   2226 ------------------------
   2227 
   2228 Magit runs Git either for side-effects (e.g., when pushing) or to get
   2229 some value (e.g., the name of the current branch).
   2230 
   2231    When Git is run for side-effects, the process output is logged in a
   2232 per-repository log buffer, which can be consulted using the
   2233 ‘magit-process’ command when things don’t go as expected.
   2234 
   2235    The output/errors for up to ‘magit-process-log-max’ Git commands are
   2236 retained.
   2237 
   2238 ‘$’ (‘magit-process’)
   2239      This commands displays the process buffer for the current
   2240      repository.
   2241 
   2242    Inside that buffer, the usual key bindings for navigating and showing
   2243 sections are available.  There is one additional command.
   2244 
   2245 ‘k’ (‘magit-process-kill’)
   2246      This command kills the process represented by the section at point.
   2247 
   2248  -- Variable: magit-git-debug
   2249      This option controls whether additional reporting of git errors is
   2250      enabled.
   2251 
   2252      Magit basically calls git for one of these two reasons: for
   2253      side-effects or to do something with its standard output.
   2254 
   2255      When git is run for side-effects then its output, including error
   2256      messages, go into the process buffer which is shown when using ‘$’.
   2257 
   2258      When git’s output is consumed in some way, then it would be too
   2259      expensive to also insert it into this buffer, but when this option
   2260      is non-nil and git returns with a non-zero exit status, then at
   2261      least its standard error is inserted into this buffer.
   2262 
   2263      This is only intended for debugging purposes.  Do not enable this
   2264      permanently, that would negatively affect performance.
   2265 
   2266      This is only intended for debugging purposes.  Do not enable this
   2267      permanently, that would negatively affect performance.  Also note
   2268      that just because git exits with a non-zero exit status and prints
   2269      an error message that usually doesn’t mean that it is an error as
   2270      far as Magit is concerned, which is another reason we usually hide
   2271      these error messages.  Whether some error message is relevant in
   2272      the context of some unexpected behavior has to be judged on a case
   2273      by case basis.
   2274 
   2275      The command ‘magit-toggle-git-debug’ changes the value of this
   2276      variable.
   2277 
   2278  -- Variable: magit-process-extreme-logging
   2279      This option controls whether ‘magit-process-file’ logs to the
   2280      ‘*Messages*’ buffer.
   2281 
   2282      Only intended for temporary use when you try to figure out how
   2283      Magit uses Git behind the scene.  Output that normally goes to the
   2284      magit-process buffer continues to go there.  Not all output goes to
   2285      either of these two buffers.
   2286 
   2287 
   2288 File: magit.info,  Node: Git Process Status,  Next: Running Git Manually,  Prev: Viewing Git Output,  Up: Running Git
   2289 
   2290 4.7.2 Git Process Status
   2291 ------------------------
   2292 
   2293 When a Git process is running for side-effects, Magit displays an
   2294 indicator in the mode line, using the ‘magit-mode-line-process’ face.
   2295 
   2296    If the Git process exits successfully, the process indicator is
   2297 removed from the mode line immediately.
   2298 
   2299    In the case of a Git error, the process indicator is not removed, but
   2300 is instead highlighted with the ‘magit-mode-line-process-error’ face,
   2301 and the error details from the process buffer are provided as a tooltip
   2302 for mouse users.  This error indicator persists in the mode line until
   2303 the next magit buffer refresh.
   2304 
   2305    If you do not wish process errors to be indicated in the mode line,
   2306 customize the ‘magit-process-display-mode-line-error’ user option.
   2307 
   2308    Process errors are additionally indicated at the top of the status
   2309 buffer.
   2310 
   2311 
   2312 File: magit.info,  Node: Running Git Manually,  Next: Git Executable,  Prev: Git Process Status,  Up: Running Git
   2313 
   2314 4.7.3 Running Git Manually
   2315 --------------------------
   2316 
   2317 While Magit provides many Emacs commands to interact with Git, it does
   2318 not cover everything.  In those cases your existing Git knowledge will
   2319 come in handy.  Magit provides some commands for running arbitrary Git
   2320 commands by typing them into the minibuffer, instead of having to switch
   2321 to a shell.
   2322 
   2323 ‘!’ (‘magit-run’)
   2324      This transient prefix command binds the following suffix commands
   2325      and displays them in a temporary buffer until a suffix is invoked.
   2326 
   2327 ‘! !’ (‘magit-git-command-topdir’)
   2328      This command reads a command from the user and executes it in the
   2329      top-level directory of the current working tree.
   2330 
   2331      The string "git " is used as initial input when prompting the user
   2332      for the command.  It can be removed to run another command.
   2333 
   2334 ‘:’ (‘magit-git-command’)
   2335 ‘! p’
   2336      This command reads a command from the user and executes it in
   2337      ‘default-directory’.  With a prefix argument the command is
   2338      executed in the top-level directory of the current working tree
   2339      instead.
   2340 
   2341      The string "git " is used as initial input when prompting the user
   2342      for the command.  It can be removed to run another command.
   2343 
   2344 ‘! s’ (‘magit-shell-command-topdir’)
   2345      This command reads a command from the user and executes it in the
   2346      top-level directory of the current working tree.
   2347 
   2348 ‘! S’ (‘magit-shell-command’)
   2349      This command reads a command from the user and executes it in
   2350      ‘default-directory’.  With a prefix argument the command is
   2351      executed in the top-level directory of the current working tree
   2352      instead.
   2353 
   2354  -- User Option: magit-shell-command-verbose-prompt
   2355      Whether the prompt, used by the above commands when reading a shell
   2356      command, shows the directory in which it will be run.
   2357 
   2358    These suffix commands start external gui tools.
   2359 
   2360 ‘! k’ (‘magit-run-gitk’)
   2361      This command runs ‘gitk’ in the current repository.
   2362 
   2363 ‘! a’ (‘magit-run-gitk-all’)
   2364      This command runs ‘gitk --all’ in the current repository.
   2365 
   2366 ‘! b’ (‘magit-run-gitk-branches’)
   2367      This command runs ‘gitk --branches’ in the current repository.
   2368 
   2369 ‘! g’ (‘magit-run-git-gui’)
   2370      This command runs ‘git gui’ in the current repository.
   2371 
   2372 ‘! m’ (‘magit-git-mergetool’)
   2373      This command runs ‘git mergetool --gui’ in the current repository.
   2374 
   2375      With a prefix argument this acts as a transient prefix command,
   2376      allowing the user to select the mergetool and change some settings.
   2377 
   2378 
   2379 File: magit.info,  Node: Git Executable,  Next: Global Git Arguments,  Prev: Running Git Manually,  Up: Running Git
   2380 
   2381 4.7.4 Git Executable
   2382 --------------------
   2383 
   2384 When Magit calls Git, then it may do so using the absolute path to the
   2385 ‘git’ executable, or using just its name.
   2386 
   2387    When running ‘git’ locally and the ‘system-type’ is ‘windows-nt’ (any
   2388 Windows version) or ‘darwin’ (macOS) then ‘magit-git-executable’ is set
   2389 to an absolute path when Magit is loaded.
   2390 
   2391    On Windows it is necessary to use an absolute path because Git comes
   2392 with several wrapper scripts for the actual ‘git’ binary, which are also
   2393 placed on ‘$PATH’, and using one of these wrappers instead of the binary
   2394 would degrade performance horribly.  For some macOS users using just the
   2395 name of the executable also performs horribly, so we avoid doing that on
   2396 that platform as well.  On other platforms, using just the name seems to
   2397 work just fine.
   2398 
   2399    Using an absolute path when running ‘git’ on a remote machine over
   2400 Tramp, would be problematic to use an absolute path that is suitable on
   2401 the local machine, so a separate option is used to control the name or
   2402 path that is used on remote machines.
   2403 
   2404  -- User Option: magit-git-executable
   2405      The ‘git’ executable used by Magit on the local host.  This should
   2406      be either the absolute path to the executable, or the string "git"
   2407      to let Emacs find the executable itself, using the standard
   2408      mechanism for doing such things.
   2409 
   2410  -- User Option: magit-remote-git-executable
   2411      The ‘git’ executable used by Magit on remote machines over Tramp.
   2412      Normally this should be just the string "git".  Consider
   2413      customizing ‘tramp-remote-path’ instead of this option.
   2414 
   2415    If Emacs is unable to find the correct executable, then you can work
   2416 around that by explicitly setting the value of one of these two options.
   2417 Doing that should be considered a kludge; it is better to make sure that
   2418 the order in ‘exec-path’ or ‘tramp-remote-path’ is correct.
   2419 
   2420    Note that ‘exec-path’ is set based on the value of the ‘PATH’
   2421 environment variable that is in effect when Emacs is started.  If you
   2422 set ‘PATH’ in your shell’s init files, then that only has an effect on
   2423 Emacs if you start it from that shell (because the environment of a
   2424 process is only passed to its child processes, not to arbitrary other
   2425 processes).  If that is not how you start Emacs, then the
   2426 ‘exec-path-from-shell’ package can help; though honestly I consider that
   2427 a kludge too.
   2428 
   2429    The command ‘magit-debug-git-executable’ can be useful to find out
   2430 where Emacs is searching for ‘git’.
   2431 
   2432 ‘M-x magit-debug-git-executable’
   2433      This command displays a buffer with information about
   2434      ‘magit-git-executable’ and ‘magit-remote-git-executable’.
   2435 
   2436 ‘M-x magit-version’
   2437      This command shows the currently used versions of Magit, Git, and
   2438      Emacs in the echo area.  Non-interactively this just returns the
   2439      Magit version.
   2440 
   2441 
   2442 File: magit.info,  Node: Global Git Arguments,  Prev: Git Executable,  Up: Running Git
   2443 
   2444 4.7.5 Global Git Arguments
   2445 --------------------------
   2446 
   2447  -- User Option: magit-git-global-arguments
   2448      The arguments set here are used every time the git executable is
   2449      run as a subprocess.  They are placed right after the executable
   2450      itself and before the git command - as in ‘git HERE... COMMAND
   2451      REST’.  For valid arguments see *note (gitman)git::.
   2452 
   2453      Be careful what you add here, especially if you are using Tramp to
   2454      connect to servers with ancient Git versions.  Never remove
   2455      anything that is part of the default value, unless you really know
   2456      what you are doing.  And think very hard before adding something;
   2457      it will be used every time Magit runs Git for any purpose.
   2458 
   2459 
   2460 File: magit.info,  Node: Inspecting,  Next: Manipulating,  Prev: Interface Concepts,  Up: Top
   2461 
   2462 5 Inspecting
   2463 ************
   2464 
   2465 The functionality provided by Magit can be roughly divided into three
   2466 groups: inspecting existing data, manipulating existing data or adding
   2467 new data, and transferring data.  Of course that is a rather crude
   2468 distinction that often falls short, but it’s more useful than no
   2469 distinction at all.  This section is concerned with inspecting data, the
   2470 next two with manipulating and transferring it.  Then follows a section
   2471 about miscellaneous functionality, which cannot easily be fit into this
   2472 distinction.
   2473 
   2474    Of course other distinctions make sense too, e.g., Git’s distinction
   2475 between porcelain and plumbing commands, which for the most part is
   2476 equivalent to Emacs’ distinction between interactive commands and
   2477 non-interactive functions.  All of the sections mentioned before are
   2478 mainly concerned with the porcelain – Magit’s plumbing layer is
   2479 described later.
   2480 
   2481 * Menu:
   2482 
   2483 * Status Buffer::
   2484 * Repository List::
   2485 * Logging::
   2486 * Diffing::
   2487 * Ediffing::
   2488 * References Buffer::
   2489 * Bisecting::
   2490 * Visiting Files and Blobs::
   2491 * Blaming::
   2492 
   2493 
   2494 File: magit.info,  Node: Status Buffer,  Next: Repository List,  Up: Inspecting
   2495 
   2496 5.1 Status Buffer
   2497 =================
   2498 
   2499 While other Magit buffers contain, e.g., one particular diff or one
   2500 particular log, the status buffer contains the diffs for staged and
   2501 unstaged changes, logs for unpushed and unpulled commits, lists of
   2502 stashes and untracked files, and information related to the current
   2503 branch.
   2504 
   2505    During certain incomplete operations – for example when a merge
   2506 resulted in a conflict – additional information is displayed that helps
   2507 proceeding with or aborting the operation.
   2508 
   2509    The command ‘magit-status’ displays the status buffer belonging to
   2510 the current repository in another window.  This command is used so often
   2511 that it should be bound globally.  We recommend using ‘C-x g’:
   2512 
   2513      (global-set-key (kbd "C-x g") 'magit-status)
   2514 
   2515 ‘C-x g’ (‘magit-status’)
   2516      When invoked from within an existing Git repository, then this
   2517      command shows the status of that repository in a buffer.
   2518 
   2519      If the current directory isn’t located within a Git repository,
   2520      then this command prompts for an existing repository or an
   2521      arbitrary directory, depending on the option
   2522      ‘magit-repository-directories’, and the status for the selected
   2523      repository is shown instead.
   2524 
   2525         • If that option specifies any existing repositories, then the
   2526           user is asked to select one of them.
   2527 
   2528         • Otherwise the user is asked to select an arbitrary directory
   2529           using regular file-name completion.  If the selected directory
   2530           is the top-level directory of an existing working tree, then
   2531           the status buffer for that is shown.
   2532 
   2533         • Otherwise the user is offered to initialize the selected
   2534           directory as a new repository.  After creating the repository
   2535           its status buffer is shown.
   2536 
   2537      These fallback behaviors can also be forced using one or more
   2538      prefix arguments:
   2539 
   2540         • With two prefix arguments (or more precisely a numeric prefix
   2541           value of 16 or greater) an arbitrary directory is read, which
   2542           is then acted on as described above.  The same could be
   2543           accomplished using the command ‘magit-init’.
   2544 
   2545         • With a single prefix argument an existing repository is read
   2546           from the user, or if no repository can be found based on the
   2547           value of ‘magit-repository-directories’, then the behavior is
   2548           the same as with two prefix arguments.
   2549 
   2550  -- User Option: magit-repository-directories
   2551      List of directories that are Git repositories or contain Git
   2552      repositories.
   2553 
   2554      Each element has the form ‘(DIRECTORY . DEPTH)’.  DIRECTORY has to
   2555      be a directory or a directory file-name, a string.  DEPTH, an
   2556      integer, specifies the maximum depth to look for Git repositories.
   2557      If it is 0, then only add DIRECTORY itself.
   2558 
   2559      This option controls which repositories are being listed by
   2560      ‘magit-list-repositories’.  It also affects ‘magit-status’ (which
   2561      see) in potentially surprising ways (see above).
   2562 
   2563  -- Command: magit-status-quick
   2564      This command is an alternative to ‘magit-status’ that usually
   2565      avoids refreshing the status buffer.
   2566 
   2567      If the status buffer of the current Git repository exists but isn’t
   2568      being displayed in the selected frame, then it is displayed without
   2569      being refreshed.
   2570 
   2571      If the status buffer is being displayed in the selected frame, then
   2572      this command refreshes it.
   2573 
   2574      Prefix arguments have the same meaning as for ‘magit-status’, and
   2575      additionally cause the buffer to be refresh.
   2576 
   2577      To use this command add this to your init file:
   2578 
   2579           (global-set-key (kbd "C-x g") 'magit-status-quick).
   2580 
   2581      If you do that and then for once want to redisplay the buffer and
   2582      also immediately refresh it, then type ‘C-x g’ followed by ‘g’.
   2583 
   2584      A possible alternative command is
   2585      ‘magit-display-repository-buffer’.  It supports displaying any
   2586      existing Magit buffer that belongs to the current repository; not
   2587      just the status buffer.
   2588 
   2589  -- Command: ido-enter-magit-status
   2590      From an Ido prompt used to open a file, instead drop into
   2591      ‘magit-status’.  This is similar to ‘ido-magic-delete-char’, which,
   2592      despite its name, usually causes a Dired buffer to be created.
   2593 
   2594      To make this command available, use something like:
   2595 
   2596           (add-hook 'ido-setup-hook
   2597                     (lambda ()
   2598                       (define-key ido-completion-map
   2599                         (kbd \"C-x g\") 'ido-enter-magit-status)))
   2600 
   2601      Starting with Emacs 25.1 the Ido keymaps are defined just once
   2602      instead of every time Ido is invoked, so now you can modify it like
   2603      pretty much every other keymap:
   2604 
   2605           (define-key ido-common-completion-map
   2606             (kbd \"C-x g\") 'ido-enter-magit-status)
   2607 
   2608 * Menu:
   2609 
   2610 * Status Sections::
   2611 * Status Header Sections::
   2612 * Status Module Sections::
   2613 * Status Options::
   2614 
   2615 
   2616 File: magit.info,  Node: Status Sections,  Next: Status Header Sections,  Up: Status Buffer
   2617 
   2618 5.1.1 Status Sections
   2619 ---------------------
   2620 
   2621 The contents of status buffers is controlled using the hook
   2622 ‘magit-status-sections-hook’.  See *note Section Hooks:: to learn about
   2623 such hooks and how to customize them.
   2624 
   2625  -- User Option: magit-status-sections-hook
   2626      Hook run to insert sections into a status buffer.
   2627 
   2628    The first function on that hook by default is
   2629 ‘magit-insert-status-headers’; it is described in the next section.  By
   2630 default the following functions are also members of that hook:
   2631 
   2632  -- Function: magit-insert-merge-log
   2633      Insert section for the on-going merge.  Display the heads that are
   2634      being merged.  If no merge is in progress, do nothing.
   2635 
   2636  -- Function: magit-insert-rebase-sequence
   2637      Insert section for the on-going rebase sequence.  If no such
   2638      sequence is in progress, do nothing.
   2639 
   2640  -- Function: magit-insert-am-sequence
   2641      Insert section for the on-going patch applying sequence.  If no
   2642      such sequence is in progress, do nothing.
   2643 
   2644  -- Function: magit-insert-sequencer-sequence
   2645      Insert section for the on-going cherry-pick or revert sequence.  If
   2646      no such sequence is in progress, do nothing.
   2647 
   2648  -- Function: magit-insert-bisect-output
   2649      While bisecting, insert section with output from ‘git bisect’.
   2650 
   2651  -- Function: magit-insert-bisect-rest
   2652      While bisecting, insert section visualizing the bisect state.
   2653 
   2654  -- Function: magit-insert-bisect-log
   2655      While bisecting, insert section logging bisect progress.
   2656 
   2657  -- Function: magit-insert-untracked-files
   2658      Maybe insert a list or tree of untracked files.
   2659 
   2660      Do so depending on the value of ‘status.showUntrackedFiles’.  Note
   2661      that even if the value is ‘all’, Magit still initially only shows
   2662      directories.  But the directory sections can then be expanded using
   2663      ‘TAB’.
   2664 
   2665  -- Function: magit-insert-unstaged-changes
   2666      Insert section showing unstaged changes.
   2667 
   2668  -- Function: magit-insert-staged-changes
   2669      Insert section showing staged changes.
   2670 
   2671  -- Function: magit-insert-stashes &optional ref heading
   2672      Insert the ‘stashes’ section showing reflog for "refs/stash".  If
   2673      optional REF is non-nil show reflog for that instead.  If optional
   2674      HEADING is non-nil use that as section heading instead of
   2675      "Stashes:".
   2676 
   2677  -- Function: magit-insert-unpulled-from-upstream
   2678      Insert section showing commits that haven’t been pulled from the
   2679      upstream branch yet.
   2680 
   2681  -- Function: magit-insert-unpulled-from-pushremote
   2682      Insert section showing commits that haven’t been pulled from the
   2683      push-remote branch yet.
   2684 
   2685  -- Function: magit-insert-unpushed-to-upstream
   2686      Insert section showing commits that haven’t been pushed to the
   2687      upstream yet.
   2688 
   2689  -- Function: magit-insert-unpushed-to-pushremote
   2690      Insert section showing commits that haven’t been pushed to the
   2691      push-remote yet.
   2692 
   2693    The following functions can also be added to the above hook:
   2694 
   2695  -- Function: magit-insert-tracked-files
   2696      Insert a tree of tracked files.
   2697 
   2698  -- Function: magit-insert-ignored-files
   2699      Insert a tree of ignored files.  Its possible to limit the logs in
   2700      the current buffer to a certain directory using ‘D = f <DIRECTORY>
   2701      RET g’.  If you do that, then that that also affects this command.
   2702 
   2703      The log filter can be used to limit to multiple files.  In that
   2704      case this function only respects the first of the files and only if
   2705      it is a directory.
   2706 
   2707  -- Function: magit-insert-skip-worktree-files
   2708      Insert a tree of skip-worktree files.  If the first element of
   2709      ‘magit-buffer-diff-files’ is a directory, then limit the list to
   2710      files below that.  The value of that variable can be set using ‘D
   2711      -- DIRECTORY RET g’.
   2712 
   2713  -- Function: magit-insert-assumed-unchanged-files
   2714      Insert a tree of files that are assumed to be unchanged.  If the
   2715      first element of ‘magit-buffer-diff-files’ is a directory, then
   2716      limit the list to files below that.  The value of that variable can
   2717      be set using ‘D -- DIRECTORY RET g’.
   2718 
   2719  -- Function: magit-insert-unpulled-or-recent-commits
   2720      Insert section showing unpulled or recent commits.  If an upstream
   2721      is configured for the current branch and it is ahead of the current
   2722      branch, then show the missing commits.  Otherwise, show the last
   2723      ‘magit-log-section-commit-count’ commits.
   2724 
   2725  -- Function: magit-insert-recent-commits
   2726      Insert section showing the last ‘magit-log-section-commit-count’
   2727      commits.
   2728 
   2729  -- User Option: magit-log-section-commit-count
   2730      How many recent commits ‘magit-insert-recent-commits’ and
   2731      ‘magit-insert-unpulled-or-recent-commits’ (provided there are no
   2732      unpulled commits) show.
   2733 
   2734  -- Function: magit-insert-unpulled-cherries
   2735      Insert section showing unpulled commits.  Like
   2736      ‘magit-insert-unpulled-commits’ but prefix each commit that has not
   2737      been applied yet (i.e., a commit with a patch-id not shared with
   2738      any local commit) with "+", and all others with "-".
   2739 
   2740  -- Function: magit-insert-unpushed-cherries
   2741      Insert section showing unpushed commits.  Like
   2742      ‘magit-insert-unpushed-commits’ but prefix each commit which has
   2743      not been applied to upstream yet (i.e., a commit with a patch-id
   2744      not shared with any upstream commit) with "+" and all others with
   2745      "-".
   2746 
   2747    See *note References Buffer:: for some more section inserters, which
   2748 could be used here.
   2749 
   2750 
   2751 File: magit.info,  Node: Status Header Sections,  Next: Status Module Sections,  Prev: Status Sections,  Up: Status Buffer
   2752 
   2753 5.1.2 Status Header Sections
   2754 ----------------------------
   2755 
   2756 The contents of status buffers is controlled using the hook
   2757 ‘magit-status-sections-hook’ (see *note Status Sections::).
   2758 
   2759    By default ‘magit-insert-status-headers’ is the first member of that
   2760 hook variable.
   2761 
   2762  -- Function: magit-insert-status-headers
   2763      Insert headers sections appropriate for ‘magit-status-mode’
   2764      buffers.  The sections are inserted by running the functions on the
   2765      hook ‘magit-status-headers-hook’.
   2766 
   2767  -- User Option: magit-status-headers-hook
   2768      Hook run to insert headers sections into the status buffer.
   2769 
   2770      This hook is run by ‘magit-insert-status-headers’, which in turn
   2771      has to be a member of ‘magit-status-sections-hook’ to be used at
   2772      all.
   2773 
   2774    By default the following functions are members of the above hook:
   2775 
   2776  -- Function: magit-insert-error-header
   2777      Insert a header line showing the message about the Git error that
   2778      just occurred.
   2779 
   2780      This function is only aware of the last error that occur when Git
   2781      was run for side-effects.  If, for example, an error occurs while
   2782      generating a diff, then that error won’t be inserted.  Refreshing
   2783      the status buffer causes this section to disappear again.
   2784 
   2785  -- Function: magit-insert-diff-filter-header
   2786      Insert a header line showing the effective diff filters.
   2787 
   2788  -- Function: magit-insert-head-branch-header
   2789      Insert a header line about the current branch or detached ‘HEAD’.
   2790 
   2791  -- Function: magit-insert-upstream-branch-header
   2792      Insert a header line about the branch that is usually pulled into
   2793      the current branch.
   2794 
   2795  -- Function: magit-insert-push-branch-header
   2796      Insert a header line about the branch that the current branch is
   2797      usually pushed to.
   2798 
   2799  -- Function: magit-insert-tags-header
   2800      Insert a header line about the current and/or next tag, along with
   2801      the number of commits between the tag and ‘HEAD’.
   2802 
   2803    The following functions can also be added to the above hook:
   2804 
   2805  -- Function: magit-insert-repo-header
   2806      Insert a header line showing the path to the repository top-level.
   2807 
   2808  -- Function: magit-insert-remote-header
   2809      Insert a header line about the remote of the current branch.
   2810 
   2811      If no remote is configured for the current branch, then fall back
   2812      showing the "origin" remote, or if that does not exist the first
   2813      remote in alphabetic order.
   2814 
   2815  -- Function: magit-insert-user-header
   2816      Insert a header line about the current user.
   2817 
   2818 
   2819 File: magit.info,  Node: Status Module Sections,  Next: Status Options,  Prev: Status Header Sections,  Up: Status Buffer
   2820 
   2821 5.1.3 Status Module Sections
   2822 ----------------------------
   2823 
   2824 The contents of status buffers is controlled using the hook
   2825 ‘magit-status-sections-hook’ (see *note Status Sections::).
   2826 
   2827    By default ‘magit-insert-modules’ is _not_ a member of that hook
   2828 variable.
   2829 
   2830  -- Function: magit-insert-modules
   2831      Insert submodule sections.
   2832 
   2833      Hook ‘magit-module-sections-hook’ controls which module sections
   2834      are inserted, and option ‘magit-module-sections-nested’ controls
   2835      whether they are wrapped in an additional section.
   2836 
   2837  -- User Option: magit-module-sections-hook
   2838      Hook run by ‘magit-insert-modules’.
   2839 
   2840  -- User Option: magit-module-sections-nested
   2841      This option controls whether ‘magit-insert-modules’ wraps inserted
   2842      sections in an additional section.
   2843 
   2844      If this is non-nil, then only a single top-level section is
   2845      inserted.  If it is nil, then all sections listed in
   2846      ‘magit-module-sections-hook’ become top-level sections.
   2847 
   2848  -- Function: magit-insert-modules-overview
   2849      Insert sections for all submodules.  For each section insert the
   2850      path, the branch, and the output of ‘git describe --tags’, or,
   2851      failing that, the abbreviated HEAD commit hash.
   2852 
   2853      Press ‘RET’ on such a submodule section to show its own status
   2854      buffer.  Press ‘RET’ on the "Modules" section to display a list of
   2855      submodules in a separate buffer.  This shows additional information
   2856      not displayed in the super-repository’s status buffer.
   2857 
   2858  -- Function: magit-insert-modules-unpulled-from-upstream
   2859      Insert sections for modules that haven’t been pulled from the
   2860      upstream yet.  These sections can be expanded to show the
   2861      respective commits.
   2862 
   2863  -- Function: magit-insert-modules-unpulled-from-pushremote
   2864      Insert sections for modules that haven’t been pulled from the
   2865      push-remote yet.  These sections can be expanded to show the
   2866      respective commits.
   2867 
   2868  -- Function: magit-insert-modules-unpushed-to-upstream
   2869      Insert sections for modules that haven’t been pushed to the
   2870      upstream yet.  These sections can be expanded to show the
   2871      respective commits.
   2872 
   2873  -- Function: magit-insert-modules-unpushed-to-pushremote
   2874      Insert sections for modules that haven’t been pushed to the
   2875      push-remote yet.  These sections can be expanded to show the
   2876      respective commits.
   2877 
   2878 
   2879 File: magit.info,  Node: Status Options,  Prev: Status Module Sections,  Up: Status Buffer
   2880 
   2881 5.1.4 Status Options
   2882 --------------------
   2883 
   2884  -- User Option: magit-status-margin
   2885      This option specifies whether the margin is initially shown in
   2886      Magit-Status mode buffers and how it is formatted.
   2887 
   2888      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   2889 
   2890         • If INIT is non-nil, then the margin is shown initially.
   2891         • STYLE controls how to format the author or committer date.  It
   2892           can be one of ‘age’ (to show the age of the commit),
   2893           ‘age-abbreviated’ (to abbreviate the time unit to a
   2894           character), or a string (suitable for ‘format-time-string’) to
   2895           show the actual date.  Option
   2896           ‘magit-log-margin-show-committer-date’ controls which date is
   2897           being displayed.
   2898         • WIDTH controls the width of the margin.  This exists for
   2899           forward compatibility and currently the value should not be
   2900           changed.
   2901         • AUTHOR controls whether the name of the author is also shown
   2902           by default.
   2903         • AUTHOR-WIDTH has to be an integer.  When the name of the
   2904           author is shown, then this specifies how much space is used to
   2905           do so.
   2906 
   2907    Also see the proceeding section for more options concerning status
   2908 buffers.
   2909 
   2910 
   2911 File: magit.info,  Node: Repository List,  Next: Logging,  Prev: Status Buffer,  Up: Inspecting
   2912 
   2913 5.2 Repository List
   2914 ===================
   2915 
   2916  -- Command: magit-list-repositories
   2917      This command displays a list of repositories in a separate buffer.
   2918 
   2919      The option ‘magit-repository-directories’ controls which
   2920      repositories are displayed.
   2921 
   2922  -- User Option: magit-repolist-columns
   2923      This option controls what columns are displayed by the command
   2924      ‘magit-list-repositories’ and how they are displayed.
   2925 
   2926      Each element has the form ‘(HEADER WIDTH FORMAT PROPS)’.
   2927 
   2928      HEADER is the string displayed in the header.  WIDTH is the width
   2929      of the column.  FORMAT is a function that is called with one
   2930      argument, the repository identification (usually its basename), and
   2931      with ‘default-directory’ bound to the toplevel of its working tree.
   2932      It has to return a string to be inserted or nil.  PROPS is an alist
   2933      that supports the keys ‘:right-align’, ‘:pad-right’ and ‘:sort’.
   2934 
   2935      The ‘:sort’ function has a weird interface described in the
   2936      docstring of ‘tabulated-list--get-sort’.  Alternatively ‘<’ and
   2937      ‘magit-repolist-version<’ can be used as those functions are
   2938      automatically replaced with functions that satisfy the interface.
   2939      Set ‘:sort’ to ‘nil’ to inhibit sorting; if unspecified, then the
   2940      column is sortable using the default sorter.
   2941 
   2942      You may wish to display a range of numeric columns using just one
   2943      character per column and without any padding between columns, in
   2944      which case you should use an appropriate HEADER, set WIDTH to 1,
   2945      and set ‘:pad-right’ to 9.  ‘+’ is substituted for numbers higher
   2946      than 9.
   2947 
   2948 The following functions can be added to the above option:
   2949 
   2950  -- Function: magit-repolist-column-ident
   2951      This function inserts the identification of the repository.
   2952      Usually this is just its basename.
   2953 
   2954  -- Function: magit-repolist-column-path
   2955      This function inserts the absolute path of the repository.
   2956 
   2957  -- Function: magit-repolist-column-version
   2958      This function inserts a description of the repository’s ‘HEAD’
   2959      revision.
   2960 
   2961  -- Function: magit-repolist-column-branch
   2962      This function inserts the name of the current branch.
   2963 
   2964  -- Function: magit-repolist-column-upstream
   2965      This function inserts the name of the upstream branch of the
   2966      current branch.
   2967 
   2968  -- Function: magit-repolist-column-branches
   2969      This function inserts the number of branches.
   2970 
   2971  -- Function: magit-repolist-column-stashes
   2972      This function inserts the number of stashes.
   2973 
   2974  -- Function: magit-repolist-column-flag
   2975      This function inserts a flag as specified by
   2976      ‘magit-repolist-column-flag-alist’.
   2977 
   2978      By default this indicates whether there are uncommitted changes.
   2979 
   2980         • ‘N’ if there is at least one untracked file.
   2981         • ‘U’ if there is at least one unstaged file.
   2982         • ‘S’ if there is at least one staged file.
   2983 
   2984      Only the first one of these that applies is shown.
   2985 
   2986  -- Function: magit-repolist-column-flags
   2987      This functions insert all flags as specified by
   2988      ‘magit-repolist-column-flag-alist’.
   2989 
   2990      This is an alternative to function ‘magit-repolist-column-flag’,
   2991      which only lists the first one found.
   2992 
   2993  -- Function: magit-repolist-column-unpulled-from-upstream
   2994      This function inserts the number of upstream commits not in the
   2995      current branch.
   2996 
   2997  -- Function: magit-repolist-column-unpulled-from-pushremote
   2998      This function inserts the number of commits in the push branch but
   2999      not the current branch.
   3000 
   3001  -- Function: magit-repolist-column-unpushed-to-upstream
   3002      This function inserts the number of commits in the current branch
   3003      but not its upstream.
   3004 
   3005  -- Function: magit-repolist-column-unpushed-to-pushremote
   3006      This function inserts the number of commits in the current branch
   3007      but not its push branch.
   3008 
   3009 The following commands are available in repolist buffers:
   3010 
   3011 ‘<RET>’ (‘magit-repolist-status’)
   3012      This command shows the status for the repository at point.
   3013 
   3014 ‘m’ (‘magit-repolist-mark’)
   3015      This command marks the repository at point.
   3016 
   3017 ‘u’ (‘magit-repolist-unmark’)
   3018      This command unmarks the repository at point.
   3019 
   3020 ‘f’ (‘magit-repolist-fetch’)
   3021      This command fetches all marked repositories.  If no repositories
   3022      are marked, then it offers to fetch all displayed repositories.
   3023 
   3024 ‘5’ (‘magit-repolist-find-file-other-frame’)
   3025      This command reads a relative file-name (without completion) and
   3026      opens the respective file in each marked repository in a new frame.
   3027      If no repositories are marked, then it offers to do this for all
   3028      displayed repositories.
   3029 
   3030 
   3031 File: magit.info,  Node: Logging,  Next: Diffing,  Prev: Repository List,  Up: Inspecting
   3032 
   3033 5.3 Logging
   3034 ===========
   3035 
   3036 The status buffer contains logs for the unpushed and unpulled commits,
   3037 but that obviously isn’t enough.  The transient prefix command
   3038 ‘magit-log’, on ‘l’, features several suffix commands, which show a
   3039 specific log in a separate log buffer.
   3040 
   3041    Like other transient prefix commands, ‘magit-log’ also features
   3042 several infix arguments that can be changed before invoking one of the
   3043 suffix commands.  However, in the case of the log transient, these
   3044 arguments may be taken from those currently in use in the current
   3045 repository’s log buffer, depending on the value of
   3046 ‘magit-prefix-use-buffer-arguments’ (see *note Transient Arguments and
   3047 Buffer Variables::).
   3048 
   3049    For information about the various arguments, see *note
   3050 (gitman)git-log::.  The switch ‘++order=VALUE’ is converted to one of
   3051 ‘--author-date-order’, ‘--date-order’, or ‘--topo-order’ before being
   3052 passed to ‘git log’.
   3053 
   3054    The log transient also features several reflog commands.  See *note
   3055 Reflog::.
   3056 
   3057 ‘l’ (‘magit-log’)
   3058      This transient prefix command binds the following suffix commands
   3059      along with the appropriate infix arguments and displays them in a
   3060      temporary buffer until a suffix is invoked.
   3061 
   3062 ‘l l’ (‘magit-log-current’)
   3063      Show log for the current branch.  When ‘HEAD’ is detached or with a
   3064      prefix argument, show log for one or more revs read from the
   3065      minibuffer.
   3066 
   3067 ‘l h’ (‘magit-log-head’)
   3068      Show log for ‘HEAD’.
   3069 
   3070 ‘l u’ (‘magit-log-related’)
   3071      Show log for the current branch, its upstream and its push target.
   3072      When the upstream is a local branch, then also show its own
   3073      upstream.  When ‘HEAD’ is detached, then show log for that, the
   3074      previously checked out branch and its upstream and push-target.
   3075 
   3076 ‘l o’ (‘magit-log-other’)
   3077      Show log for one or more revs read from the minibuffer.  The user
   3078      can input any revision or revisions separated by a space, or even
   3079      ranges, but only branches, tags, and a representation of the commit
   3080      at point are available as completion candidates.
   3081 
   3082 ‘l L’ (‘magit-log-branches’)
   3083      Show log for all local branches and ‘HEAD’.
   3084 
   3085 ‘l b’ (‘magit-log-all-branches’)
   3086      Show log for all local and remote branches and ‘HEAD’.
   3087 
   3088 ‘l a’ (‘magit-log-all’)
   3089      Show log for all references and ‘HEAD’.
   3090 
   3091    Two additional commands that show the log for the file or blob that
   3092 is being visited in the current buffer exists, see *note Commands for
   3093 Buffers Visiting Files::.  The command ‘magit-cherry’ also shows a log,
   3094 see *note Cherries::.
   3095 
   3096 * Menu:
   3097 
   3098 * Refreshing Logs::
   3099 * Log Buffer::
   3100 * Log Margin::
   3101 * Select from Log::
   3102 * Reflog::
   3103 * Cherries::
   3104 
   3105 
   3106 File: magit.info,  Node: Refreshing Logs,  Next: Log Buffer,  Up: Logging
   3107 
   3108 5.3.1 Refreshing Logs
   3109 ---------------------
   3110 
   3111 The transient prefix command ‘magit-log-refresh’, on ‘L’, can be used to
   3112 change the log arguments used in the current buffer, without changing
   3113 which log is shown.  This works in dedicated log buffers, but also in
   3114 the status buffer.
   3115 
   3116 ‘L’ (‘magit-log-refresh’)
   3117      This transient prefix command binds the following suffix commands
   3118      along with the appropriate infix arguments and displays them in a
   3119      temporary buffer until a suffix is invoked.
   3120 
   3121 ‘L g’ (‘magit-log-refresh’)
   3122      This suffix command sets the local log arguments for the current
   3123      buffer.
   3124 
   3125 ‘L s’ (‘magit-log-set-default-arguments’)
   3126      This suffix command sets the default log arguments for buffers of
   3127      the same type as that of the current buffer.  Other existing
   3128      buffers of the same type are not affected because their local
   3129      values have already been initialized.
   3130 
   3131 ‘L w’ (‘magit-log-save-default-arguments’)
   3132      This suffix command sets the default log arguments for buffers of
   3133      the same type as that of the current buffer, and saves the value
   3134      for future sessions.  Other existing buffers of the same type are
   3135      not affected because their local values have already been
   3136      initialized.
   3137 
   3138 ‘L L’ (‘magit-toggle-margin’)
   3139      Show or hide the margin.
   3140 
   3141 
   3142 File: magit.info,  Node: Log Buffer,  Next: Log Margin,  Prev: Refreshing Logs,  Up: Logging
   3143 
   3144 5.3.2 Log Buffer
   3145 ----------------
   3146 
   3147 ‘L’ (‘magit-log-refresh’)
   3148      This transient prefix command binds the following suffix commands
   3149      along with the appropriate infix arguments and displays them in a
   3150      temporary buffer until a suffix is invoked.
   3151 
   3152      See *note Refreshing Logs::.
   3153 
   3154 ‘q’ (‘magit-log-bury-buffer’)
   3155      Bury the current buffer or the revision buffer in the same frame.
   3156      Like ‘magit-mode-bury-buffer’ (which see) but with a negative
   3157      prefix argument instead bury the revision buffer, provided it is
   3158      displayed in the current frame.
   3159 
   3160 ‘C-c C-b’ (‘magit-go-backward’)
   3161      Move backward in current buffer’s history.
   3162 
   3163 ‘C-c C-f’ (‘magit-go-forward’)
   3164      Move forward in current buffer’s history.
   3165 
   3166 ‘C-c C-n’ (‘magit-log-move-to-parent’)
   3167      Move to a parent of the current commit.  By default, this is the
   3168      first parent, but a numeric prefix can be used to specify another
   3169      parent.
   3170 
   3171 ‘j’ (‘magit-log-move-to-revision’)
   3172      Read a revision and move to it in current log buffer.
   3173 
   3174      If the chosen reference or revision isn’t being displayed in the
   3175      current log buffer, then inform the user about that and do nothing
   3176      else.
   3177 
   3178      If invoked outside any log buffer, then display the log buffer of
   3179      the current repository first; creating it if necessary.
   3180 
   3181 ‘<SPC>’ (‘magit-diff-show-or-scroll-up’)
   3182      Update the commit or diff buffer for the thing at point.
   3183 
   3184      Either show the commit or stash at point in the appropriate buffer,
   3185      or if that buffer is already being displayed in the current frame
   3186      and contains information about that commit or stash, then instead
   3187      scroll the buffer up.  If there is no commit or stash at point,
   3188      then prompt for a commit.
   3189 
   3190 ‘<DEL>’ (‘magit-diff-show-or-scroll-down’)
   3191      Update the commit or diff buffer for the thing at point.
   3192 
   3193      Either show the commit or stash at point in the appropriate buffer,
   3194      or if that buffer is already being displayed in the current frame
   3195      and contains information about that commit or stash, then instead
   3196      scroll the buffer down.  If there is no commit or stash at point,
   3197      then prompt for a commit.
   3198 
   3199 ‘=’ (‘magit-log-toggle-commit-limit’)
   3200      Toggle the number of commits the current log buffer is limited to.
   3201      If the number of commits is currently limited, then remove that
   3202      limit.  Otherwise set it to 256.
   3203 
   3204 ‘+’ (‘magit-log-double-commit-limit’)
   3205      Double the number of commits the current log buffer is limited to.
   3206 
   3207 ‘-’ (‘magit-log-half-commit-limit’)
   3208      Half the number of commits the current log buffer is limited to.
   3209 
   3210  -- User Option: magit-log-auto-more
   3211      Insert more log entries automatically when moving past the last
   3212      entry.  Only considered when moving past the last entry with
   3213      ‘magit-goto-*-section’ commands.
   3214 
   3215  -- User Option: magit-log-show-refname-after-summary
   3216      Whether to show the refnames after the commit summaries.  This is
   3217      useful if you use really long branch names.
   3218 
   3219  -- User Option: magit-log-show-color-graph-limit
   3220      When showing more commits than specified by this option, then the
   3221      ‘--color’ argument, if specified, is silently dropped.  This is
   3222      necessary because the ‘ansi-color’ library, which is used to turn
   3223      control sequences into faces, is just too slow.
   3224 
   3225  -- User Option: magit-log-show-signatures-limit
   3226      When showing more commits than specified by this option, then the
   3227      ‘--show-signature’ argument, if specified, is silently dropped.
   3228      This is necessary because checking the signature of a large number
   3229      of commits is just too slow.
   3230 
   3231    Magit displays references in logs a bit differently from how Git does
   3232 it.
   3233 
   3234    Local branches are blue and remote branches are green.  Of course
   3235 that depends on the used theme, as do the colors used for other types of
   3236 references.  The current branch has a box around it, as do remote
   3237 branches that are their respective remote’s ‘HEAD’ branch.
   3238 
   3239    If a local branch and its push-target point at the same commit, then
   3240 their names are combined to preserve space and to make that relationship
   3241 visible.  For example:
   3242 
   3243      origin/feature
   3244      [green][blue-]
   3245 
   3246      instead of
   3247 
   3248      feature origin/feature
   3249      [blue-] [green-------]
   3250 
   3251    Also note that while the transient features the ‘--show-signature’
   3252 argument, that won’t actually be used when enabled, because Magit
   3253 defaults to use just one line per commit.  Instead the commit colorized
   3254 to indicate the validity of the signed commit object, using the faces
   3255 named ‘magit-signature-*’ (which see).
   3256 
   3257    For a description of ‘magit-log-margin’ see *note Log Margin::.
   3258 
   3259 
   3260 File: magit.info,  Node: Log Margin,  Next: Select from Log,  Prev: Log Buffer,  Up: Logging
   3261 
   3262 5.3.3 Log Margin
   3263 ----------------
   3264 
   3265 In buffers which show one or more logs, it is possible to show
   3266 additional information about each commit in the margin.  The options
   3267 used to configure the margin are named ‘magit-INFIX-margin’, where INFIX
   3268 is the same as in the respective major-mode ‘magit-INFIX-mode’.  In
   3269 regular log buffers that would be ‘magit-log-margin’.
   3270 
   3271  -- User Option: magit-log-margin
   3272      This option specifies whether the margin is initially shown in
   3273      Magit-Log mode buffers and how it is formatted.
   3274 
   3275      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   3276 
   3277         • If INIT is non-nil, then the margin is shown initially.
   3278         • STYLE controls how to format the author or committer date.  It
   3279           can be one of ‘age’ (to show the age of the commit),
   3280           ‘age-abbreviated’ (to abbreviate the time unit to a
   3281           character), or a string (suitable for ‘format-time-string’) to
   3282           show the actual date.  Option
   3283           ‘magit-log-margin-show-committer-date’ controls which date is
   3284           being displayed.
   3285         • WIDTH controls the width of the margin.  This exists for
   3286           forward compatibility and currently the value should not be
   3287           changed.
   3288         • AUTHOR controls whether the name of the author is also shown
   3289           by default.
   3290         • AUTHOR-WIDTH has to be an integer.  When the name of the
   3291           author is shown, then this specifies how much space is used to
   3292           do so.
   3293 
   3294    You can change the STYLE and AUTHOR-WIDTH of all ‘magit-INFIX-margin’
   3295 options to the same values by customizing ‘magit-log-margin’ *before*
   3296 ‘magit’ is loaded.  If you do that, then the respective values for the
   3297 other options will default to what you have set for that variable.
   3298 Likewise if you set INIT in ‘magit-log-margin’ to ‘nil’, then that is
   3299 used in the default of all other options.  But setting it to ‘t’, i.e.
   3300 re-enforcing the default for that option, does not carry to other
   3301 options.
   3302 
   3303  -- User Option: magit-log-margin-show-committer-date
   3304      This option specifies whether to show the committer date in the
   3305      margin.  This option only controls whether the committer date is
   3306      displayed instead of the author date.  Whether some date is
   3307      displayed in the margin and whether the margin is displayed at all
   3308      is controlled by other options.
   3309 
   3310 ‘L’ (‘magit-margin-settings’)
   3311      This transient prefix command binds the following suffix commands,
   3312      each of which changes the appearance of the margin in some way.
   3313 
   3314    In some buffers that support the margin, ‘L’ is instead bound to
   3315 ‘magit-log-refresh’, but that transient features the same commands, and
   3316 then some other unrelated commands.
   3317 
   3318 ‘L L’ (‘magit-toggle-margin’)
   3319      This command shows or hides the margin.
   3320 
   3321 ‘L l’ (‘magit-cycle-margin-style’)
   3322      This command cycles the style used for the margin.
   3323 
   3324 ‘L d’ (‘magit-toggle-margin-details’)
   3325      This command shows or hides details in the margin.
   3326 
   3327 
   3328 File: magit.info,  Node: Select from Log,  Next: Reflog,  Prev: Log Margin,  Up: Logging
   3329 
   3330 5.3.4 Select from Log
   3331 ---------------------
   3332 
   3333 When the user has to select a recent commit that is reachable from
   3334 ‘HEAD’, using regular completion would be inconvenient (because most
   3335 humans cannot remember hashes or "HEAD~5", at least not without double
   3336 checking).  Instead a log buffer is used to select the commit, which has
   3337 the advantage that commits are presented in order and with the commit
   3338 message.
   3339 
   3340    Such selection logs are used when selecting the beginning of a rebase
   3341 and when selecting the commit to be squashed into.
   3342 
   3343    In addition to the key bindings available in all log buffers, the
   3344 following additional key bindings are available in selection log
   3345 buffers:
   3346 
   3347 ‘C-c C-c’ (‘magit-log-select-pick’)
   3348      Select the commit at point and act on it.  Call
   3349      ‘magit-log-select-pick-function’ with the selected commit as
   3350      argument.
   3351 
   3352 ‘C-c C-k’ (‘magit-log-select-quit’)
   3353      Abort selecting a commit, don’t act on any commit.
   3354 
   3355  -- User Option: magit-log-select-margin
   3356      This option specifies whether the margin is initially shown in
   3357      Magit-Log-Select mode buffers and how it is formatted.
   3358 
   3359      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   3360 
   3361         • If INIT is non-nil, then the margin is shown initially.
   3362         • STYLE controls how to format the author or committer date.  It
   3363           can be one of ‘age’ (to show the age of the commit),
   3364           ‘age-abbreviated’ (to abbreviate the time unit to a
   3365           character), or a string (suitable for ‘format-time-string’) to
   3366           show the actual date.  Option
   3367           ‘magit-log-margin-show-committer-date’ controls which date is
   3368           being displayed.
   3369         • WIDTH controls the width of the margin.  This exists for
   3370           forward compatibility and currently the value should not be
   3371           changed.
   3372         • AUTHOR controls whether the name of the author is also shown
   3373           by default.
   3374         • AUTHOR-WIDTH has to be an integer.  When the name of the
   3375           author is shown, then this specifies how much space is used to
   3376           do so.
   3377 
   3378 
   3379 File: magit.info,  Node: Reflog,  Next: Cherries,  Prev: Select from Log,  Up: Logging
   3380 
   3381 5.3.5 Reflog
   3382 ------------
   3383 
   3384 Also see *note (gitman)git-reflog::.
   3385 
   3386    These reflog commands are available from the log transient.  See
   3387 *note Logging::.
   3388 
   3389 ‘l r’ (‘magit-reflog-current’)
   3390      Display the reflog of the current branch.
   3391 
   3392 ‘l O’ (‘magit-reflog-other’)
   3393      Display the reflog of a branch or another ref.
   3394 
   3395 ‘l H’ (‘magit-reflog-head’)
   3396      Display the ‘HEAD’ reflog.
   3397 
   3398  -- User Option: magit-reflog-margin
   3399      This option specifies whether the margin is initially shown in
   3400      Magit-Reflog mode buffers and how it is formatted.
   3401 
   3402      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   3403 
   3404         • If INIT is non-nil, then the margin is shown initially.
   3405         • STYLE controls how to format the author or committer date.  It
   3406           can be one of ‘age’ (to show the age of the commit),
   3407           ‘age-abbreviated’ (to abbreviate the time unit to a
   3408           character), or a string (suitable for ‘format-time-string’) to
   3409           show the actual date.  Option
   3410           ‘magit-log-margin-show-committer-date’ controls which date is
   3411           being displayed.
   3412         • WIDTH controls the width of the margin.  This exists for
   3413           forward compatibility and currently the value should not be
   3414           changed.
   3415         • AUTHOR controls whether the name of the author is also shown
   3416           by default.
   3417         • AUTHOR-WIDTH has to be an integer.  When the name of the
   3418           author is shown, then this specifies how much space is used to
   3419           do so.
   3420 
   3421 
   3422 File: magit.info,  Node: Cherries,  Prev: Reflog,  Up: Logging
   3423 
   3424 5.3.6 Cherries
   3425 --------------
   3426 
   3427 Cherries are commits that haven’t been applied upstream (yet), and are
   3428 usually visualized using a log.  Each commit is prefixed with ‘-’ if it
   3429 has an equivalent in the upstream and ‘+’ if it does not, i.e., if it is
   3430 a cherry.
   3431 
   3432    The command ‘magit-cherry’ shows cherries for a single branch, but
   3433 the references buffer (see *note References Buffer::) can show cherries
   3434 for multiple "upstreams" at once.
   3435 
   3436    Also see *note (gitman)git-reflog::.
   3437 
   3438 ‘Y’ (‘magit-cherry’)
   3439      Show commits that are in a certain branch but that have not been
   3440      merged in the upstream branch.
   3441 
   3442  -- User Option: magit-cherry-margin
   3443      This option specifies whether the margin is initially shown in
   3444      Magit-Cherry mode buffers and how it is formatted.
   3445 
   3446      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   3447 
   3448         • If INIT is non-nil, then the margin is shown initially.
   3449         • STYLE controls how to format the author or committer date.  It
   3450           can be one of ‘age’ (to show the age of the commit),
   3451           ‘age-abbreviated’ (to abbreviate the time unit to a
   3452           character), or a string (suitable for ‘format-time-string’) to
   3453           show the actual date.  Option
   3454           ‘magit-log-margin-show-committer-date’ controls which date is
   3455           being displayed.
   3456         • WIDTH controls the width of the margin.  This exists for
   3457           forward compatibility and currently the value should not be
   3458           changed.
   3459         • AUTHOR controls whether the name of the author is also shown
   3460           by default.
   3461         • AUTHOR-WIDTH has to be an integer.  When the name of the
   3462           author is shown, then this specifies how much space is used to
   3463           do so.
   3464 
   3465 
   3466 File: magit.info,  Node: Diffing,  Next: Ediffing,  Prev: Logging,  Up: Inspecting
   3467 
   3468 5.4 Diffing
   3469 ===========
   3470 
   3471 The status buffer contains diffs for the staged and unstaged commits,
   3472 but that obviously isn’t enough.  The transient prefix command
   3473 ‘magit-diff’, on ‘d’, features several suffix commands, which show a
   3474 specific diff in a separate diff buffer.
   3475 
   3476    Like other transient prefix commands, ‘magit-diff’ also features
   3477 several infix arguments that can be changed before invoking one of the
   3478 suffix commands.  However, in the case of the diff transient, these
   3479 arguments may be taken from those currently in use in the current
   3480 repository’s diff buffer, depending on the value of
   3481 ‘magit-prefix-use-buffer-arguments’ (see *note Transient Arguments and
   3482 Buffer Variables::).
   3483 
   3484    Also see *note (gitman)git-diff::.
   3485 
   3486 ‘d’ (‘magit-diff’)
   3487      This transient prefix command binds the following suffix commands
   3488      along with the appropriate infix arguments and displays them in a
   3489      temporary buffer until a suffix is invoked.
   3490 
   3491 ‘d d’ (‘magit-diff-dwim’)
   3492      Show changes for the thing at point.
   3493 
   3494 ‘d r’ (‘magit-diff-range’)
   3495      Show differences between two commits.
   3496 
   3497      RANGE should be a range (A..B or A...B) but can also be a single
   3498      commit.  If one side of the range is omitted, then it defaults to
   3499      ‘HEAD’.  If just a commit is given, then changes in the working
   3500      tree relative to that commit are shown.
   3501 
   3502      If the region is active, use the revisions on the first and last
   3503      line of the region.  With a prefix argument, instead of diffing the
   3504      revisions, choose a revision to view changes along, starting at the
   3505      common ancestor of both revisions (i.e., use a "..." range).
   3506 
   3507 ‘d w’ (‘magit-diff-working-tree’)
   3508      Show changes between the current working tree and the ‘HEAD’
   3509      commit.  With a prefix argument show changes between the working
   3510      tree and a commit read from the minibuffer.
   3511 
   3512 ‘d s’ (‘magit-diff-staged’)
   3513      Show changes between the index and the ‘HEAD’ commit.  With a
   3514      prefix argument show changes between the index and a commit read
   3515      from the minibuffer.
   3516 
   3517 ‘d u’ (‘magit-diff-unstaged’)
   3518      Show changes between the working tree and the index.
   3519 
   3520 ‘d p’ (‘magit-diff-paths’)
   3521      Show changes between any two files on disk.
   3522 
   3523    All of the above suffix commands update the repository’s diff buffer.
   3524 The diff transient also features two commands which show differences in
   3525 another buffer:
   3526 
   3527 ‘d c’ (‘magit-show-commit’)
   3528      Show the commit at point.  If there is no commit at point or with a
   3529      prefix argument, prompt for a commit.
   3530 
   3531 ‘d t’ (‘magit-stash-show’)
   3532      Show all diffs of a stash in a buffer.
   3533 
   3534    Two additional commands that show the diff for the file or blob that
   3535 is being visited in the current buffer exists, see *note Commands for
   3536 Buffers Visiting Files::.
   3537 
   3538 * Menu:
   3539 
   3540 * Refreshing Diffs::
   3541 * Commands Available in Diffs::
   3542 * Diff Options::
   3543 * Revision Buffer::
   3544 
   3545 
   3546 File: magit.info,  Node: Refreshing Diffs,  Next: Commands Available in Diffs,  Up: Diffing
   3547 
   3548 5.4.1 Refreshing Diffs
   3549 ----------------------
   3550 
   3551 The transient prefix command ‘magit-diff-refresh’, on ‘D’, can be used
   3552 to change the diff arguments used in the current buffer, without
   3553 changing which diff is shown.  This works in dedicated diff buffers, but
   3554 also in the status buffer.
   3555 
   3556    (There is one exception; diff arguments cannot be changed in buffers
   3557 created by ‘magit-merge-preview’ because the underlying Git command does
   3558 not support these arguments.)
   3559 
   3560 ‘D’ (‘magit-diff-refresh’)
   3561      This transient prefix command binds the following suffix commands
   3562      along with the appropriate infix arguments and displays them in a
   3563      temporary buffer until a suffix is invoked.
   3564 
   3565 ‘D g’ (‘magit-diff-refresh’)
   3566      This suffix command sets the local diff arguments for the current
   3567      buffer.
   3568 
   3569 ‘D s’ (‘magit-diff-set-default-arguments’)
   3570      This suffix command sets the default diff arguments for buffers of
   3571      the same type as that of the current buffer.  Other existing
   3572      buffers of the same type are not affected because their local
   3573      values have already been initialized.
   3574 
   3575 ‘D w’ (‘magit-diff-save-default-arguments’)
   3576      This suffix command sets the default diff arguments for buffers of
   3577      the same type as that of the current buffer, and saves the value
   3578      for future sessions.  Other existing buffers of the same type are
   3579      not affected because their local values have already been
   3580      initialized.
   3581 
   3582 ‘D t’ (‘magit-diff-toggle-refine-hunk’)
   3583      This command toggles hunk refinement on or off.
   3584 
   3585 ‘D r’ (‘magit-diff-switch-range-type’)
   3586      This command converts the diff range type from "revA..revB" to
   3587      "revB...revA", or vice versa.
   3588 
   3589 ‘D f’ (‘magit-diff-flip-revs’)
   3590      This command swaps revisions in the diff range from "revA..revB" to
   3591      "revB..revA", or vice versa.
   3592 
   3593 ‘D F’ (‘magit-diff-toggle-file-filter’)
   3594      This command toggles the file restriction of the diffs in the
   3595      current buffer, allowing you to quickly switch between viewing all
   3596      the changes in the commit and the restricted subset.  As a special
   3597      case, when this command is called from a log buffer, it toggles the
   3598      file restriction in the repository’s revision buffer, which is
   3599      useful when you display a revision from a log buffer that is
   3600      restricted to a file or files.
   3601 
   3602    In addition to the above transient, which allows changing any of the
   3603 supported arguments, there also exist some commands that change only a
   3604 particular argument.
   3605 
   3606 ‘-’ (‘magit-diff-less-context’)
   3607      This command decreases the context for diff hunks by COUNT lines.
   3608 
   3609 ‘+’ (‘magit-diff-more-context’)
   3610      This command increases the context for diff hunks by COUNT lines.
   3611 
   3612 ‘0’ (‘magit-diff-default-context’)
   3613      This command resets the context for diff hunks to the default
   3614      height.
   3615 
   3616    The following commands quickly change what diff is being displayed
   3617 without having to using one of the diff transient.
   3618 
   3619 ‘C-c C-d’ (‘magit-diff-while-committing’)
   3620      While committing, this command shows the changes that are about to
   3621      be committed.  While amending, invoking the command again toggles
   3622      between showing just the new changes or all the changes that will
   3623      be committed.
   3624 
   3625      This binding is available in the diff buffer as well as the commit
   3626      message buffer.
   3627 
   3628 ‘C-c C-b’ (‘magit-go-backward’)
   3629      This command moves backward in current buffer’s history.
   3630 
   3631 ‘C-c C-f’ (‘magit-go-forward’)
   3632      This command moves forward in current buffer’s history.
   3633 
   3634 
   3635 File: magit.info,  Node: Commands Available in Diffs,  Next: Diff Options,  Prev: Refreshing Diffs,  Up: Diffing
   3636 
   3637 5.4.2 Commands Available in Diffs
   3638 ---------------------------------
   3639 
   3640 Some commands are only available if point is inside a diff.
   3641 
   3642    ‘magit-diff-visit-file’ and related commands visit the appropriate
   3643 version of the file that the diff at point is about.  Likewise
   3644 ‘magit-diff-visit-worktree-file’ and related commands visit the worktree
   3645 version of the file that the diff at point is about.  See *note Visiting
   3646 Files and Blobs from a Diff:: for more information and the key bindings.
   3647 
   3648 ‘C-c C-t’ (‘magit-diff-trace-definition’)
   3649      This command shows a log for the definition at point.
   3650 
   3651  -- User Option: magit-log-trace-definition-function
   3652      The function specified by this option is used by
   3653      ‘magit-log-trace-definition’ to determine the function at point.
   3654      For major-modes that have special needs, you could set the local
   3655      value using the mode’s hook.
   3656 
   3657 ‘C-c C-e’ (‘magit-diff-edit-hunk-commit’)
   3658      From a hunk, this command edits the respective commit and visits
   3659      the file.
   3660 
   3661      First it visits the file being modified by the hunk at the correct
   3662      location using ‘magit-diff-visit-file’.  This actually visits a
   3663      blob.  When point is on a diff header, not within an individual
   3664      hunk, then this visits the blob the first hunk is about.
   3665 
   3666      Then it invokes ‘magit-edit-line-commit’, which uses an interactive
   3667      rebase to make the commit editable, or if that is not possible
   3668      because the commit is not reachable from ‘HEAD’ by checking out
   3669      that commit directly.  This also causes the actual worktree file to
   3670      be visited.
   3671 
   3672      Neither the blob nor the file buffer are killed when finishing the
   3673      rebase.  If that is undesirable, then it might be better to use
   3674      ‘magit-rebase-edit-commit’ instead of this command.
   3675 
   3676 ‘j’ (‘magit-jump-to-diffstat-or-diff’)
   3677      This command jumps to the diffstat or diff.  When point is on a
   3678      file inside the diffstat section, then jump to the respective diff
   3679      section.  Otherwise, jump to the diffstat section or a child
   3680      thereof.
   3681 
   3682    The next two commands are not specific to Magit-Diff mode (or and
   3683 Magit buffer for that matter), but it might be worth pointing out that
   3684 they are available here too.
   3685 
   3686 ‘<SPC>’ (‘scroll-up’)
   3687      This command scrolls text upward.
   3688 
   3689 ‘<DEL>’ (‘scroll-down’)
   3690      This command scrolls text downward.
   3691 
   3692 
   3693 File: magit.info,  Node: Diff Options,  Next: Revision Buffer,  Prev: Commands Available in Diffs,  Up: Diffing
   3694 
   3695 5.4.3 Diff Options
   3696 ------------------
   3697 
   3698  -- User Option: magit-diff-refine-hunk
   3699      Whether to show word-granularity differences within diff hunks.
   3700 
   3701         • ‘nil’ Never show fine differences.
   3702         • ‘t’ Show fine differences for the current diff hunk only.
   3703         • ‘all’ Show fine differences for all displayed diff hunks.
   3704 
   3705  -- User Option: magit-diff-refine-ignore-whitespace
   3706      Whether to ignore whitespace changes in word-granularity
   3707      differences.
   3708 
   3709  -- User Option: magit-diff-adjust-tab-width
   3710      Whether to adjust the width of tabs in diffs.
   3711 
   3712      Determining the correct width can be expensive if it requires
   3713      opening large and/or many files, so the widths are cached in the
   3714      variable ‘magit-diff--tab-width-cache’.  Set that to nil to
   3715      invalidate the cache.
   3716 
   3717         • ‘nil’ Never adjust tab width.  Use ‘tab-width’s value from the
   3718           Magit buffer itself instead.
   3719 
   3720         • ‘t’ If the corresponding file-visiting buffer exits, then use
   3721           ‘tab-width’’s value from that buffer.  Doing this is cheap, so
   3722           this value is used even if a corresponding cache entry exists.
   3723 
   3724         • ‘always’ If there is no such buffer, then temporarily visit
   3725           the file to determine the value.
   3726 
   3727         • NUMBER Like ‘always’, but don’t visit files larger than NUMBER
   3728           bytes.
   3729 
   3730  -- User Option: magit-diff-paint-whitespace
   3731      Specify where to highlight whitespace errors.
   3732 
   3733      See ‘magit-diff-highlight-trailing’,
   3734      ‘magit-diff-highlight-indentation’.  The symbol ‘t’ means in all
   3735      diffs, ‘status’ means only in the status buffer, and nil means
   3736      nowhere.
   3737 
   3738         • ‘nil’ Never highlight whitespace errors.
   3739         • ‘t’ Highlight whitespace errors everywhere.
   3740         • ‘uncommitted’ Only highlight whitespace errors in diffs
   3741           showing uncommitted changes.  For backward compatibility
   3742           ‘status’ is treated as a synonym.
   3743 
   3744  -- User Option: magit-diff-paint-whitespace-lines
   3745      Specify in what kind of lines to highlight whitespace errors.
   3746 
   3747         • ‘t’ Highlight only in added lines.
   3748         • ‘both’ Highlight in added and removed lines.
   3749         • ‘all’ Highlight in added, removed and context lines.
   3750 
   3751  -- User Option: magit-diff-highlight-trailing
   3752      Whether to highlight whitespace at the end of a line in diffs.
   3753      Used only when ‘magit-diff-paint-whitespace’ is non-nil.
   3754 
   3755  -- User Option: magit-diff-highlight-indentation
   3756      This option controls whether to highlight the indentation in case
   3757      it used the "wrong" indentation style.  Indentation is only
   3758      highlighted if ‘magit-diff-paint-whitespace’ is also non-nil.
   3759 
   3760      The value is an alist of the form ‘((REGEXP . INDENT)...)’.  The
   3761      path to the current repository is matched against each element in
   3762      reverse order.  Therefore if a REGEXP matches, then earlier
   3763      elements are not tried.
   3764 
   3765      If the used INDENT is ‘tabs’, highlight indentation with tabs.  If
   3766      INDENT is an integer, highlight indentation with at least that many
   3767      spaces.  Otherwise, highlight neither.
   3768 
   3769  -- User Option: magit-diff-hide-trailing-cr-characters
   3770      Whether to hide ^M characters at the end of a line in diffs.
   3771 
   3772  -- User Option: magit-diff-highlight-hunk-region-functions
   3773      This option specifies the functions used to highlight the
   3774      hunk-internal region.
   3775 
   3776      ‘magit-diff-highlight-hunk-region-dim-outside’ overlays the outside
   3777      of the hunk internal selection with a face that causes the added
   3778      and removed lines to have the same background color as context
   3779      lines.  This function should not be removed from the value of this
   3780      option.
   3781 
   3782      ‘magit-diff-highlight-hunk-region-using-overlays’ and
   3783      ‘magit-diff-highlight-hunk-region-using-underline’ emphasize the
   3784      region by placing delimiting horizontal lines before and after it.
   3785      Both of these functions have glitches which cannot be fixed due to
   3786      limitations of Emacs’ display engine.  For more information see
   3787      <https://github.com/magit/magit/issues/2758> ff.
   3788 
   3789      Instead of, or in addition to, using delimiting horizontal lines,
   3790      to emphasize the boundaries, you may wish to emphasize the text
   3791      itself, using ‘magit-diff-highlight-hunk-region-using-face’.
   3792 
   3793      In terminal frames it’s not possible to draw lines as the overlay
   3794      and underline variants normally do, so there they fall back to
   3795      calling the face function instead.
   3796 
   3797  -- User Option: magit-diff-unmarked-lines-keep-foreground
   3798      This option controls whether added and removed lines outside the
   3799      hunk-internal region only lose their distinct background color or
   3800      also the foreground color.  Whether the outside of the region is
   3801      dimmed at all depends on
   3802      ‘magit-diff-highlight-hunk-region-functions’.
   3803 
   3804  -- User Option: magit-diff-extra-stat-arguments
   3805      This option specifies additional arguments to be used alongside
   3806      ‘--stat’.
   3807 
   3808      The value is a list of zero or more arguments or a function that
   3809      takes no argument and returns such a list.  These arguments are
   3810      allowed here: ‘--stat-width’, ‘--stat-name-width’,
   3811      ‘--stat-graph-width’ and ‘--compact-summary’.  Also see *note
   3812      (gitman)git-diff::.
   3813 
   3814 
   3815 File: magit.info,  Node: Revision Buffer,  Prev: Diff Options,  Up: Diffing
   3816 
   3817 5.4.4 Revision Buffer
   3818 ---------------------
   3819 
   3820  -- User Option: magit-revision-insert-related-refs
   3821      Whether to show related branches in revision buffers.
   3822 
   3823         • ‘nil’ Don’t show any related branches.
   3824         • ‘t’ Show related local branches.
   3825         • ‘all’ Show related local and remote branches.
   3826         • ‘mixed’ Show all containing branches and local merged
   3827           branches.
   3828 
   3829  -- User Option: magit-revision-show-gravatars
   3830      Whether to show gravatar images in revision buffers.
   3831 
   3832      If ‘nil’, then don’t insert any gravatar images.  If ‘t’, then
   3833      insert both images.  If ‘author’ or ‘committer’, then insert only
   3834      the respective image.
   3835 
   3836      If you have customized the option ‘magit-revision-headers-format’
   3837      and want to insert the images then you might also have to specify
   3838      where to do so.  In that case the value has to be a cons-cell of
   3839      two regular expressions.  The car specifies where to insert the
   3840      author’s image.  The top half of the image is inserted right after
   3841      the matched text, the bottom half on the next line in the same
   3842      column.  The cdr specifies where to insert the committer’s image,
   3843      accordingly.  Either the car or the cdr may be nil."
   3844 
   3845  -- User Option: magit-revision-use-hash-sections
   3846      Whether to turn hashes inside the commit message into sections.
   3847 
   3848      If non-nil, then hashes inside the commit message are turned into
   3849      ‘commit’ sections.  There is a trade off to be made between
   3850      performance and reliability:
   3851 
   3852         • ‘slow’ calls git for every word to be absolutely sure.
   3853         • ‘quick’ skips words less than seven characters long.
   3854         • ‘quicker’ additionally skips words that don’t contain a
   3855           number.
   3856         • ‘quickest’ uses all words that are at least seven characters
   3857           long and which contain at least one number as well as at least
   3858           one letter.
   3859 
   3860      If nil, then no hashes are turned into sections, but you can still
   3861      visit the commit at point using "RET".
   3862 
   3863    The diffs shown in the revision buffer may be automatically
   3864 restricted to a subset of the changed files.  If the revision buffer is
   3865 displayed from a log buffer, the revision buffer will share the same
   3866 file restriction as that log buffer (also see the command
   3867 ‘magit-diff-toggle-file-filter’).
   3868 
   3869  -- User Option: magit-revision-filter-files-on-follow
   3870      Whether showing a commit from a log buffer honors the log’s file
   3871      filter when the log arguments include ‘--follow’.
   3872 
   3873      When this option is nil, displaying a commit from a log ignores the
   3874      log’s file filter if the log arguments include ‘--follow’.  Doing
   3875      so avoids showing an empty diff in revision buffers for commits
   3876      before a rename event.  In such cases, the ‘--patch’ argument of
   3877      the log transient can be used to show the file-restricted diffs
   3878      inline.
   3879 
   3880      Set this option to non-nil to keep the log’s file restriction even
   3881      if ‘--follow’ is present in the log arguments.
   3882 
   3883    If the revision buffer is not displayed from a log buffer, the file
   3884 restriction is determined as usual (see *note Transient Arguments and
   3885 Buffer Variables::).
   3886 
   3887 
   3888 File: magit.info,  Node: Ediffing,  Next: References Buffer,  Prev: Diffing,  Up: Inspecting
   3889 
   3890 5.5 Ediffing
   3891 ============
   3892 
   3893 This section describes how to enter Ediff from Magit buffers.  For
   3894 information on how to use Ediff itself, see *note (ediff)Top::.
   3895 
   3896 ‘e’ (‘magit-ediff-dwim’)
   3897      Compare, stage, or resolve using Ediff.
   3898 
   3899      This command tries to guess what file, and what commit or range the
   3900      user wants to compare, stage, or resolve using Ediff.  It might
   3901      only be able to guess either the file, or range/commit, in which
   3902      case the user is asked about the other.  It might not always guess
   3903      right, in which case the appropriate ‘magit-ediff-*’ command has to
   3904      be used explicitly.  If it cannot read the user’s mind at all, then
   3905      it asks the user for a command to run.
   3906 
   3907 ‘E’ (‘magit-ediff’)
   3908      This transient prefix command binds the following suffix commands
   3909      and displays them in a temporary buffer until a suffix is invoked.
   3910 
   3911 ‘E r’ (‘magit-ediff-compare’)
   3912      Compare two revisions of a file using Ediff.
   3913 
   3914      If the region is active, use the revisions on the first and last
   3915      line of the region.  With a prefix argument, instead of diffing the
   3916      revisions, choose a revision to view changes along, starting at the
   3917      common ancestor of both revisions (i.e., use a "..." range).
   3918 
   3919 ‘E m’ (‘magit-ediff-resolve-rest’)
   3920      This command allows you to resolve outstanding conflicts in the
   3921      file at point using Ediff.  If there is no file at point or if it
   3922      doesn’t have any unmerged changes, then this command prompts for a
   3923      file.
   3924 
   3925      Provided that the value of ‘merge.conflictstyle’ is ‘diff3’, you
   3926      can view the file’s merge-base revision using ‘/’ in the Ediff
   3927      control buffer.
   3928 
   3929      The A, B and Ancestor buffers are constructed from the conflict
   3930      markers in the worktree file.  Because you and/or Git may have
   3931      already resolved some conflicts, that means that these buffers may
   3932      not contain the actual versions from the respective blobs.
   3933 
   3934 ‘E M’ (‘magit-ediff-resolve-all’)
   3935      This command allows you to resolve all conflicts in the file at
   3936      point using Ediff.  If there is no file at point or if it doesn’t
   3937      have any unmerged changes, then this command prompts for a file.
   3938 
   3939      Provided that the value of ‘merge.conflictstyle’ is ‘diff3’, you
   3940      can view the file’s merge-base revision using ‘/’ in the Ediff
   3941      control buffer.
   3942 
   3943      First the file in the worktree is moved aside, appending the suffix
   3944      ‘.ORIG’, so that you could later go back to that version.  Then it
   3945      is reconstructed from the two sides of the conflict and the
   3946      merge-base, if available.
   3947 
   3948      It would be nice if the worktree file were just used as-is, but
   3949      Ediff does not support that.  This means that all conflicts, that
   3950      Git has already resolved, are restored.  On the other hand Ediff
   3951      also tries to resolve conflicts, and in many cases Ediff and Git
   3952      should produce similar results.
   3953 
   3954      However if you have already resolved some conflicts manually, then
   3955      those changes are discarded (though you can recover them from the
   3956      backup file).  In such cases ‘magit-ediff-resolve-rest’ might be
   3957      more suitable.
   3958 
   3959      The advantage that this command has over ‘magit-ediff-resolve-rest’
   3960      is that the A, B and Ancestor buffers correspond to blobs from the
   3961      respective commits, allowing you to inspect a side in context and
   3962      to use Magit commands in these buffers to do so.  Blame and log
   3963      commands are particularly useful here.
   3964 
   3965 ‘E t’ (‘magit-git-mergetool’)
   3966      This command does not actually use Ediff.  While it serves the same
   3967      purpose as ‘magit-ediff-resolve-rest’, it uses ‘git mergetool
   3968      --gui’ to resolve conflicts.
   3969 
   3970      With a prefix argument this acts as a transient prefix command,
   3971      allowing the user to select the mergetool and change some settings.
   3972 
   3973 ‘E s’ (‘magit-ediff-stage’)
   3974      Stage and unstage changes to a file using Ediff, defaulting to the
   3975      file at point.
   3976 
   3977 ‘E u’ (‘magit-ediff-show-unstaged’)
   3978      Show unstaged changes to a file using Ediff.
   3979 
   3980 ‘E i’ (‘magit-ediff-show-staged’)
   3981      Show staged changes to a file using Ediff.
   3982 
   3983 ‘E w’ (‘magit-ediff-show-working-tree’)
   3984      Show changes in a file between ‘HEAD’ and working tree using Ediff.
   3985 
   3986 ‘E c’ (‘magit-ediff-show-commit’)
   3987      Show changes to a file introduced by a commit using Ediff.
   3988 
   3989 ‘E z’ (‘magit-ediff-show-stash’)
   3990      Show changes to a file introduced by a stash using Ediff.
   3991 
   3992  -- User Option: magit-ediff-dwim-resolve-function
   3993      This option controls which function ‘magit-ediff-dwim’ uses to
   3994      resolve conflicts.  One of ‘magit-ediff-resolve-rest’,
   3995      ‘magit-ediff-resolve-all’ or ‘magit-git-mergetool’; which are all
   3996      discussed above.
   3997 
   3998  -- User Option: magit-ediff-dwim-show-on-hunks
   3999      This option controls what command ‘magit-ediff-dwim’ calls when
   4000      point is on uncommitted hunks.  When nil, always run
   4001      ‘magit-ediff-stage’.  Otherwise, use ‘magit-ediff-show-staged’ and
   4002      ‘magit-ediff-show-unstaged’ to show staged and unstaged changes,
   4003      respectively.
   4004 
   4005  -- User Option: magit-ediff-show-stash-with-index
   4006      This option controls whether ‘magit-ediff-show-stash’ includes a
   4007      buffer containing the file’s state in the index at the time the
   4008      stash was created.  This makes it possible to tell which changes in
   4009      the stash were staged.
   4010 
   4011  -- User Option: magit-ediff-quit-hook
   4012      This hook is run after quitting an Ediff session that was created
   4013      using a Magit command.  The hook functions are run inside the Ediff
   4014      control buffer, and should not change the current buffer.
   4015 
   4016      This is similar to ‘ediff-quit-hook’ but takes the needs of Magit
   4017      into account.  The regular ‘ediff-quit-hook’ is ignored by Ediff
   4018      sessions that were created using a Magit command.
   4019 
   4020 
   4021 File: magit.info,  Node: References Buffer,  Next: Bisecting,  Prev: Ediffing,  Up: Inspecting
   4022 
   4023 5.6 References Buffer
   4024 =====================
   4025 
   4026 ‘y’ (‘magit-show-refs’)
   4027      This command lists branches and tags in a dedicated buffer.
   4028 
   4029      However if this command is invoked again from this buffer or if it
   4030      is invoked with a prefix argument, then it acts as a transient
   4031      prefix command, which binds the following suffix commands and some
   4032      infix arguments.
   4033 
   4034    All of the following suffix commands list exactly the same branches
   4035 and tags.  The only difference the optional feature that can be enabled
   4036 by changing the value of ‘magit-refs-show-commit-count’ (see below).
   4037 These commands specify a different branch or commit against which all
   4038 the other references are compared.
   4039 
   4040 ‘y y’ (‘magit-show-refs-head’)
   4041      This command lists branches and tags in a dedicated buffer.  Each
   4042      reference is being compared with ‘HEAD’.
   4043 
   4044 ‘y c’ (‘magit-show-refs-current’)
   4045      This command lists branches and tags in a dedicated buffer.  Each
   4046      reference is being compared with the current branch or ‘HEAD’ if it
   4047      is detached.
   4048 
   4049 ‘y o’ (‘magit-show-refs-other’)
   4050      This command lists branches and tags in a dedicated buffer.  Each
   4051      reference is being compared with a branch read from the user.
   4052 
   4053 ‘y r’ (‘magit-refs-set-show-commit-count’)
   4054      This command changes for which refs the commit count is shown.
   4055 
   4056  -- User Option: magit-refs-show-commit-count
   4057      Whether to show commit counts in Magit-Refs mode buffers.
   4058 
   4059         • ‘all’ Show counts for branches and tags.
   4060         • ‘branch’ Show counts for branches only.
   4061         • ‘nil’ Never show counts.
   4062 
   4063      The default is ‘nil’ because anything else can be very expensive.
   4064 
   4065  -- User Option: magit-refs-pad-commit-counts
   4066      Whether to pad all commit counts on all sides in Magit-Refs mode
   4067      buffers.
   4068 
   4069      If this is nil, then some commit counts are displayed right next to
   4070      one of the branches that appear next to the count, without any
   4071      space in between.  This might look bad if the branch name faces
   4072      look too similar to ‘magit-dimmed’.
   4073 
   4074      If this is non-nil, then spaces are placed on both sides of all
   4075      commit counts.
   4076 
   4077  -- User Option: magit-refs-show-remote-prefix
   4078      Whether to show the remote prefix in lists of remote branches.
   4079 
   4080      Showing the prefix is redundant because the name of the remote is
   4081      already shown in the heading preceding the list of its branches.
   4082 
   4083  -- User Option: magit-refs-primary-column-width
   4084      Width of the primary column in ‘magit-refs-mode’ buffers.  The
   4085      primary column is the column that contains the name of the branch
   4086      that the current row is about.
   4087 
   4088      If this is an integer, then the column is that many columns wide.
   4089      Otherwise it has to be a cons-cell of two integers.  The first
   4090      specifies the minimal width, the second the maximal width.  In that
   4091      case the actual width is determined using the length of the names
   4092      of the shown local branches.  (Remote branches and tags are not
   4093      taken into account when calculating to optimal width.)
   4094 
   4095  -- User Option: magit-refs-focus-column-width
   4096      Width of the focus column in ‘magit-refs-mode’ buffers.
   4097 
   4098      The focus column is the first column, which marks one branch
   4099      (usually the current branch) as the focused branch using ‘*’ or
   4100      ‘@’.  For each other reference, this column optionally shows how
   4101      many commits it is ahead of the focused branch and ‘<’, or if it
   4102      isn’t ahead then the commits it is behind and ‘>’, or if it isn’t
   4103      behind either, then a ‘=’.
   4104 
   4105      This column may also display only ‘*’ or ‘@’ for the focused
   4106      branch, in which case this option is ignored.  Use ‘L v’ to change
   4107      the verbosity of this column.
   4108 
   4109  -- User Option: magit-refs-margin
   4110      This option specifies whether the margin is initially shown in
   4111      Magit-Refs mode buffers and how it is formatted.
   4112 
   4113      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   4114 
   4115         • If INIT is non-nil, then the margin is shown initially.
   4116         • STYLE controls how to format the author or committer date.  It
   4117           can be one of ‘age’ (to show the age of the commit),
   4118           ‘age-abbreviated’ (to abbreviate the time unit to a
   4119           character), or a string (suitable for ‘format-time-string’) to
   4120           show the actual date.  Option
   4121           ‘magit-log-margin-show-committer-date’ controls which date is
   4122           being displayed.
   4123         • WIDTH controls the width of the margin.  This exists for
   4124           forward compatibility and currently the value should not be
   4125           changed.
   4126         • AUTHOR controls whether the name of the author is also shown
   4127           by default.
   4128         • AUTHOR-WIDTH has to be an integer.  When the name of the
   4129           author is shown, then this specifies how much space is used to
   4130           do so.
   4131 
   4132  -- User Option: magit-refs-margin-for-tags
   4133      This option specifies whether to show information about tags in the
   4134      margin.  This is disabled by default because it is slow if there
   4135      are many tags.
   4136 
   4137    The following variables control how individual refs are displayed.
   4138 If you change one of these variables (especially the "%c" part), then
   4139 you should also change the others to keep things aligned.  The following
   4140 %-sequences are supported:
   4141 
   4142    • ‘%a’ Number of commits this ref has over the one we compare to.
   4143    • ‘%b’ Number of commits the ref we compare to has over this one.
   4144    • ‘%c’ Number of commits this ref has over the one we compare to.
   4145      For the ref which all other refs are compared this is instead "@",
   4146      if it is the current branch, or "#" otherwise.
   4147    • ‘%C’ For the ref which all other refs are compared this is "@", if
   4148      it is the current branch, or "#" otherwise.  For all other refs "
   4149      ".
   4150    • ‘%h’ Hash of this ref’s tip.
   4151    • ‘%m’ Commit summary of the tip of this ref.
   4152    • ‘%n’ Name of this ref.
   4153    • ‘%u’ Upstream of this local branch.
   4154    • ‘%U’ Upstream of this local branch and additional local vs.
   4155      upstream information.
   4156 
   4157  -- User Option: magit-refs-filter-alist
   4158      The purpose of this option is to forgo displaying certain refs
   4159      based on their name.  If you want to not display any refs of a
   4160      certain type, then you should remove the appropriate function from
   4161      ‘magit-refs-sections-hook’ instead.
   4162 
   4163      This alist controls which tags and branches are omitted from being
   4164      displayed in ‘magit-refs-mode’ buffers.  If it is ‘nil’, then all
   4165      refs are displayed (subject to ‘magit-refs-sections-hook’).
   4166 
   4167      All keys are tried in order until one matches.  Then its value is
   4168      used and subsequent elements are ignored.  If the value is non-nil,
   4169      then the reference is displayed, otherwise it is not.  If no
   4170      element matches, then the reference is displayed.
   4171 
   4172      A key can either be a regular expression that the refname has to
   4173      match, or a function that takes the refname as only argument and
   4174      returns a boolean.  A remote branch such as "origin/master" is
   4175      displayed as just "master", however for this comparison the former
   4176      is used.
   4177 
   4178 ‘<RET>’ (‘magit-visit-ref’)
   4179      This command visits the reference or revision at point in another
   4180      buffer.  If there is no revision at point or with a prefix argument
   4181      then it prompts for a revision.
   4182 
   4183      This command behaves just like ‘magit-show-commit’ as described
   4184      above, except if point is on a reference in a ‘magit-refs-mode’
   4185      buffer, in which case the behavior may be different, but only if
   4186      you have customized the option ‘magit-visit-ref-behavior’.
   4187 
   4188  -- User Option: magit-visit-ref-behavior
   4189      This option controls how ‘magit-visit-ref’ behaves in
   4190      ‘magit-refs-mode’ buffers.
   4191 
   4192      By default ‘magit-visit-ref’ behaves like ‘magit-show-commit’, in
   4193      all buffers, including ‘magit-refs-mode’ buffers.  When the type of
   4194      the section at point is ‘commit’ then "RET" is bound to
   4195      ‘magit-show-commit’, and when the type is either ‘branch’ or ‘tag’
   4196      then it is bound to ‘magit-visit-ref’.
   4197 
   4198      "RET" is one of Magit’s most essential keys and at least by default
   4199      it should behave consistently across all of Magit, especially
   4200      because users quickly learn that it does something very harmless;
   4201      it shows more information about the thing at point in another
   4202      buffer.
   4203 
   4204      However "RET" used to behave differently in ‘magit-refs-mode’
   4205      buffers, doing surprising things, some of which cannot really be
   4206      described as "visit this thing".  If you’ve grown accustomed this
   4207      behavior, you can restore it by adding one or more of the below
   4208      symbols to the value of this option.  But keep in mind that by
   4209      doing so you don’t only introduce inconsistencies, you also lose
   4210      some functionality and might have to resort to ‘M-x
   4211      magit-show-commit’ to get it back.
   4212 
   4213      ‘magit-visit-ref’ looks for these symbols in the order in which
   4214      they are described here.  If the presence of a symbol applies to
   4215      the current situation, then the symbols that follow do not affect
   4216      the outcome.
   4217 
   4218         • ‘focus-on-ref’
   4219 
   4220           With a prefix argument update the buffer to show commit counts
   4221           and lists of cherry commits relative to the reference at point
   4222           instead of relative to the current buffer or ‘HEAD’.
   4223 
   4224           Instead of adding this symbol, consider pressing "C-u y o
   4225           RET".
   4226 
   4227         • ‘create-branch’
   4228 
   4229           If point is on a remote branch, then create a new local branch
   4230           with the same name, use the remote branch as its upstream, and
   4231           then check out the local branch.
   4232 
   4233           Instead of adding this symbol, consider pressing "b c RET
   4234           RET", like you would do in other buffers.
   4235 
   4236         • ‘checkout-any’
   4237 
   4238           Check out the reference at point.  If that reference is a tag
   4239           or a remote branch, then this results in a detached ‘HEAD’.
   4240 
   4241           Instead of adding this symbol, consider pressing "b b RET",
   4242           like you would do in other buffers.
   4243 
   4244         • ‘checkout-branch’
   4245 
   4246           Check out the local branch at point.
   4247 
   4248           Instead of adding this symbol, consider pressing "b b RET",
   4249           like you would do in other buffers.
   4250 
   4251 * Menu:
   4252 
   4253 * References Sections::
   4254 
   4255 
   4256 File: magit.info,  Node: References Sections,  Up: References Buffer
   4257 
   4258 5.6.1 References Sections
   4259 -------------------------
   4260 
   4261 The contents of references buffers is controlled using the hook
   4262 ‘magit-refs-sections-hook’.  See *note Section Hooks:: to learn about
   4263 such hooks and how to customize them.  All of the below functions are
   4264 members of the default value.  Note that it makes much less sense to
   4265 customize this hook than it does for the respective hook used for the
   4266 status buffer.
   4267 
   4268  -- User Option: magit-refs-sections-hook
   4269      Hook run to insert sections into a references buffer.
   4270 
   4271  -- Function: magit-insert-local-branches
   4272      Insert sections showing all local branches.
   4273 
   4274  -- Function: magit-insert-remote-branches
   4275      Insert sections showing all remote-tracking branches.
   4276 
   4277  -- Function: magit-insert-tags
   4278      Insert sections showing all tags.
   4279 
   4280 
   4281 File: magit.info,  Node: Bisecting,  Next: Visiting Files and Blobs,  Prev: References Buffer,  Up: Inspecting
   4282 
   4283 5.7 Bisecting
   4284 =============
   4285 
   4286 Also see *note (gitman)git-bisect::.
   4287 
   4288 ‘B’ (‘magit-bisect’)
   4289      This transient prefix command binds the following suffix commands
   4290      and displays them in a temporary buffer until a suffix is invoked.
   4291 
   4292    When bisecting is not in progress, then the transient features the
   4293 following suffix commands.
   4294 
   4295 ‘B B’ (‘magit-bisect-start’)
   4296      Start a bisect session.
   4297 
   4298      Bisecting a bug means to find the commit that introduced it.  This
   4299      command starts such a bisect session by asking for a known good
   4300      commit and a known bad commit.  If you’re bisecting a change that
   4301      isn’t a regression, you can select alternate terms that are
   4302      conceptually more fitting than "bad" and "good", but the infix
   4303      arguments to do so are disabled by default.
   4304 
   4305 ‘B s’ (‘magit-bisect-run’)
   4306      Bisect automatically by running commands after each step.
   4307 
   4308    When bisecting in progress, then the transient instead features the
   4309 following suffix commands.
   4310 
   4311 ‘B b’ (‘magit-bisect-bad’)
   4312      Mark the current commit as bad.  Use this after you have asserted
   4313      that the commit does contain the bug in question.
   4314 
   4315 ‘B g’ (‘magit-bisect-good’)
   4316      Mark the current commit as good.  Use this after you have asserted
   4317      that the commit does not contain the bug in question.
   4318 
   4319 ‘B m’ (‘magit-bisect-mark’)
   4320      Mark the current commit with one of the bisect terms.  This command
   4321      provides an alternative to ‘magit-bisect-bad’ and
   4322      ‘magit-bisect-good’ and is useful when using terms other than "bad"
   4323      and "good".  This suffix is disabled by default.
   4324 
   4325 ‘B k’ (‘magit-bisect-skip’)
   4326      Skip the current commit.  Use this if for some reason the current
   4327      commit is not a good one to test.  This command lets Git choose a
   4328      different one.
   4329 
   4330 ‘B r’ (‘magit-bisect-reset’)
   4331      After bisecting, cleanup bisection state and return to original
   4332      ‘HEAD’.
   4333 
   4334    By default the status buffer shows information about the ongoing
   4335 bisect session.
   4336 
   4337  -- User Option: magit-bisect-show-graph
   4338      This option controls whether a graph is displayed for the log of
   4339      commits that still have to be bisected.
   4340 
   4341 
   4342 File: magit.info,  Node: Visiting Files and Blobs,  Next: Blaming,  Prev: Bisecting,  Up: Inspecting
   4343 
   4344 5.8 Visiting Files and Blobs
   4345 ============================
   4346 
   4347 Magit provides several commands that visit a file or blob (the version
   4348 of a file that is stored in a certain commit).  Actually it provides
   4349 several *groups* of such commands and the several *variants* within each
   4350 group.
   4351 
   4352    Also see *note Commands for Buffers Visiting Files::.
   4353 
   4354 * Menu:
   4355 
   4356 * General-Purpose Visit Commands::
   4357 * Visiting Files and Blobs from a Diff::
   4358 
   4359 
   4360 File: magit.info,  Node: General-Purpose Visit Commands,  Next: Visiting Files and Blobs from a Diff,  Up: Visiting Files and Blobs
   4361 
   4362 5.8.1 General-Purpose Visit Commands
   4363 ------------------------------------
   4364 
   4365 These commands can be used anywhere to open any blob.  Currently no keys
   4366 are bound to these commands by default, but that is likely to change.
   4367 
   4368  -- Command: magit-find-file
   4369      This command reads a filename and revision from the user and visits
   4370      the respective blob in a buffer.  The buffer is displayed in the
   4371      selected window.
   4372 
   4373  -- Command: magit-find-file-other-window
   4374      This command reads a filename and revision from the user and visits
   4375      the respective blob in a buffer.  The buffer is displayed in
   4376      another window.
   4377 
   4378  -- Command: magit-find-file-other-frame
   4379      This command reads a filename and revision from the user and visits
   4380      the respective blob in a buffer.  The buffer is displayed in
   4381      another frame.
   4382 
   4383 
   4384 File: magit.info,  Node: Visiting Files and Blobs from a Diff,  Prev: General-Purpose Visit Commands,  Up: Visiting Files and Blobs
   4385 
   4386 5.8.2 Visiting Files and Blobs from a Diff
   4387 ------------------------------------------
   4388 
   4389 These commands can only be used when point is inside a diff.
   4390 
   4391 ‘<RET>’ (‘magit-diff-visit-file’)
   4392      This command visits the appropriate version of the file that the
   4393      diff at point is about.
   4394 
   4395      This commands visits the worktree version of the appropriate file.
   4396      The location of point inside the diff determines which file is
   4397      being visited.  The visited version depends on what changes the
   4398      diff is about.
   4399 
   4400        1. If the diff shows uncommitted changes (i.e., staged or
   4401           unstaged changes), then visit the file in the working tree
   4402           (i.e., the same "real" file that ‘find-file’ would visit.  In
   4403           all other cases visit a "blob" (i.e., the version of a file as
   4404           stored in some commit).
   4405 
   4406        2. If point is on a removed line, then visit the blob for the
   4407           first parent of the commit that removed that line, i.e., the
   4408           last commit where that line still exists.
   4409 
   4410        3. If point is on an added or context line, then visit the blob
   4411           that adds that line, or if the diff shows from more than a
   4412           single commit, then visit the blob from the last of these
   4413           commits.
   4414 
   4415      In the file-visiting buffer this command goes to the line that
   4416      corresponds to the line that point is on in the diff.
   4417 
   4418      The buffer is displayed in the selected window.  With a prefix
   4419      argument the buffer is displayed in another window instead.
   4420 
   4421  -- User Option: magit-diff-visit-previous-blob
   4422      This option controls whether ‘magit-diff-visit-file’ may visit the
   4423      previous blob.  When this is ‘t’ (the default) and point is on a
   4424      removed line in a diff for a committed change, then
   4425      ‘magit-diff-visit-file’ visits the blob from the last revision
   4426      which still had that line.
   4427 
   4428      Currently this is only supported for committed changes, for staged
   4429      and unstaged changes ‘magit-diff-visit-file’ always visits the file
   4430      in the working tree.
   4431 
   4432 ‘C-<return>’ (‘magit-diff-visit-file-worktree’)
   4433      This command visits the worktree version of the appropriate file.
   4434      The location of point inside the diff determines which file is
   4435      being visited.  Unlike ‘magit-diff-visit-file’ it always visits the
   4436      "real" file in the working tree, i.e the "current version" of the
   4437      file.
   4438 
   4439      In the file-visiting buffer this command goes to the line that
   4440      corresponds to the line that point is on in the diff.  Lines that
   4441      were added or removed in the working tree, the index and other
   4442      commits in between are automatically accounted for.
   4443 
   4444      The buffer is displayed in the selected window.  With a prefix
   4445      argument the buffer is displayed in another window instead.
   4446 
   4447    Variants of the above two commands exist that instead visit the file
   4448 in another window or in another frame.  If you prefer such behavior,
   4449 then you may want to change the above key bindings, but note that the
   4450 above commands also use another window when invoked with a prefix
   4451 argument.
   4452 
   4453  -- Command: magit-diff-visit-file-other-window
   4454  -- Command: magit-diff-visit-file-other-frame
   4455  -- Command: magit-diff-visit-worktree-file-other-window
   4456  -- Command: magit-diff-visit-worktree-file-other-frame
   4457 
   4458 
   4459 File: magit.info,  Node: Blaming,  Prev: Visiting Files and Blobs,  Up: Inspecting
   4460 
   4461 5.9 Blaming
   4462 ===========
   4463 
   4464 Also see *note (gitman)git-blame::.
   4465 
   4466    To start blaming, invoke the ‘magit-file-dispatch’ transient prefix
   4467 command.  When using the default key bindings, that can be done by
   4468 pressing ‘C-c M-g’.  When using the recommended bindings, this command
   4469 is instead bound to ‘C-c f’.  Also see *note Global Bindings::.
   4470 
   4471    The blaming suffix commands can be invoked directly from the file
   4472 dispatch transient.  However if you want to set an infix argument, then
   4473 you have to enter the blaming sub-prefix first.
   4474 
   4475 ‘C-c f B’ (‘magit-blame’)
   4476 ‘C-c f b’ (‘magit-blame-addition’)
   4477 ‘C-c f B b’
   4478 ‘C-c f r’ (‘magit-blame-removal’)
   4479 ‘C-c f B r’
   4480 ‘C-c f f’ (‘magit-blame-reverse’)
   4481 ‘C-c f B f’
   4482 ‘C-c f e’ (‘magit-blame-echo’)
   4483 ‘C-c f B e’
   4484 ‘C-c f q’ (‘magit-blame-quit’)
   4485 ‘C-c f B q’
   4486      Each of these commands is documented individually right below,
   4487      alongside their default key bindings.  The bindings shown above are
   4488      the recommended bindings, which you can enable by following the
   4489      instructions in *note Global Bindings::.
   4490 
   4491 ‘C-c M-g B’ (‘magit-blame’)
   4492      This transient prefix command binds the following suffix commands
   4493      along with the appropriate infix arguments and displays them in a
   4494      temporary buffer until a suffix is invoked.
   4495 
   4496    Note that not all of the following suffixes are available at all
   4497 times.  For example if ‘magit-blame-mode’ is not enabled, then the
   4498 command whose purpose is to turn off that mode would not be of any use
   4499 and therefore isn’t available.
   4500 
   4501 ‘C-c M-g b’ (‘magit-blame-addition’)
   4502 ‘C-c M-g B b’
   4503      This command augments each line or chunk of lines in the current
   4504      file-visiting or blob-visiting buffer with information about what
   4505      commits last touched these lines.
   4506 
   4507      If the buffer visits a revision of that file, then history up to
   4508      that revision is considered.  Otherwise, the file’s full history is
   4509      considered, including uncommitted changes.
   4510 
   4511      If Magit-Blame mode is already turned on in the current buffer then
   4512      blaming is done recursively, by visiting REVISION:FILE (using
   4513      ‘magit-find-file’), where REVISION is a parent of the revision that
   4514      added the current line or chunk of lines.
   4515 
   4516 ‘C-c M-g r’ (‘magit-blame-removal’)
   4517 ‘C-c M-g B r’
   4518      This command augments each line or chunk of lines in the current
   4519      blob-visiting buffer with information about the revision that
   4520      removes it.  It cannot be used in file-visiting buffers.
   4521 
   4522      Like ‘magit-blame-addition’, this command can be used recursively.
   4523 
   4524 ‘C-c M-g f’ (‘magit-blame-reverse’)
   4525 ‘C-c M-g B f’
   4526      This command augments each line or chunk of lines in the current
   4527      file-visiting or blob-visiting buffer with information about the
   4528      last revision in which a line still existed.
   4529 
   4530      Like ‘magit-blame-addition’, this command can be used recursively.
   4531 
   4532 ‘C-c M-g e’ (‘magit-blame-echo’)
   4533 ‘C-c M-g B e’
   4534      This command is like ‘magit-blame-addition’ except that it doesn’t
   4535      turn on ‘read-only-mode’ and that it initially uses the
   4536      visualization style specified by option ‘magit-blame-echo-style’.
   4537 
   4538    The following key bindings are available when Magit-Blame mode is
   4539 enabled and Read-Only mode is not enabled.  These commands are also
   4540 available in other buffers; here only the behavior is described that is
   4541 relevant in file-visiting buffers that are being blamed.
   4542 
   4543 ‘C-c M-g q’ (‘magit-blame-quit’)
   4544 ‘C-c M-g B q’
   4545      This command turns off Magit-Blame mode.  If the buffer was created
   4546      during a recursive blame, then it also kills the buffer.
   4547 
   4548 ‘<RET>’ (‘magit-show-commit’)
   4549      This command shows the commit that last touched the line at point.
   4550 
   4551 ‘<SPC>’ (‘magit-diff-show-or-scroll-up’)
   4552      This command updates the commit buffer.
   4553 
   4554      This either shows the commit that last touched the line at point in
   4555      the appropriate buffer, or if that buffer is already being
   4556      displayed in the current frame and if that buffer contains
   4557      information about that commit, then the buffer is scrolled up
   4558      instead.
   4559 
   4560 ‘<DEL>’ (‘magit-diff-show-or-scroll-down’)
   4561      This command updates the commit buffer.
   4562 
   4563      This either shows the commit that last touched the line at point in
   4564      the appropriate buffer, or if that buffer is already being
   4565      displayed in the current frame and if that buffer contains
   4566      information about that commit, then the buffer is scrolled down
   4567      instead.
   4568 
   4569    The following key bindings are available when both Magit-Blame mode
   4570 and Read-Only mode are enabled.
   4571 
   4572 ‘b’ (‘magit-blame’)
   4573      See above.
   4574 
   4575 ‘n’ (‘magit-blame-next-chunk’)
   4576      This command moves to the next chunk.
   4577 
   4578 ‘N’ (‘magit-blame-next-chunk-same-commit’)
   4579      This command moves to the next chunk from the same commit.
   4580 
   4581 ‘p’ (‘magit-blame-previous-chunk’)
   4582      This command moves to the previous chunk.
   4583 
   4584 ‘P’ (‘magit-blame-previous-chunk-same-commit’)
   4585      This command moves to the previous chunk from the same commit.
   4586 
   4587 ‘q’ (‘magit-blame-quit’)
   4588      This command turns off Magit-Blame mode.  If the buffer was created
   4589      during a recursive blame, then it also kills the buffer.
   4590 
   4591 ‘M-w’ (‘magit-blame-copy-hash’)
   4592      This command saves the hash of the current chunk’s commit to the
   4593      kill ring.
   4594 
   4595      When the region is active, the command saves the region’s content
   4596      instead of the hash, like ‘kill-ring-save’ would.
   4597 
   4598 ‘c’ (‘magit-blame-cycle-style’)
   4599      This command changes how blame information is visualized in the
   4600      current buffer by cycling through the styles specified using the
   4601      option ‘magit-blame-styles’.
   4602 
   4603    Blaming is also controlled using the following options.
   4604 
   4605  -- User Option: magit-blame-styles
   4606      This option defines a list of styles used to visualize blame
   4607      information.  For now see its doc-string to learn more.
   4608 
   4609  -- User Option: magit-blame-echo-style
   4610      This option specifies the blame visualization style used by the
   4611      command ‘magit-blame-echo’.  This must be a symbol that is used as
   4612      the identifier for one of the styles defined in
   4613      ‘magit-blame-styles’.
   4614 
   4615  -- User Option: magit-blame-time-format
   4616      This option specifies the format string used to display times when
   4617      showing blame information.
   4618 
   4619  -- User Option: magit-blame-read-only
   4620      This option controls whether blaming a buffer also makes
   4621      temporarily read-only.
   4622 
   4623  -- User Option: magit-blame-disable-modes
   4624      This option lists incompatible minor-modes that should be disabled
   4625      temporarily when a buffer contains blame information.  They are
   4626      enabled again when the buffer no longer shows blame information.
   4627 
   4628  -- User Option: magit-blame-goto-chunk-hook
   4629      This hook is run when moving between chunks.
   4630 
   4631 
   4632 File: magit.info,  Node: Manipulating,  Next: Transferring,  Prev: Inspecting,  Up: Top
   4633 
   4634 6 Manipulating
   4635 **************
   4636 
   4637 * Menu:
   4638 
   4639 * Creating Repository::
   4640 * Cloning Repository::
   4641 * Staging and Unstaging::
   4642 * Applying::
   4643 * Committing::
   4644 * Branching::
   4645 * Merging::
   4646 * Resolving Conflicts::
   4647 * Rebasing::
   4648 * Cherry Picking::
   4649 * Resetting::
   4650 * Stashing::
   4651 
   4652 
   4653 File: magit.info,  Node: Creating Repository,  Next: Cloning Repository,  Up: Manipulating
   4654 
   4655 6.1 Creating Repository
   4656 =======================
   4657 
   4658 ‘I’ (‘magit-init’)
   4659      This command initializes a repository and then shows the status
   4660      buffer for the new repository.
   4661 
   4662      If the directory is below an existing repository, then the user has
   4663      to confirm that a new one should be created inside.  If the
   4664      directory is the root of the existing repository, then the user has
   4665      to confirm that it should be reinitialized.
   4666 
   4667 
   4668 File: magit.info,  Node: Cloning Repository,  Next: Staging and Unstaging,  Prev: Creating Repository,  Up: Manipulating
   4669 
   4670 6.2 Cloning Repository
   4671 ======================
   4672 
   4673 To clone a remote or local repository use ‘C’, which is bound to the
   4674 command ‘magit-clone’.  This command either act as a transient prefix
   4675 command, which binds several infix arguments and suffix commands, or it
   4676 can invoke ‘git clone’ directly, depending on whether a prefix argument
   4677 is used and on the value of ‘magit-clone-always-transient’.
   4678 
   4679  -- User Option: magit-clone-always-transient
   4680      This option controls whether the command ‘magit-clone’ always acts
   4681      as a transient prefix command, regardless of whether a prefix
   4682      argument is used or not.  If ‘t’, then that command always acts as
   4683      a transient prefix.  If ‘nil’, then a prefix argument has to be
   4684      used for it to act as a transient.
   4685 
   4686 ‘C’ (‘magit-clone’)
   4687      This command either acts as a transient prefix command as described
   4688      above or does the same thing as ‘transient-clone-regular’ as
   4689      described below.
   4690 
   4691      If it acts as a transient prefix, then it binds the following
   4692      suffix commands and several infix arguments.
   4693 
   4694 ‘C C’ (‘magit-clone-regular’)
   4695      This command creates a regular clone of an existing repository.
   4696      The repository and the target directory are read from the user.
   4697 
   4698 ‘C s’ (‘magit-clone-shallow’)
   4699      This command creates a shallow clone of an existing repository.
   4700      The repository and the target directory are read from the user.  By
   4701      default the depth of the cloned history is a single commit, but
   4702      with a prefix argument the depth is read from the user.
   4703 
   4704 ‘C >’ (‘magit-clone-sparse’)
   4705      This command creates a clone of an existing repository and
   4706      initializes a sparse checkout, avoiding a checkout of the full
   4707      working tree.  To add more directories, use the
   4708      ‘magit-sparse-checkout’ transient (see *note Sparse checkouts::).
   4709 
   4710 ‘C b’ (‘magit-clone-bare’)
   4711      This command creates a bare clone of an existing repository.  The
   4712      repository and the target directory are read from the user.
   4713 
   4714 ‘C m’ (‘magit-clone-mirror’)
   4715      This command creates a mirror of an existing repository.  The
   4716      repository and the target directory are read from the user.
   4717 
   4718    The following suffixes are disabled by default.  See *note
   4719 (transient)Enabling and Disabling Suffixes:: for how to enable them.
   4720 
   4721 ‘C d’ (‘magit-clone-shallow-since’)
   4722      This command creates a shallow clone of an existing repository.
   4723      Only commits that were committed after a date are cloned, which is
   4724      read from the user.  The repository and the target directory are
   4725      also read from the user.
   4726 
   4727 ‘C e’ (‘magit-clone-shallow-exclude’)
   4728      This command creates a shallow clone of an existing repository.
   4729      This reads a branch or tag from the user.  Commits that are
   4730      reachable from that are not cloned.  The repository and the target
   4731      directory are also read from the user.
   4732 
   4733  -- User Option: magit-clone-set-remote-head
   4734      This option controls whether cloning causes the reference
   4735      ‘refs/remotes/<remote>/HEAD’ to be created in the clone.  The
   4736      default is to delete the reference after running ‘git clone’, which
   4737      insists on creating it.  This is because the reference has not been
   4738      found to be particularly useful as it is not automatically updated
   4739      when the ‘HEAD’ of the remote changes.  Setting this option to ‘t’
   4740      preserves Git’s default behavior of creating the reference.
   4741 
   4742  -- User Option: magit-clone-set-remote.pushDefault
   4743      This option controls whether the value of the Git variable
   4744      ‘remote.pushDefault’ is set after cloning.
   4745 
   4746         • If ‘t’, then it is always set without asking.
   4747         • If ‘ask’, then the users are asked every time they clone a
   4748           repository.
   4749         • If ‘nil’, then it is never set.
   4750 
   4751  -- User Option: magit-clone-default-directory
   4752      This option control the default directory name used when reading
   4753      the destination for a cloning operation.
   4754 
   4755         • If ‘nil’ (the default), then the value of ‘default-directory’
   4756           is used.
   4757         • If a directory, then that is used.
   4758         • If a function, then that is called with the remote url as the
   4759           only argument and the returned value is used.
   4760 
   4761  -- User Option: magit-clone-name-alist
   4762      This option maps regular expressions, which match repository names,
   4763      to repository urls, making it possible for users to enter short
   4764      names instead of urls when cloning repositories.
   4765 
   4766      Each element has the form ‘(REGEXP HOSTNAME USER)’.  When the user
   4767      enters a name when a cloning command asks for a name or url, then
   4768      that is looked up in this list.  The first element whose REGEXP
   4769      matches is used.
   4770 
   4771      The format specified by option ‘magit-clone-url-format’ is used to
   4772      turn the name into an url, using HOSTNAME and the repository name.
   4773      If the provided name contains a slash, then that is used.
   4774      Otherwise if the name omits the owner of the repository, then the
   4775      default user specified in the matched entry is used.
   4776 
   4777      If USER contains a dot, then it is treated as a Git variable and
   4778      the value of that is used as the username.  Otherwise it is used as
   4779      the username itself.
   4780 
   4781  -- User Option: magit-clone-url-format
   4782      The format specified by this option is used when turning repository
   4783      names into urls.  ‘%h’ is the hostname and ‘%n’ is the repository
   4784      name, including the name of the owner.  The value can be a string
   4785      (representing a single static format) or an alist with elements
   4786      ‘(HOSTNAME . FORMAT)’ mapping hostnames to formats.  When an alist
   4787      is used, the ‘t’ key represents the default format.
   4788 
   4789      Example of a single format string:
   4790 
   4791           (setq magit-clone-url-format
   4792                 "git@%h:%n.git")
   4793 
   4794      Example of by-hostname format strings:
   4795 
   4796           (setq magit-clone-url-format
   4797                 '(("git.example.com" . "git@%h:~%n")
   4798                   (nil . "git@%h:%n.git")))
   4799 
   4800  -- User Option: magit-post-clone-hook
   4801      Hook run after the Git process has successfully finished cloning
   4802      the repository.  When the hook is called, ‘default-directory’ is
   4803      let-bound to the directory where the repository has been cloned.
   4804 
   4805 
   4806 File: magit.info,  Node: Staging and Unstaging,  Next: Applying,  Prev: Cloning Repository,  Up: Manipulating
   4807 
   4808 6.3 Staging and Unstaging
   4809 =========================
   4810 
   4811 Like Git, Magit can of course stage and unstage complete files.  Unlike
   4812 Git, it also allows users to gracefully un-/stage individual hunks and
   4813 even just part of a hunk.  To stage individual hunks and parts of hunks
   4814 using Git directly, one has to use the very modal and rather clumsy
   4815 interface of a ‘git add --interactive’ session.
   4816 
   4817    With Magit, on the other hand, one can un-/stage individual hunks by
   4818 just moving point into the respective section inside a diff displayed in
   4819 the status buffer or a separate diff buffer and typing ‘s’ or ‘u’.  To
   4820 operate on just parts of a hunk, mark the changes that should be
   4821 un-/staged using the region and then press the same key that would be
   4822 used to un-/stage.  To stage multiple files or hunks at once use a
   4823 region that starts inside the heading of such a section and ends inside
   4824 the heading of a sibling section of the same type.
   4825 
   4826    Besides staging and unstaging, Magit also provides several other
   4827 "apply variants" that can also operate on a file, multiple files at
   4828 once, a hunk, multiple hunks at once, and on parts of a hunk.  These
   4829 apply variants are described in the next section.
   4830 
   4831    You can also use Ediff to stage and unstage.  See *note Ediffing::.
   4832 
   4833 ‘s’ (‘magit-stage’)
   4834      Add the change at point to the staging area.
   4835 
   4836      With a prefix argument and an untracked file (or files) at point,
   4837      stage the file but not its content.  This makes it possible to
   4838      stage only a subset of the new file’s changes.
   4839 
   4840 ‘S’ (‘magit-stage-modified’)
   4841      Stage all changes to files modified in the worktree.  Stage all new
   4842      content of tracked files and remove tracked files that no longer
   4843      exist in the working tree from the index also.  With a prefix
   4844      argument also stage previously untracked (but not ignored) files.
   4845 
   4846 ‘u’ (‘magit-unstage’)
   4847      Remove the change at point from the staging area.
   4848 
   4849      Only staged changes can be unstaged.  But by default this command
   4850      performs an action that is somewhat similar to unstaging, when it
   4851      is called on a committed change: it reverses the change in the
   4852      index but not in the working tree.
   4853 
   4854 ‘U’ (‘magit-unstage-all’)
   4855      Remove all changes from the staging area.
   4856 
   4857  -- User Option: magit-unstage-committed
   4858      This option controls whether ‘magit-unstage’ "unstages" committed
   4859      changes by reversing them in the index but not the working tree.
   4860      The alternative is to raise an error.
   4861 
   4862 ‘M-x magit-reverse-in-index’
   4863      This command reverses the committed change at point in the index
   4864      but not the working tree.  By default no key is bound directly to
   4865      this command, but it is indirectly called when ‘u’
   4866      (‘magit-unstage’) is pressed on a committed change.
   4867 
   4868      This allows extracting a change from ‘HEAD’, while leaving it in
   4869      the working tree, so that it can later be committed using a
   4870      separate commit.  A typical workflow would be:
   4871 
   4872        1. Optionally make sure that there are no uncommitted changes.
   4873        2. Visit the ‘HEAD’ commit and navigate to the change that should
   4874           not have been included in that commit.
   4875        3. Type ‘u’ (‘magit-unstage’) to reverse it in the index.  This
   4876           assumes that ‘magit-unstage-committed-changes’ is non-nil.
   4877        4. Type ‘c e’ to extend ‘HEAD’ with the staged changes, including
   4878           those that were already staged before.
   4879        5. Optionally stage the remaining changes using ‘s’ or ‘S’ and
   4880           then type ‘c c’ to create a new commit.
   4881 
   4882 ‘M-x magit-reset-index’
   4883      Reset the index to some commit.  The commit is read from the user
   4884      and defaults to the commit at point.  If there is no commit at
   4885      point, then it defaults to ‘HEAD’.
   4886 
   4887 * Menu:
   4888 
   4889 * Staging from File-Visiting Buffers::
   4890 
   4891 
   4892 File: magit.info,  Node: Staging from File-Visiting Buffers,  Up: Staging and Unstaging
   4893 
   4894 6.3.1 Staging from File-Visiting Buffers
   4895 ----------------------------------------
   4896 
   4897 Fine-grained un-/staging has to be done from the status or a diff
   4898 buffer, but it’s also possible to un-/stage all changes made to the file
   4899 visited in the current buffer right from inside that buffer.
   4900 
   4901 ‘M-x magit-stage-file’
   4902      When invoked inside a file-visiting buffer, then stage all changes
   4903      to that file.  In a Magit buffer, stage the file at point if any.
   4904      Otherwise prompt for a file to be staged.  With a prefix argument
   4905      always prompt the user for a file, even in a file-visiting buffer
   4906      or when there is a file section at point.
   4907 
   4908 ‘M-x magit-unstage-file’
   4909      When invoked inside a file-visiting buffer, then unstage all
   4910      changes to that file.  In a Magit buffer, unstage the file at point
   4911      if any.  Otherwise prompt for a file to be unstaged.  With a prefix
   4912      argument always prompt the user for a file, even in a file-visiting
   4913      buffer or when there is a file section at point.
   4914 
   4915 
   4916 File: magit.info,  Node: Applying,  Next: Committing,  Prev: Staging and Unstaging,  Up: Manipulating
   4917 
   4918 6.4 Applying
   4919 ============
   4920 
   4921 Magit provides several "apply variants": stage, unstage, discard,
   4922 reverse, and "regular apply".  At least when operating on a hunk they
   4923 are all implemented using ‘git apply’, which is why they are called
   4924 "apply variants".
   4925 
   4926    • Stage.  Apply a change from the working tree to the index.  The
   4927      change also remains in the working tree.
   4928 
   4929    • Unstage.  Remove a change from the index.  The change remains in
   4930      the working tree.
   4931 
   4932    • Discard.  On a staged change, remove it from the working tree and
   4933      the index.  On an unstaged change, remove it from the working tree
   4934      only.
   4935 
   4936    • Reverse.  Reverse a change in the working tree.  Both committed and
   4937      staged changes can be reversed.  Unstaged changes cannot be
   4938      reversed.  Discard them instead.
   4939 
   4940    • Apply.  Apply a change to the working tree.  Both committed and
   4941      staged changes can be applied.  Unstaged changes cannot be applied
   4942      - as they already have been applied.
   4943 
   4944    The previous section described the staging and unstaging commands.
   4945 What follows are the commands which implement the remaining apply
   4946 variants.
   4947 
   4948 ‘a’ (‘magit-apply’)
   4949      Apply the change at point to the working tree.
   4950 
   4951      With a prefix argument fallback to a 3-way merge.  Doing so causes
   4952      the change to be applied to the index as well.
   4953 
   4954 ‘k’ (‘magit-discard’)
   4955      Remove the change at point from the working tree.
   4956 
   4957      On a hunk or file with unresolved conflicts prompt which side to
   4958      keep (while discarding the other).  If point is within the text of
   4959      a side, then keep that side without prompting.
   4960 
   4961 ‘v’ (‘magit-reverse’)
   4962      Reverse the change at point in the working tree.
   4963 
   4964      With a prefix argument fallback to a 3-way merge.  Doing so causes
   4965      the change to be applied to the index as well.
   4966 
   4967    With a prefix argument all apply variants attempt a 3-way merge when
   4968 appropriate (i.e., when ‘git apply’ is used internally).
   4969 
   4970 
   4971 File: magit.info,  Node: Committing,  Next: Branching,  Prev: Applying,  Up: Manipulating
   4972 
   4973 6.5 Committing
   4974 ==============
   4975 
   4976 When the user initiates a commit, Magit calls ‘git commit’ without any
   4977 arguments, so Git has to get it from the user.  It creates the file
   4978 ‘.git/COMMIT_EDITMSG’ and then opens that file in an editor.  Magit
   4979 arranges for that editor to be the Emacsclient.  Once the user finishes
   4980 the editing session, the Emacsclient exits and Git creates the commit
   4981 using the file’s content as message.
   4982 
   4983 * Menu:
   4984 
   4985 * Initiating a Commit::
   4986 * Editing Commit Messages::
   4987 
   4988 
   4989 File: magit.info,  Node: Initiating a Commit,  Next: Editing Commit Messages,  Up: Committing
   4990 
   4991 6.5.1 Initiating a Commit
   4992 -------------------------
   4993 
   4994 Also see *note (gitman)git-commit::.
   4995 
   4996 ‘c’ (‘magit-commit’)
   4997      This transient prefix command binds the following suffix commands
   4998      along with the appropriate infix arguments and displays them in a
   4999      temporary buffer until a suffix is invoked.
   5000 
   5001 ‘c c’ (‘magit-commit-create’)
   5002      Create a new commit on ‘HEAD’.  With a prefix argument amend to the
   5003      commit at ‘HEAD’ instead.
   5004 
   5005 ‘c a’ (‘magit-commit-amend’)
   5006      Amend the last commit.
   5007 
   5008 ‘c e’ (‘magit-commit-extend’)
   5009      Amend the last commit, without editing the message.  With a prefix
   5010      argument keep the committer date, otherwise change it.  The option
   5011      ‘magit-commit-extend-override-date’ can be used to inverse the
   5012      meaning of the prefix argument.
   5013 
   5014      Non-interactively respect the optional OVERRIDE-DATE argument and
   5015      ignore the option.
   5016 
   5017 ‘c w’ (‘magit-commit-reword’)
   5018      Reword the last commit, ignoring staged changes.  With a prefix
   5019      argument keep the committer date, otherwise change it.  The option
   5020      ‘magit-commit-reword-override-date’ can be used to inverse the
   5021      meaning of the prefix argument.
   5022 
   5023      Non-interactively respect the optional OVERRIDE-DATE argument and
   5024      ignore the option.
   5025 
   5026 ‘c f’ (‘magit-commit-fixup’)
   5027      Create a fixup commit.
   5028 
   5029      With a prefix argument the target commit has to be confirmed.
   5030      Otherwise the commit at point may be used without confirmation
   5031      depending on the value of option ‘magit-commit-squash-confirm’.
   5032 
   5033 ‘c F’ (‘magit-commit-instant-fixup’)
   5034      Create a fixup commit and instantly rebase.
   5035 
   5036 ‘c s’ (‘magit-commit-squash’)
   5037      Create a squash commit, without editing the squash message.
   5038 
   5039      With a prefix argument the target commit has to be confirmed.
   5040      Otherwise the commit at point may be used without confirmation
   5041      depending on the value of option ‘magit-commit-squash-confirm’.
   5042 
   5043 ‘c S’ (‘magit-commit-instant-squash’)
   5044      Create a squash commit and instantly rebase.
   5045 
   5046 ‘c A’ (‘magit-commit-augment’)
   5047      Create a squash commit, editing the squash message.
   5048 
   5049      With a prefix argument the target commit has to be confirmed.
   5050      Otherwise the commit at point may be used without confirmation
   5051      depending on the value of option ‘magit-commit-squash-confirm’.
   5052 
   5053  -- User Option: magit-commit-ask-to-stage
   5054      Whether to ask to stage all unstaged changes when committing and
   5055      nothing is staged.
   5056 
   5057  -- User Option: magit-commit-show-diff
   5058      Whether the relevant diff is automatically shown when committing.
   5059 
   5060  -- User Option: magit-commit-extend-override-date
   5061      Whether using ‘magit-commit-extend’ changes the committer date.
   5062 
   5063  -- User Option: magit-commit-reword-override-date
   5064      Whether using ‘magit-commit-reword’ changes the committer date.
   5065 
   5066  -- User Option: magit-commit-squash-confirm
   5067      Whether the commit targeted by squash and fixup has to be
   5068      confirmed.  When non-nil then the commit at point (if any) is used
   5069      as default choice.  Otherwise it has to be confirmed.  This option
   5070      only affects ‘magit-commit-squash’ and ‘magit-commit-fixup’.  The
   5071      "instant" variants always require confirmation because making an
   5072      error while using those is harder to recover from.
   5073 
   5074  -- User Option: magit-post-commit-hook
   5075      Hook run after creating a commit without the user editing a
   5076      message.
   5077 
   5078      This hook is run by ‘magit-refresh’ if ‘this-command’ is a member
   5079      of ‘magit-post-commit-hook-commands’.  This only includes commands
   5080      named ‘magit-commit-*’ that do *not* require that the user edits
   5081      the commit message in a buffer.
   5082 
   5083      Also see ‘git-commit-post-finish-hook’.
   5084 
   5085  -- User Option: magit-commit-diff-inhibit-same-window
   5086      Whether to inhibit use of same window when showing diff while
   5087      committing.
   5088 
   5089      When writing a commit, then a diff of the changes to be committed
   5090      is automatically shown.  The idea is that the diff is shown in a
   5091      different window of the same frame and for most users that just
   5092      works.  In other words most users can completely ignore this option
   5093      because its value doesn’t make a difference for them.
   5094 
   5095      However for users who configured Emacs to never create a new window
   5096      even when the package explicitly tries to do so, then displaying
   5097      two new buffers necessarily means that the first is immediately
   5098      replaced by the second.  In our case the message buffer is
   5099      immediately replaced by the diff buffer, which is of course highly
   5100      undesirable.
   5101 
   5102      A workaround is to suppress this user configuration in this
   5103      particular case.  Users have to explicitly opt-in by toggling this
   5104      option.  We cannot enable the workaround unconditionally because
   5105      that again causes issues for other users: if the frame is too tiny
   5106      or the relevant settings too aggressive, then the diff buffer would
   5107      end up being displayed in a new frame.
   5108 
   5109      Also see <https://github.com/magit/magit/issues/4132>.
   5110 
   5111 
   5112 File: magit.info,  Node: Editing Commit Messages,  Prev: Initiating a Commit,  Up: Committing
   5113 
   5114 6.5.2 Editing Commit Messages
   5115 -----------------------------
   5116 
   5117 After initiating a commit as described in the previous section, two new
   5118 buffers appear.  One shows the changes that are about to be committed,
   5119 while the other is used to write the message.
   5120 
   5121    Commit messages are edited in an edit session - in the background
   5122 ‘git’ is waiting for the editor, in our case ‘emacsclient’, to save the
   5123 commit message in a file (in most cases ‘.git/COMMIT_EDITMSG’) and then
   5124 return.  If the editor returns with a non-zero exit status then ‘git’
   5125 does not create the commit.  So the most important commands are those
   5126 for finishing and aborting the commit.
   5127 
   5128 ‘C-c C-c’ (‘with-editor-finish’)
   5129      Finish the current editing session by returning with exit code 0.
   5130      Git then creates the commit using the message it finds in the file.
   5131 
   5132 ‘C-c C-k’ (‘with-editor-cancel’)
   5133      Cancel the current editing session by returning with exit code 1.
   5134      Git then cancels the commit, but leaves the file untouched.
   5135 
   5136    In addition to being used by ‘git commit’, messages may also be
   5137 stored in a ring that persists until Emacs is closed.  By default the
   5138 message is stored at the beginning and the end of an edit session
   5139 (regardless of whether the session is finished successfully or was
   5140 canceled).  It is sometimes useful to bring back messages from that
   5141 ring.
   5142 
   5143 ‘C-c M-s’ (‘git-commit-save-message’)
   5144      Save the current buffer content to the commit message ring.
   5145 
   5146 ‘M-p’ (‘git-commit-prev-message’)
   5147      Cycle backward through the commit message ring, after saving the
   5148      current message to the ring.  With a numeric prefix ARG, go back
   5149      ARG comments.
   5150 
   5151 ‘M-n’ (‘git-commit-next-message’)
   5152      Cycle forward through the commit message ring, after saving the
   5153      current message to the ring.  With a numeric prefix ARG, go back
   5154      ARG comments.
   5155 
   5156    By default the diff for the changes that are about to be committed
   5157 are automatically shown when invoking the commit.  To prevent that,
   5158 remove ‘magit-commit-diff’ from ‘server-switch-hook’.
   5159 
   5160    When amending to an existing commit it may be useful to show either
   5161 the changes that are about to be added to that commit or to show those
   5162 changes alongside those that have already been committed.
   5163 
   5164 ‘C-c C-d’ (‘magit-diff-while-committing’)
   5165      While committing, show the changes that are about to be committed.
   5166      While amending, invoking the command again toggles between showing
   5167      just the new changes or all the changes that will be committed.
   5168 
   5169 * Menu:
   5170 
   5171 * Using the Revision Stack::
   5172 * Commit Pseudo Headers::
   5173 * Commit Mode and Hooks::
   5174 * Commit Message Conventions::
   5175 
   5176 
   5177 File: magit.info,  Node: Using the Revision Stack,  Next: Commit Pseudo Headers,  Up: Editing Commit Messages
   5178 
   5179 Using the Revision Stack
   5180 ........................
   5181 
   5182 ‘C-c C-w’ (‘magit-pop-revision-stack’)
   5183      This command inserts a representation of a revision into the
   5184      current buffer.  It can be used inside buffers used to write commit
   5185      messages but also in other buffers such as buffers used to edit
   5186      emails or ChangeLog files.
   5187 
   5188      By default this command pops the revision which was last added to
   5189      the ‘magit-revision-stack’ and inserts it into the current buffer
   5190      according to ‘magit-pop-revision-stack-format’.  Revisions can be
   5191      put on the stack using ‘magit-copy-section-value’ and
   5192      ‘magit-copy-buffer-revision’.
   5193 
   5194      If the stack is empty or with a prefix argument it instead reads a
   5195      revision in the minibuffer.  By using the minibuffer history this
   5196      allows selecting an item which was popped earlier or to insert an
   5197      arbitrary reference or revision without first pushing it onto the
   5198      stack.
   5199 
   5200      When reading the revision from the minibuffer, then it might not be
   5201      possible to guess the correct repository.  When this command is
   5202      called inside a repository (e.g., while composing a commit
   5203      message), then that repository is used.  Otherwise (e.g., while
   5204      composing an email) then the repository recorded for the top
   5205      element of the stack is used (even though we insert another
   5206      revision).  If not called inside a repository and with an empty
   5207      stack, or with two prefix arguments, then read the repository in
   5208      the minibuffer too.
   5209 
   5210  -- User Option: magit-pop-revision-stack-format
   5211      This option controls how the command ‘magit-pop-revision-stack’
   5212      inserts a revision into the current buffer.
   5213 
   5214      The entries on the stack have the format ‘(HASH TOPLEVEL)’ and this
   5215      option has the format ‘(POINT-FORMAT EOB-FORMAT INDEX-REGEXP)’, all
   5216      of which may be nil or a string (though either one of EOB-FORMAT or
   5217      POINT-FORMAT should be a string, and if INDEX-REGEXP is non-nil,
   5218      then the two formats should be too).
   5219 
   5220      First INDEX-REGEXP is used to find the previously inserted entry,
   5221      by searching backward from point.  The first submatch must match
   5222      the index number.  That number is incremented by one, and becomes
   5223      the index number of the entry to be inserted.  If you don’t want to
   5224      number the inserted revisions, then use nil for INDEX-REGEXP.
   5225 
   5226      If INDEX-REGEXP is non-nil then both POINT-FORMAT and EOB-FORMAT
   5227      should contain \"%N\", which is replaced with the number that was
   5228      determined in the previous step.
   5229 
   5230      Both formats, if non-nil and after removing %N, are then expanded
   5231      using ‘git show --format=FORMAT ...’ inside TOPLEVEL.
   5232 
   5233      The expansion of POINT-FORMAT is inserted at point, and the
   5234      expansion of EOB-FORMAT is inserted at the end of the buffer (if
   5235      the buffer ends with a comment, then it is inserted right before
   5236      that).
   5237 
   5238 
   5239 File: magit.info,  Node: Commit Pseudo Headers,  Next: Commit Mode and Hooks,  Prev: Using the Revision Stack,  Up: Editing Commit Messages
   5240 
   5241 Commit Pseudo Headers
   5242 .....................
   5243 
   5244 Some projects use pseudo headers in commit messages.  Magit colorizes
   5245 such headers and provides some commands to insert such headers.
   5246 
   5247  -- User Option: git-commit-known-pseudo-headers
   5248      A list of Git pseudo headers to be highlighted.
   5249 
   5250 ‘C-c C-i’ (‘git-commit-insert-pseudo-header’)
   5251      Insert a commit message pseudo header.
   5252 
   5253 ‘C-c C-a’ (‘git-commit-ack’)
   5254      Insert a header acknowledging that you have looked at the commit.
   5255 
   5256 ‘C-c C-r’ (‘git-commit-review’)
   5257      Insert a header acknowledging that you have reviewed the commit.
   5258 
   5259 ‘C-c C-s’ (‘git-commit-signoff’)
   5260      Insert a header to sign off the commit.
   5261 
   5262 ‘C-c C-t’ (‘git-commit-test’)
   5263      Insert a header acknowledging that you have tested the commit.
   5264 
   5265 ‘C-c C-o’ (‘git-commit-cc’)
   5266      Insert a header mentioning someone who might be interested.
   5267 
   5268 ‘C-c C-p’ (‘git-commit-reported’)
   5269      Insert a header mentioning the person who reported the issue being
   5270      fixed by the commit.
   5271 
   5272 ‘C-c M-i’ (‘git-commit-suggested’)
   5273      Insert a header mentioning the person who suggested the change.
   5274 
   5275 
   5276 File: magit.info,  Node: Commit Mode and Hooks,  Next: Commit Message Conventions,  Prev: Commit Pseudo Headers,  Up: Editing Commit Messages
   5277 
   5278 Commit Mode and Hooks
   5279 .....................
   5280 
   5281 ‘git-commit-mode’ is a minor mode that is only used to establish certain
   5282 key bindings.  This makes it possible to use an arbitrary major mode in
   5283 buffers used to edit commit messages.  It is even possible to use
   5284 different major modes in different repositories, which is useful when
   5285 different projects impose different commit message conventions.
   5286 
   5287  -- User Option: git-commit-major-mode
   5288      The value of this option is the major mode used to edit Git commit
   5289      messages.
   5290 
   5291    Because ‘git-commit-mode’ is a minor mode, we don’t use its mode hook
   5292 to setup the buffer, except for the key bindings.  All other setup
   5293 happens in the function ‘git-commit-setup’, which among other things
   5294 runs the hook ‘git-commit-setup-hook’.
   5295 
   5296  -- User Option: git-commit-setup-hook
   5297      Hook run at the end of ‘git-commit-setup’.
   5298 
   5299 The following functions are suitable for this hook:
   5300 
   5301  -- Function: git-commit-save-message
   5302      Save the current buffer content to the commit message ring.
   5303 
   5304  -- Function: git-commit-setup-changelog-support
   5305      After this function is called, ChangeLog entries are treated as
   5306      paragraphs.
   5307 
   5308  -- Function: git-commit-turn-on-auto-fill
   5309      Turn on ‘auto-fill-mode’.
   5310 
   5311  -- Function: git-commit-turn-on-flyspell
   5312      Turn on Flyspell mode.  Also prevent comments from being checked
   5313      and finally check current non-comment text.
   5314 
   5315  -- Function: git-commit-propertize-diff
   5316      Propertize the diff shown inside the commit message buffer.  Git
   5317      inserts such diffs into the commit message template when the
   5318      ‘--verbose’ argument is used.  ‘magit-commit’ by default does not
   5319      offer that argument because the diff that is shown in a separate
   5320      buffer is more useful.  But some users disagree, which is why this
   5321      function exists.
   5322 
   5323  -- Function: bug-reference-mode
   5324      Hyperlink bug references in the buffer.
   5325 
   5326  -- Function: with-editor-usage-message
   5327      Show usage information in the echo area.
   5328 
   5329  -- User Option: git-commit-post-finish-hook
   5330      Hook run after the user finished writing a commit message.
   5331 
   5332      This hook is only run after pressing ‘C-c C-c’ in a buffer used to
   5333      edit a commit message.  If a commit is created without the user
   5334      typing a message into a buffer, then this hook is not run.
   5335 
   5336      This hook is not run until the new commit has been created.  If
   5337      doing so takes Git longer than one second, then this hook isn’t run
   5338      at all.  For certain commands such as ‘magit-rebase-continue’ this
   5339      hook is never run because doing so would lead to a race condition.
   5340 
   5341      This hook is only run if ‘magit’ is available.
   5342 
   5343      Also see ‘magit-post-commit-hook’.
   5344 
   5345 
   5346 File: magit.info,  Node: Commit Message Conventions,  Prev: Commit Mode and Hooks,  Up: Editing Commit Messages
   5347 
   5348 Commit Message Conventions
   5349 ..........................
   5350 
   5351 Git-Commit highlights certain violations of commonly accepted commit
   5352 message conventions.  Certain violations even cause Git-Commit to ask
   5353 you to confirm that you really want to do that.  This nagging can of
   5354 course be turned off, but the result of doing that usually is that
   5355 instead of some code it’s now the human who is reviewing your commits
   5356 who has to waste some time telling you to fix your commits.
   5357 
   5358  -- User Option: git-commit-summary-max-length
   5359      The intended maximal length of the summary line of commit messages.
   5360      Characters beyond this column are colorized to indicate that this
   5361      preference has been violated.
   5362 
   5363  -- User Option: git-commit-finish-query-functions
   5364      List of functions called to query before performing commit.
   5365 
   5366      The commit message buffer is current while the functions are
   5367      called.  If any of them returns nil, then the commit is not
   5368      performed and the buffer is not killed.  The user should then fix
   5369      the issue and try again.
   5370 
   5371      The functions are called with one argument.  If it is non-nil then
   5372      that indicates that the user used a prefix argument to force
   5373      finishing the session despite issues.  Functions should usually
   5374      honor this wish and return non-nil.
   5375 
   5376      By default the only member is ‘git-commit-check-style-conventions’.
   5377 
   5378  -- Function: git-commit-check-style-conventions
   5379      This function checks for violations of certain basic style
   5380      conventions.  For each violation it asks users if they want to
   5381      proceed anyway.
   5382 
   5383  -- User Option: git-commit-style-convention-checks
   5384      This option controls what conventions the function by the same name
   5385      tries to enforce.  The value is a list of self-explanatory symbols
   5386      identifying certain conventions; ‘non-empty-second-line’ and
   5387      ‘overlong-summary-line’.
   5388 
   5389 
   5390 File: magit.info,  Node: Branching,  Next: Merging,  Prev: Committing,  Up: Manipulating
   5391 
   5392 6.6 Branching
   5393 =============
   5394 
   5395 * Menu:
   5396 
   5397 * The Two Remotes::
   5398 * Branch Commands::
   5399 * Branch Git Variables::
   5400 * Auxiliary Branch Commands::
   5401 
   5402 
   5403 File: magit.info,  Node: The Two Remotes,  Next: Branch Commands,  Up: Branching
   5404 
   5405 6.6.1 The Two Remotes
   5406 ---------------------
   5407 
   5408 The upstream branch of some local branch is the branch into which the
   5409 commits on that local branch should eventually be merged, usually
   5410 something like ‘origin/master’.  For the ‘master’ branch itself the
   5411 upstream branch and the branch it is being pushed to, are usually the
   5412 same remote branch.  But for a feature branch the upstream branch and
   5413 the branch it is being pushed to should differ.
   5414 
   5415    The commits on feature branches too should _eventually_ end up in a
   5416 remote branch such as ‘origin/master’ or ‘origin/maint’.  Such a branch
   5417 should therefore be used as the upstream.  But feature branches
   5418 shouldn’t be pushed directly to such branches.  Instead a feature branch
   5419 ‘my-feature’ is usually pushed to ‘my-fork/my-feature’ or if you are a
   5420 contributor ‘origin/my-feature’.  After the new feature has been
   5421 reviewed, the maintainer merges the feature into ‘master’.  And finally
   5422 ‘master’ (not ‘my-feature’ itself) is pushed to ‘origin/master’.
   5423 
   5424    But new features seldom are perfect on the first try, and so feature
   5425 branches usually have to be reviewed, improved, and re-pushed several
   5426 times.  Pushing should therefore be easy to do, and for that reason many
   5427 Git users have concluded that it is best to use the remote branch to
   5428 which the local feature branch is being pushed as its upstream.
   5429 
   5430    But luckily Git has long ago gained support for a push-remote which
   5431 can be configured separately from the upstream branch, using the
   5432 variables ‘branch.<name>.pushRemote’ and ‘remote.pushDefault’.  So we no
   5433 longer have to choose which of the two remotes should be used as "the
   5434 remote".
   5435 
   5436    Each of the fetching, pulling, and pushing transient commands
   5437 features three suffix commands that act on the current branch and some
   5438 other branch.  Of these, ‘p’ is bound to a command which acts on the
   5439 push-remote, ‘u’ is bound to a command which acts on the upstream, and
   5440 ‘e’ is bound to a command which acts on any other branch.  The status
   5441 buffer shows unpushed and unpulled commits for both the push-remote and
   5442 the upstream.
   5443 
   5444    It’s fairly simple to configure these two remotes.  The values of all
   5445 the variables that are related to fetching, pulling, and pushing (as
   5446 well as some other branch-related variables) can be inspected and
   5447 changed using the command ‘magit-branch-configure’, which is available
   5448 from many transient prefix commands that deal with branches.  It is also
   5449 possible to set the push-remote or upstream while pushing (see *note
   5450 Pushing::).
   5451 
   5452 
   5453 File: magit.info,  Node: Branch Commands,  Next: Branch Git Variables,  Prev: The Two Remotes,  Up: Branching
   5454 
   5455 6.6.2 Branch Commands
   5456 ---------------------
   5457 
   5458 The transient prefix command ‘magit-branch’ is used to create and
   5459 checkout branches, and to make changes to existing branches.  It is not
   5460 used to fetch, pull, merge, rebase, or push branches, i.e., this command
   5461 deals with branches themselves, not with the commits reachable from
   5462 them.  Those features are available from separate transient command.
   5463 
   5464 ‘b’ (‘magit-branch’)
   5465      This transient prefix command binds the following suffix commands
   5466      and displays them in a temporary buffer until a suffix is invoked.
   5467 
   5468      By default it also binds and displays the values of some
   5469      branch-related Git variables and allows changing their values.
   5470 
   5471  -- User Option: magit-branch-direct-configure
   5472      This option controls whether the transient command ‘magit-branch’
   5473      can be used to directly change the values of Git variables.  This
   5474      defaults to ‘t’ (to avoid changing key bindings).  When set to
   5475      ‘nil’, then no variables are displayed by that transient command,
   5476      and its suffix command ‘magit-branch-configure’ has to be used
   5477      instead to view and change branch related variables.
   5478 
   5479 ‘b C’ (‘magit-branch-configure’)
   5480 ‘f C’
   5481 ‘F C’
   5482 ‘P C’
   5483      This transient prefix command binds commands that set the value of
   5484      branch-related variables and displays them in a temporary buffer
   5485      until the transient is exited.
   5486 
   5487      With a prefix argument, this command always prompts for a branch.
   5488 
   5489      Without a prefix argument this depends on whether it was invoked as
   5490      a suffix of ‘magit-branch’ and on the
   5491      ‘magit-branch-direct-configure’ option.  If ‘magit-branch’ already
   5492      displays the variables for the current branch, then it isn’t useful
   5493      to invoke another transient that displays them for the same branch.
   5494      In that case this command prompts for a branch.
   5495 
   5496    The variables are described in *note Branch Git Variables::.
   5497 
   5498 ‘b b’ (‘magit-checkout’)
   5499      Checkout a revision read in the minibuffer and defaulting to the
   5500      branch or arbitrary revision at point.  If the revision is a local
   5501      branch then that becomes the current branch.  If it is something
   5502      else then ‘HEAD’ becomes detached.  Checkout fails if the working
   5503      tree or the staging area contain changes.
   5504 
   5505 ‘b n’ (‘magit-branch-create’)
   5506      Create a new branch.  The user is asked for a branch or arbitrary
   5507      revision to use as the starting point of the new branch.  When a
   5508      branch name is provided, then that becomes the upstream branch of
   5509      the new branch.  The name of the new branch is also read in the
   5510      minibuffer.
   5511 
   5512      Also see option ‘magit-branch-prefer-remote-upstream’.
   5513 
   5514 ‘b c’ (‘magit-branch-and-checkout’)
   5515      This command creates a new branch like ‘magit-branch-create’, but
   5516      then also checks it out.
   5517 
   5518      Also see option ‘magit-branch-prefer-remote-upstream’.
   5519 
   5520 ‘b l’ (‘magit-branch-checkout’)
   5521      This command checks out an existing or new local branch.  It reads
   5522      a branch name from the user offering all local branches and a
   5523      subset of remote branches as candidates.  Remote branches for which
   5524      a local branch by the same name exists are omitted from the list of
   5525      candidates.  The user can also enter a completely new branch name.
   5526 
   5527         • If the user selects an existing local branch, then that is
   5528           checked out.
   5529 
   5530         • If the user selects a remote branch, then it creates and
   5531           checks out a new local branch with the same name, and
   5532           configures the selected remote branch as the push target.
   5533 
   5534         • If the user enters a new branch name, then it creates and
   5535           checks that out, after also reading the starting-point from
   5536           the user.
   5537 
   5538      In the latter two cases the upstream is also set.  Whether it is
   5539      set to the chosen starting point or something else depends on the
   5540      value of ‘magit-branch-adjust-remote-upstream-alist’.
   5541 
   5542 ‘b s’ (‘magit-branch-spinoff’)
   5543      This command creates and checks out a new branch starting at and
   5544      tracking the current branch.  That branch in turn is reset to the
   5545      last commit it shares with its upstream.  If the current branch has
   5546      no upstream or no unpushed commits, then the new branch is created
   5547      anyway and the previously current branch is not touched.
   5548 
   5549      This is useful to create a feature branch after work has already
   5550      began on the old branch (likely but not necessarily "master").
   5551 
   5552      If the current branch is a member of the value of option
   5553      ‘magit-branch-prefer-remote-upstream’ (which see), then the current
   5554      branch will be used as the starting point as usual, but the
   5555      upstream of the starting-point may be used as the upstream of the
   5556      new branch, instead of the starting-point itself.
   5557 
   5558      If optional FROM is non-nil, then the source branch is reset to
   5559      ‘FROM~’, instead of to the last commit it shares with its upstream.
   5560      Interactively, FROM is only ever non-nil, if the region selects
   5561      some commits, and among those commits, FROM is the commit that is
   5562      the fewest commits ahead of the source branch.
   5563 
   5564      The commit at the other end of the selection actually does not
   5565      matter, all commits between FROM and ‘HEAD’ are moved to the new
   5566      branch.  If FROM is not reachable from ‘HEAD’ or is reachable from
   5567      the source branch’s upstream, then an error is raised.
   5568 
   5569 ‘b S’ (‘magit-branch-spinout’)
   5570      This command behaves like ‘magit-branch-spinoff’, except that it
   5571      does not change the current branch.  If there are any uncommitted
   5572      changes, then it behaves exactly like ‘magit-branch-spinoff’.
   5573 
   5574 ‘b x’ (‘magit-branch-reset’)
   5575      This command resets a branch, defaulting to the branch at point, to
   5576      the tip of another branch or any other commit.
   5577 
   5578      When the branch being reset is the current branch, then a hard
   5579      reset is performed.  If there are any uncommitted changes, then the
   5580      user has to confirm the reset because those changes would be lost.
   5581 
   5582      This is useful when you have started work on a feature branch but
   5583      realize it’s all crap and want to start over.
   5584 
   5585      When resetting to another branch and a prefix argument is used,
   5586      then the target branch is set as the upstream of the branch that is
   5587      being reset.
   5588 
   5589 ‘b k’ (‘magit-branch-delete’)
   5590      Delete one or multiple branches.  If the region marks multiple
   5591      branches, then offer to delete those.  Otherwise, prompt for a
   5592      single branch to be deleted, defaulting to the branch at point.
   5593 
   5594      Require confirmation when deleting branches is dangerous in some
   5595      way.  Option ‘magit-no-confirm’ can be customized to not require
   5596      confirmation in certain cases.  See its docstring to learn why
   5597      confirmation is required by default in certain cases or if a prompt
   5598      is confusing.
   5599 
   5600 ‘b m’ (‘magit-branch-rename’)
   5601      Rename a branch.  The branch and the new name are read in the
   5602      minibuffer.  With prefix argument the branch is renamed even if
   5603      that name conflicts with an existing branch.
   5604 
   5605  -- User Option: magit-branch-read-upstream-first
   5606      When creating a branch, whether to read the upstream branch before
   5607      the name of the branch that is to be created.  The default is ‘t’,
   5608      and I recommend you leave it at that.
   5609 
   5610  -- User Option: magit-branch-prefer-remote-upstream
   5611      This option specifies whether remote upstreams are favored over
   5612      local upstreams when creating new branches.
   5613 
   5614      When a new branch is created, then the branch, commit, or stash at
   5615      point is suggested as the starting point of the new branch, or if
   5616      there is no such revision at point the current branch.  In either
   5617      case the user may choose another starting point.
   5618 
   5619      If the chosen starting point is a branch, then it may also be set
   5620      as the upstream of the new branch, depending on the value of the
   5621      Git variable ‘branch.autoSetupMerge’.  By default this is done for
   5622      remote branches, but not for local branches.
   5623 
   5624      You might prefer to always use some remote branch as upstream.  If
   5625      the chosen starting point is (1) a local branch, (2) whose name
   5626      matches a member of the value of this option, (3) the upstream of
   5627      that local branch is a remote branch with the same name, and (4)
   5628      that remote branch can be fast-forwarded to the local branch, then
   5629      the chosen branch is used as starting point, but its own upstream
   5630      is used as the upstream of the new branch.
   5631 
   5632      Members of this option’s value are treated as branch names that
   5633      have to match exactly unless they contain a character that makes
   5634      them invalid as a branch name.  Recommended characters to use to
   5635      trigger interpretation as a regexp are "*" and "^".  Some other
   5636      characters which you might expect to be invalid, actually are not,
   5637      e.g., ".+$" are all perfectly valid.  More precisely, if ‘git
   5638      check-ref-format --branch STRING’ exits with a non-zero status,
   5639      then treat STRING as a regexp.
   5640 
   5641      Assuming the chosen branch matches these conditions you would end
   5642      up with with e.g.:
   5643 
   5644           feature --upstream--> origin/master
   5645 
   5646      instead of
   5647 
   5648           feature --upstream--> master --upstream--> origin/master
   5649 
   5650      Which you prefer is a matter of personal preference.  If you do
   5651      prefer the former, then you should add branches such as ‘master’,
   5652      ‘next’, and ‘maint’ to the value of this options.
   5653 
   5654  -- User Option: magit-branch-adjust-remote-upstream-alist
   5655      The value of this option is an alist of branches to be used as the
   5656      upstream when branching a remote branch.
   5657 
   5658      When creating a local branch from an ephemeral branch located on a
   5659      remote, e.g., a feature or hotfix branch, then that remote branch
   5660      should usually not be used as the upstream branch, since the
   5661      push-remote already allows accessing it and having both the
   5662      upstream and the push-remote reference the same related branch
   5663      would be wasteful.  Instead a branch like "maint" or "master"
   5664      should be used as the upstream.
   5665 
   5666      This option allows specifying the branch that should be used as the
   5667      upstream when branching certain remote branches.  The value is an
   5668      alist of the form ‘((UPSTREAM . RULE)...)’.  The first matching
   5669      element is used, the following elements are ignored.
   5670 
   5671      UPSTREAM is the branch to be used as the upstream for branches
   5672      specified by RULE.  It can be a local or a remote branch.
   5673 
   5674      RULE can either be a regular expression, matching branches whose
   5675      upstream should be the one specified by UPSTREAM.  Or it can be a
   5676      list of the only branches that should *not* use UPSTREAM; all other
   5677      branches will.  Matching is done after stripping the remote part of
   5678      the name of the branch that is being branched from.
   5679 
   5680      If you use a finite set of non-ephemeral branches across all your
   5681      repositories, then you might use something like:
   5682 
   5683           (("origin/master" . ("master" "next" "maint")))
   5684 
   5685      Or if the names of all your ephemeral branches contain a slash, at
   5686      least in some repositories, then a good value could be:
   5687 
   5688           (("origin/master" . "/"))
   5689 
   5690      Of course you can also fine-tune:
   5691 
   5692           (("origin/maint" . "\\`hotfix/")
   5693            ("origin/master" . "\\`feature/"))
   5694 
   5695      UPSTREAM can be a local branch:
   5696 
   5697           (("master" . ("master" "next" "maint")))
   5698 
   5699    Because the main branch is no longer almost always named "master" you
   5700 should also account for other common names:
   5701 
   5702      (("main"  . ("main" "master" "next" "maint"))
   5703       ("master" . ("main" "master" "next" "maint")))
   5704 
   5705  -- Command: magit-branch-orphan
   5706      This command creates and checks out a new orphan branch with
   5707      contents from a given revision.
   5708 
   5709  -- Command: magit-branch-or-checkout
   5710      This command is a hybrid between ‘magit-checkout’ and
   5711      ‘magit-branch-and-checkout’ and is intended as a replacement for
   5712      the former in ‘magit-branch’.
   5713 
   5714      It first asks the user for an existing branch or revision.  If the
   5715      user input actually can be resolved as a branch or revision, then
   5716      it checks that out, just like ‘magit-checkout’ would.
   5717 
   5718      Otherwise it creates and checks out a new branch using the input as
   5719      its name.  Before doing so it reads the starting-point for the new
   5720      branch.  This is similar to what ‘magit-branch-and-checkout’ does.
   5721 
   5722      To use this command instead of ‘magit-checkout’ add this to your
   5723      init file:
   5724 
   5725           (transient-replace-suffix 'magit-branch 'magit-checkout
   5726             '("b" "dwim" magit-branch-or-checkout))
   5727 
   5728 
   5729 File: magit.info,  Node: Branch Git Variables,  Next: Auxiliary Branch Commands,  Prev: Branch Commands,  Up: Branching
   5730 
   5731 6.6.3 Branch Git Variables
   5732 --------------------------
   5733 
   5734 These variables can be set from the transient prefix command
   5735 ‘magit-branch-configure’.  By default they can also be set from
   5736 ‘magit-branch’.  See *note Branch Commands::.
   5737 
   5738  -- Variable: branch.NAME.merge
   5739      Together with ‘branch.NAME.remote’ this variable defines the
   5740      upstream branch of the local branch named NAME.  The value of this
   5741      variable is the full reference of the upstream _branch_.
   5742 
   5743  -- Variable: branch.NAME.remote
   5744      Together with ‘branch.NAME.merge’ this variable defines the
   5745      upstream branch of the local branch named NAME.  The value of this
   5746      variable is the name of the upstream _remote_.
   5747 
   5748  -- Variable: branch.NAME.rebase
   5749      This variable controls whether pulling into the branch named NAME
   5750      is done by rebasing or by merging the fetched branch.
   5751 
   5752         • When ‘true’ then pulling is done by rebasing.
   5753         • When ‘false’ then pulling is done by merging.
   5754         • When undefined then the value of ‘pull.rebase’ is used.  The
   5755           default of that variable is ‘false’.
   5756 
   5757  -- Variable: branch.NAME.pushRemote
   5758      This variable specifies the remote that the branch named NAME is
   5759      usually pushed to.  The value has to be the name of an existing
   5760      remote.
   5761 
   5762      It is not possible to specify the name of _branch_ to push the
   5763      local branch to.  The name of the remote branch is always the same
   5764      as the name of the local branch.
   5765 
   5766      If this variable is undefined but ‘remote.pushDefault’ is defined,
   5767      then the value of the latter is used.  By default
   5768      ‘remote.pushDefault’ is undefined.
   5769 
   5770  -- Variable: branch.NAME.description
   5771      This variable can be used to describe the branch named NAME.  That
   5772      description is used, e.g., when turning the branch into a series of
   5773      patches.
   5774 
   5775    The following variables specify defaults which are used if the above
   5776 branch-specific variables are not set.
   5777 
   5778  -- Variable: pull.rebase
   5779      This variable specifies whether pulling is done by rebasing or by
   5780      merging.  It can be overwritten using ‘branch.NAME.rebase’.
   5781 
   5782         • When ‘true’ then pulling is done by rebasing.
   5783         • When ‘false’ (the default) then pulling is done by merging.
   5784 
   5785      Since it is never a good idea to merge the upstream branch into a
   5786      feature or hotfix branch and most branches are such branches, you
   5787      should consider setting this to ‘true’, and ‘branch.master.rebase’
   5788      to ‘false’.
   5789 
   5790  -- Variable: remote.pushDefault
   5791      This variable specifies what remote the local branches are usually
   5792      pushed to.  This can be overwritten per branch using
   5793      ‘branch.NAME.pushRemote’.
   5794 
   5795    The following variables are used during the creation of a branch and
   5796 control whether the various branch-specific variables are automatically
   5797 set at this time.
   5798 
   5799  -- Variable: branch.autoSetupMerge
   5800      This variable specifies under what circumstances creating a branch
   5801      NAME should result in the variables ‘branch.NAME.merge’ and
   5802      ‘branch.NAME.remote’ being set according to the starting point used
   5803      to create the branch.  If the starting point isn’t a branch, then
   5804      these variables are never set.
   5805 
   5806         • When ‘always’ then the variables are set regardless of whether
   5807           the starting point is a local or a remote branch.
   5808         • When ‘true’ (the default) then the variables are set when the
   5809           starting point is a remote branch, but not when it is a local
   5810           branch.
   5811         • When ‘false’ then the variables are never set.
   5812 
   5813  -- Variable: branch.autoSetupRebase
   5814      This variable specifies whether creating a branch NAME should
   5815      result in the variable ‘branch.NAME.rebase’ being set to ‘true’.
   5816 
   5817         • When ‘always’ then the variable is set regardless of whether
   5818           the starting point is a local or a remote branch.
   5819         • When ‘local’ then the variable are set when the starting point
   5820           is a local branch, but not when it is a remote branch.
   5821         • When ‘remote’ then the variable are set when the starting
   5822           point is a remote branch, but not when it is a local branch.
   5823         • When ‘never’ (the default) then the variable is never set.
   5824 
   5825    Note that the respective commands always change the repository-local
   5826 values.  If you want to change the global value, which is used when the
   5827 local value is undefined, then you have to do so on the command line,
   5828 e.g.:
   5829 
   5830      git config --global remote.autoSetupMerge always
   5831 
   5832    For more information about these variables you should also see *note
   5833 (gitman)git-config::.  Also see *note (gitman)git-branch::.  , *note
   5834 (gitman)git-checkout::.  and *note Pushing::.
   5835 
   5836  -- User Option: magit-prefer-remote-upstream
   5837      This option controls whether commands that read a branch from the
   5838      user and then set it as the upstream branch, offer a local or a
   5839      remote branch as default completion candidate, when they have the
   5840      choice.
   5841 
   5842      This affects all commands that use ‘magit-read-upstream-branch’ or
   5843      ‘magit-read-starting-point’, which includes all commands that
   5844      change the upstream and many which create new branches.
   5845 
   5846 
   5847 File: magit.info,  Node: Auxiliary Branch Commands,  Prev: Branch Git Variables,  Up: Branching
   5848 
   5849 6.6.4 Auxiliary Branch Commands
   5850 -------------------------------
   5851 
   5852 These commands are not available from the transient ‘magit-branch’ by
   5853 default.
   5854 
   5855  -- Command: magit-branch-shelve
   5856      This command shelves a branch.  This is done by deleting the
   5857      branch, and creating a new reference "refs/shelved/BRANCH-NAME"
   5858      pointing at the same commit as the branch pointed at.  If the
   5859      deleted branch had a reflog, then that is preserved as the reflog
   5860      of the new reference.
   5861 
   5862      This is useful if you want to move a branch out of sight, but are
   5863      not ready to completely discard it yet.
   5864 
   5865  -- Command: magit-branch-unshelve
   5866      This command unshelves a branch that was previously shelved using
   5867      ‘magit-branch-shelve’.  This is done by deleting the reference
   5868      "refs/shelved/BRANCH-NAME" and creating a branch "BRANCH-NAME"
   5869      pointing at the same commit as the deleted reference pointed at.
   5870      If the deleted reference had a reflog, then that is restored as the
   5871      reflog of the branch.
   5872 
   5873 
   5874 File: magit.info,  Node: Merging,  Next: Resolving Conflicts,  Prev: Branching,  Up: Manipulating
   5875 
   5876 6.7 Merging
   5877 ===========
   5878 
   5879 Also see *note (gitman)git-merge::.  For information on how to resolve
   5880 merge conflicts see the next section.
   5881 
   5882 ‘m’ (‘magit-merge’)
   5883      This transient prefix command binds the following suffix commands
   5884      along with the appropriate infix arguments and displays them in a
   5885      temporary buffer until a suffix is invoked.
   5886 
   5887    When no merge is in progress, then the transient features the
   5888 following suffix commands.
   5889 
   5890 ‘m m’ (‘magit-merge-plain’)
   5891      This command merges another branch or an arbitrary revision into
   5892      the current branch.  The branch or revision to be merged is read in
   5893      the minibuffer and defaults to the branch at point.
   5894 
   5895      Unless there are conflicts or a prefix argument is used, then the
   5896      resulting merge commit uses a generic commit message, and the user
   5897      does not get a chance to inspect or change it before the commit is
   5898      created.  With a prefix argument this does not actually create the
   5899      merge commit, which makes it possible to inspect how conflicts were
   5900      resolved and to adjust the commit message.
   5901 
   5902 ‘m e’ (‘magit-merge-editmsg’)
   5903      This command merges another branch or an arbitrary revision into
   5904      the current branch and opens a commit message buffer, so that the
   5905      user can make adjustments.  The commit is not actually created
   5906      until the user finishes with ‘C-c C-c’.
   5907 
   5908 ‘m n’ (‘magit-merge-nocommit’)
   5909      This command merges another branch or an arbitrary revision into
   5910      the current branch, but does not actually create the merge commit.
   5911      The user can then further adjust the merge, even when automatic
   5912      conflict resolution succeeded and/or adjust the commit message.
   5913 
   5914 ‘m a’ (‘magit-merge-absorb’)
   5915      This command merges another local branch into the current branch
   5916      and then removes the former.
   5917 
   5918      Before the source branch is merged, it is first force pushed to its
   5919      push-remote, provided the respective remote branch already exists.
   5920      This ensures that the respective pull-request (if any) won’t get
   5921      stuck on some obsolete version of the commits that are being
   5922      merged.  Finally, if ‘magit-branch-pull-request’ was used to create
   5923      the merged branch, then the respective remote branch is also
   5924      removed.
   5925 
   5926 ‘m i’ (‘magit-merge-into’)
   5927      This command merges the current branch into another local branch
   5928      and then removes the former.  The latter becomes the new current
   5929      branch.
   5930 
   5931      Before the source branch is merged, it is first force pushed to its
   5932      push-remote, provided the respective remote branch already exists.
   5933      This ensures that the respective pull-request (if any) won’t get
   5934      stuck on some obsolete version of the commits that are being
   5935      merged.  Finally, if ‘magit-branch-pull-request’ was used to create
   5936      the merged branch, then the respective remote branch is also
   5937      removed.
   5938 
   5939 ‘m s’ (‘magit-merge-squash’)
   5940      This command squashes the changes introduced by another branch or
   5941      an arbitrary revision into the current branch.  This only applies
   5942      the changes made by the squashed commits.  No information is
   5943      preserved that would allow creating an actual merge commit.
   5944      Instead of this command you should probably use a command from the
   5945      apply transient.
   5946 
   5947 ‘m p’ (‘magit-merge-preview’)
   5948      This command shows a preview of merging another branch or an
   5949      arbitrary revision into the current branch.
   5950 
   5951      Note that commands, that normally change how a diff is displayed,
   5952      do not work in buffers created by this command, because the
   5953      underlying Git command does not support diff arguments.
   5954 
   5955    When a merge is in progress, then the transient instead features the
   5956 following suffix commands.
   5957 
   5958 ‘m m’ (‘magit-merge’)
   5959      After the user resolved conflicts, this command proceeds with the
   5960      merge.  If some conflicts weren’t resolved, then this command
   5961      fails.
   5962 
   5963 ‘m a’ (‘magit-merge-abort’)
   5964      This command aborts the current merge operation.
   5965 
   5966 
   5967 File: magit.info,  Node: Resolving Conflicts,  Next: Rebasing,  Prev: Merging,  Up: Manipulating
   5968 
   5969 6.8 Resolving Conflicts
   5970 =======================
   5971 
   5972 When merging branches (or otherwise combining or changing history)
   5973 conflicts can occur.  If you edited two completely different parts of
   5974 the same file in two branches and then merge one of these branches into
   5975 the other, then Git can resolve that on its own, but if you edit the
   5976 same area of a file, then a human is required to decide how the two
   5977 versions, or "sides of the conflict", are to be combined into one.
   5978 
   5979    Here we can only provide a brief introduction to the subject and
   5980 point you toward some tools that can help.  If you are new to this, then
   5981 please also consult Git’s own documentation as well as other resources.
   5982 
   5983    If a file has conflicts and Git cannot resolve them by itself, then
   5984 it puts both versions into the affected file along with special markers
   5985 whose purpose is to denote the boundaries of the unresolved part of the
   5986 file and between the different versions.  These boundary lines begin
   5987 with the strings consisting of seven times the same character, one of
   5988 ‘<’, ‘|’, ‘=’ and ‘>’, and are followed by information about the source
   5989 of the respective versions, e.g.:
   5990 
   5991      <<<<<<< HEAD
   5992      Take the blue pill.
   5993      =======
   5994      Take the red pill.
   5995      >>>>>>> feature
   5996 
   5997    In this case you have chosen to take the red pill on one branch and
   5998 on another you picked the blue pill.  Now that you are merging these two
   5999 diverging branches, Git cannot possibly know which pill you want to
   6000 take.
   6001 
   6002    To resolve that conflict you have to create a version of the affected
   6003 area of the file by keeping only one of the sides, possibly by editing
   6004 it in order to bring in the changes from the other side, remove the
   6005 other versions as well as the markers, and then stage the result.  A
   6006 possible resolution might be:
   6007 
   6008      Take both pills.
   6009 
   6010    Often it is useful to see not only the two sides of the conflict but
   6011 also the "original" version from before the same area of the file was
   6012 modified twice on different branches.  Instruct Git to insert that
   6013 version as well by running this command once:
   6014 
   6015      git config --global merge.conflictStyle diff3
   6016 
   6017    The above conflict might then have looked like this:
   6018 
   6019      <<<<<<< HEAD
   6020      Take the blue pill.
   6021      ||||||| merged common ancestors
   6022      Take either the blue or the red pill, but not both.
   6023      =======
   6024      Take the red pill.
   6025      >>>>>>> feature
   6026 
   6027    If that were the case, then the above conflict resolution would not
   6028 have been correct, which demonstrates why seeing the original version
   6029 alongside the conflicting versions can be useful.
   6030 
   6031    You can perform the conflict resolution completely by hand, but Emacs
   6032 also provides some packages that help in the process: Smerge, Ediff
   6033 (*note (ediff)Top::), and Emerge (*note (emacs)Emerge::).  Magit does
   6034 not provide its own tools for conflict resolution, but it does make
   6035 using Smerge and Ediff more convenient.  (Ediff supersedes Emerge, so
   6036 you probably don’t want to use the latter anyway.)
   6037 
   6038    In the Magit status buffer, files with unresolved conflicts are
   6039 listed in the "Unstaged changes" and/or "Staged changes" sections.  They
   6040 are prefixed with the word "unmerged", which in this context essentially
   6041 is a synonym for "unresolved".
   6042 
   6043    Pressing ‘RET’ while point is on such a file section shows a buffer
   6044 visiting that file, turns on ‘smerge-mode’ in that buffer, and places
   6045 point inside the first area with conflicts.  You should then resolve
   6046 that conflict using regular edit commands and/or Smerge commands.
   6047 
   6048    Unfortunately Smerge does not have a manual, but you can get a list
   6049 of commands and binding ‘C-c ^ C-h’ and press ‘RET’ while point is on a
   6050 command name to read its documentation.
   6051 
   6052    Normally you would edit one version and then tell Smerge to keep only
   6053 that version.  Use ‘C-c ^ m’ (‘smerge-keep-mine’) to keep the ‘HEAD’
   6054 version or ‘C-c ^ o’ (‘smerge-keep-other’) to keep the version that
   6055 follows "|||||||".  Then use ‘C-c ^ n’ to move to the next conflicting
   6056 area in the same file.  Once you are done resolving conflicts, return to
   6057 the Magit status buffer.  The file should now be shown as "modified", no
   6058 longer as "unmerged", because Smerge automatically stages the file when
   6059 you save the buffer after resolving the last conflict.
   6060 
   6061    Magit now wraps the mentioned Smerge commands, allowing you to use
   6062 these key bindings without having to go to the file-visiting buffer.
   6063 Additionally ‘k’ (‘magit-discard’) on a hunk with unresolved conflicts
   6064 asks which side to keep or, if point is on a side, then it keeps it
   6065 without prompting.  Similarly ‘k’ on a unresolved file ask which side to
   6066 keep.
   6067 
   6068    Alternatively you could use Ediff, which uses separate buffers for
   6069 the different versions of the file.  To resolve conflicts in a file
   6070 using Ediff press ‘e’ while point is on such a file in the status
   6071 buffer.
   6072 
   6073    Ediff can be used for other purposes as well.  For more information
   6074 on how to enter Ediff from Magit, see *note Ediffing::.  Explaining how
   6075 to use Ediff is beyond the scope of this manual, instead see *note
   6076 (ediff)Top::.
   6077 
   6078    If you are unsure whether you should Smerge or Ediff, then use the
   6079 former.  It is much easier to understand and use, and except for truly
   6080 complex conflicts, the latter is usually overkill.
   6081 
   6082 
   6083 File: magit.info,  Node: Rebasing,  Next: Cherry Picking,  Prev: Resolving Conflicts,  Up: Manipulating
   6084 
   6085 6.9 Rebasing
   6086 ============
   6087 
   6088 Also see *note (gitman)git-rebase::.  For information on how to resolve
   6089 conflicts that occur during rebases see the preceding section.
   6090 
   6091 ‘r’ (‘magit-rebase’)
   6092      This transient prefix command binds the following suffix commands
   6093      along with the appropriate infix arguments and displays them in a
   6094      temporary buffer until a suffix is invoked.
   6095 
   6096    When no rebase is in progress, then the transient features the
   6097 following suffix commands.
   6098 
   6099    Using one of these commands _starts_ a rebase sequence.  Git might
   6100 then stop somewhere along the way, either because you told it to do so,
   6101 or because applying a commit failed due to a conflict.  When that
   6102 happens, then the status buffer shows information about the rebase
   6103 sequence which is in progress in a section similar to a log section.
   6104 See *note Information About In-Progress Rebase::.
   6105 
   6106    For information about the upstream and the push-remote, see *note The
   6107 Two Remotes::.
   6108 
   6109 ‘r p’ (‘magit-rebase-onto-pushremote’)
   6110      This command rebases the current branch onto its push-remote.
   6111 
   6112      With a prefix argument or when the push-remote is either not
   6113      configured or unusable, then let the user first configure the
   6114      push-remote.
   6115 
   6116 ‘r u’ (‘magit-rebase-onto-upstream’)
   6117      This command rebases the current branch onto its upstream branch.
   6118 
   6119      With a prefix argument or when the upstream is either not
   6120      configured or unusable, then let the user first configure the
   6121      upstream.
   6122 
   6123 ‘r e’ (‘magit-rebase-branch’)
   6124      This command rebases the current branch onto a branch read in the
   6125      minibuffer.  All commits that are reachable from head but not from
   6126      the selected branch TARGET are being rebased.
   6127 
   6128 ‘r s’ (‘magit-rebase-subset’)
   6129      This command starts a non-interactive rebase sequence to transfer
   6130      commits from START to ‘HEAD’ onto NEWBASE.  START has to be
   6131      selected from a list of recent commits.
   6132 
   6133    By default Magit uses the ‘--autostash’ argument, which causes
   6134 uncommitted changes to be stored in a stash before the rebase begins.
   6135 These changes are restored after the rebase completes and if possible
   6136 the stash is removed.  If the stash does not apply cleanly, then the
   6137 stash is not removed.  In case something goes wrong when resolving the
   6138 conflicts, this allows you to start over.
   6139 
   6140    Even though one of the actions is dedicated to interactive rebases,
   6141 the transient also features the infix argument ‘--interactive’.  This
   6142 can be used to turn one of the other, non-interactive rebase variants
   6143 into an interactive rebase.
   6144 
   6145    For example if you want to clean up a feature branch and at the same
   6146 time rebase it onto ‘master’, then you could use ‘r-iu’.  But we
   6147 recommend that you instead do that in two steps.  First use ‘ri’ to
   6148 cleanup the feature branch, and then in a second step ‘ru’ to rebase it
   6149 onto ‘master’.  That way if things turn out to be more complicated than
   6150 you thought and/or you make a mistake and have to start over, then you
   6151 only have to redo half the work.
   6152 
   6153    Explicitly enabling ‘--interactive’ won’t have an effect on the
   6154 following commands as they always use that argument anyway, even if it
   6155 is not enabled in the transient.
   6156 
   6157 ‘r i’ (‘magit-rebase-interactive’)
   6158      This command starts an interactive rebase sequence.
   6159 
   6160 ‘r f’ (‘magit-rebase-autosquash’)
   6161      This command combines squash and fixup commits with their intended
   6162      targets.
   6163 
   6164 ‘r m’ (‘magit-rebase-edit-commit’)
   6165      This command starts an interactive rebase sequence that lets the
   6166      user edit a single older commit.
   6167 
   6168 ‘r w’ (‘magit-rebase-reword-commit’)
   6169      This command starts an interactive rebase sequence that lets the
   6170      user reword a single older commit.
   6171 
   6172 ‘r k’ (‘magit-rebase-remove-commit’)
   6173      This command removes a single older commit using rebase.
   6174 
   6175    When a rebase is in progress, then the transient instead features the
   6176 following suffix commands.
   6177 
   6178 ‘r r’ (‘magit-rebase-continue’)
   6179      This command restart the current rebasing operation.
   6180 
   6181      In some cases this pops up a commit message buffer for you do edit.
   6182      With a prefix argument the old message is reused as-is.
   6183 
   6184 ‘r s’ (‘magit-rebase-skip’)
   6185      This command skips the current commit and restarts the current
   6186      rebase operation.
   6187 
   6188 ‘r e’ (‘magit-rebase-edit’)
   6189      This command lets the user edit the todo list of the current rebase
   6190      operation.
   6191 
   6192 ‘r a’ (‘magit-rebase-abort’)
   6193      This command aborts the current rebase operation, restoring the
   6194      original branch.
   6195 
   6196 * Menu:
   6197 
   6198 * Editing Rebase Sequences::
   6199 * Information About In-Progress Rebase::
   6200 
   6201 
   6202 File: magit.info,  Node: Editing Rebase Sequences,  Next: Information About In-Progress Rebase,  Up: Rebasing
   6203 
   6204 6.9.1 Editing Rebase Sequences
   6205 ------------------------------
   6206 
   6207 ‘C-c C-c’ (‘with-editor-finish’)
   6208      Finish the current editing session by returning with exit code 0.
   6209      Git then uses the rebase instructions it finds in the file.
   6210 
   6211 ‘C-c C-k’ (‘with-editor-cancel’)
   6212      Cancel the current editing session by returning with exit code 1.
   6213      Git then forgoes starting the rebase sequence.
   6214 
   6215 ‘<RET>’ (‘git-rebase-show-commit’)
   6216      Show the commit on the current line in another buffer and select
   6217      that buffer.
   6218 
   6219 ‘<SPC>’ (‘git-rebase-show-or-scroll-up’)
   6220      Show the commit on the current line in another buffer without
   6221      selecting that buffer.  If the revision buffer is already visible
   6222      in another window of the current frame, then instead scroll that
   6223      window up.
   6224 
   6225 ‘<DEL>’ (‘git-rebase-show-or-scroll-down’)
   6226      Show the commit on the current line in another buffer without
   6227      selecting that buffer.  If the revision buffer is already visible
   6228      in another window of the current frame, then instead scroll that
   6229      window down.
   6230 
   6231 ‘p’ (‘git-rebase-backward-line’)
   6232      Move to previous line.
   6233 
   6234 ‘n’ (‘forward-line’)
   6235      Move to next line.
   6236 
   6237 ‘M-p’ (‘git-rebase-move-line-up’)
   6238      Move the current commit (or command) up.
   6239 
   6240 ‘M-n’ (‘git-rebase-move-line-down’)
   6241      Move the current commit (or command) down.
   6242 
   6243 ‘r’ (‘git-rebase-reword’)
   6244      Edit message of commit on current line.
   6245 
   6246 ‘e’ (‘git-rebase-edit’)
   6247      Stop at the commit on the current line.
   6248 
   6249 ‘s’ (‘git-rebase-squash’)
   6250      Meld commit on current line into previous commit, and edit message.
   6251 
   6252 ‘f’ (‘git-rebase-fixup’)
   6253      Meld commit on current line into previous commit, discarding the
   6254      current commit’s message.
   6255 
   6256 ‘k’ (‘git-rebase-kill-line’)
   6257      Kill the current action line.
   6258 
   6259 ‘c’ (‘git-rebase-pick’)
   6260      Use commit on current line.
   6261 
   6262 ‘x’ (‘git-rebase-exec’)
   6263      Insert a shell command to be run after the proceeding commit.
   6264 
   6265      If there already is such a command on the current line, then edit
   6266      that instead.  With a prefix argument insert a new command even
   6267      when there already is one on the current line.  With empty input
   6268      remove the command on the current line, if any.
   6269 
   6270 ‘b’ (‘git-rebase-break’)
   6271      Insert a break action before the current line, instructing Git to
   6272      return control to the user.
   6273 
   6274 ‘y’ (‘git-rebase-insert’)
   6275      Read an arbitrary commit and insert it below current line.
   6276 
   6277 ‘C-x u’ (‘git-rebase-undo’)
   6278      Undo some previous changes.  Like ‘undo’ but works in read-only
   6279      buffers.
   6280 
   6281  -- User Option: git-rebase-auto-advance
   6282      Whether to move to next line after changing a line.
   6283 
   6284  -- User Option: git-rebase-show-instructions
   6285      Whether to show usage instructions inside the rebase buffer.
   6286 
   6287  -- User Option: git-rebase-confirm-cancel
   6288      Whether confirmation is required to cancel.
   6289 
   6290    When a rebase is performed with the ‘--rebase-merges’ option, the
   6291 sequence will include a few other types of actions and the following
   6292 commands become relevant.
   6293 
   6294 ‘l’ (‘git-rebase-label’)
   6295      This commands inserts a label action or edits the one at point.
   6296 
   6297 ‘t’ (‘git-rebase-reset’)
   6298      This command inserts a reset action or edits the one at point.  The
   6299      prompt will offer the labels that are currently present in the
   6300      buffer.
   6301 
   6302 ‘MM’ (‘git-rebase-merge’)
   6303      The command inserts a merge action or edits the one at point.  The
   6304      prompt will offer the labels that are currently present in the
   6305      buffer.  Specifying a message to reuse via ‘-c’ or ‘-C’ is not
   6306      supported; an editor will always be invoked for the merge.
   6307 
   6308 ‘Mt’ (‘git-rebase-merge-toggle-editmsg’)
   6309      This command toggles between the ‘-C’ and ‘-c’ options of the merge
   6310      action at point.  These options both specify a commit whose message
   6311      should be reused.  The lower-case variant instructs Git to invoke
   6312      the editor when creating the merge, allowing the user to edit the
   6313      message.
   6314 
   6315 
   6316 File: magit.info,  Node: Information About In-Progress Rebase,  Prev: Editing Rebase Sequences,  Up: Rebasing
   6317 
   6318 6.9.2 Information About In-Progress Rebase
   6319 ------------------------------------------
   6320 
   6321 While a rebase sequence is in progress, the status buffer features a
   6322 section that lists the commits that have already been applied as well as
   6323 the commits that still have to be applied.
   6324 
   6325    The commits are split in two halves.  When rebase stops at a commit,
   6326 either because the user has to deal with a conflict or because s/he
   6327 explicitly requested that rebase stops at that commit, then point is
   6328 placed on the commit that separates the two groups, i.e., on ‘HEAD’.
   6329 The commits above it have not been applied yet, while the ‘HEAD’ and the
   6330 commits below it have already been applied.  In between these two groups
   6331 of applied and yet-to-be applied commits, there sometimes is a commit
   6332 which has been dropped.
   6333 
   6334    Each commit is prefixed with a word and these words are additionally
   6335 shown in different colors to indicate the status of the commits.
   6336 
   6337    The following colors are used:
   6338 
   6339    • Commits that use the same foreground color as the ‘default’ face
   6340      have not been applied yet.
   6341 
   6342    • Yellow commits have some special relationship to the commit rebase
   6343      stopped at.  This is used for the words "join", "goal", "same" and
   6344      "work" (see below).
   6345 
   6346    • Gray commits have already been applied.
   6347 
   6348    • The blue commit is the ‘HEAD’ commit.
   6349 
   6350    • The green commit is the commit the rebase sequence stopped at.  If
   6351      this is the same commit as ‘HEAD’ (e.g., because you haven’t done
   6352      anything yet after rebase stopped at the commit, then this commit
   6353      is shown in blue, not green).  There can only be a green *and* a
   6354      blue commit at the same time, if you create one or more new commits
   6355      after rebase stops at a commit.
   6356 
   6357    • Red commits have been dropped.  They are shown for reference only,
   6358      e.g., to make it easier to diff.
   6359 
   6360    Of course these colors are subject to the color-theme in use.
   6361 
   6362    The following words are used:
   6363 
   6364    • Commits prefixed with ‘pick’, ‘reword’, ‘edit’, ‘squash’, and
   6365      ‘fixup’ have not been applied yet.  These words have the same
   6366      meaning here as they do in the buffer used to edit the rebase
   6367      sequence.  See *note Editing Rebase Sequences::.  When the
   6368      ‘--rebase-merges’ option was specified, ‘reset’, ‘label’, and
   6369      ‘merge’ lines may also be present.
   6370 
   6371    • Commits prefixed with ‘done’ and ‘onto’ have already been applied.
   6372      It is possible for such a commit to be the ‘HEAD’, in which case it
   6373      is blue.  Otherwise it is grey.
   6374 
   6375         • The commit prefixed with ‘onto’ is the commit on top of which
   6376           all the other commits are being re-applied.  This commit
   6377           itself did not have to be re-applied, it is the commit rebase
   6378           did rewind to before starting to re-apply other commits.
   6379 
   6380         • Commits prefixed with ‘done’ have already been re-applied.
   6381           This includes commits that have been re-applied but also new
   6382           commits that you have created during the rebase.
   6383 
   6384    • All other commits, those not prefixed with any of the above words,
   6385      are in some way related to the commit at which rebase stopped.
   6386 
   6387      To determine whether a commit is related to the stopped-at commit
   6388      their hashes, trees and patch-ids (1) are being compared.  The
   6389      commit message is not used for this purpose.
   6390 
   6391      Generally speaking commits that are related to the stopped-at
   6392      commit can have any of the used colors, though not all color/word
   6393      combinations are possible.
   6394 
   6395      Words used for stopped-at commits are:
   6396 
   6397         • When a commit is prefixed with ‘void’, then that indicates
   6398           that Magit knows for sure that all the changes in that commit
   6399           have been applied using several new commits.  This commit is
   6400           no longer reachable from ‘HEAD’, and it also isn’t one of the
   6401           commits that will be applied when resuming the session.
   6402 
   6403         • When a commit is prefixed with ‘join’, then that indicates
   6404           that the rebase sequence stopped at that commit due to a
   6405           conflict - you now have to join (merge) the changes with what
   6406           has already been applied.  In a sense this is the commit
   6407           rebase stopped at, but while its effect is already in the
   6408           index and in the worktree (with conflict markers), the commit
   6409           itself has not actually been applied yet (it isn’t the
   6410           ‘HEAD’).  So it is shown in yellow, like the other commits
   6411           that still have to be applied.
   6412 
   6413         • When a commit is prefixed with ‘stop’ or a _blue_ or _green_
   6414           ‘same’, then that indicates that rebase stopped at this
   6415           commit, that it is still applied or has been applied again,
   6416           and that at least its patch-id is unchanged.
   6417 
   6418              • When a commit is prefixed with ‘stop’, then that
   6419                indicates that rebase stopped at that commit because you
   6420                requested that earlier, and its patch-id is unchanged.
   6421                It might even still be the exact same commit.
   6422 
   6423              • When a commit is prefixed with a _blue_ or _green_
   6424                ‘same’, then that indicates that while its tree or hash
   6425                changed, its patch-id did not.  If it is blue, then it is
   6426                the ‘HEAD’ commit (as always for blue).  When it is
   6427                green, then it no longer is ‘HEAD’ because other commit
   6428                have been created since (but before continuing the
   6429                rebase).
   6430 
   6431         • When a commit is prefixed with ‘goal’, a _yellow_ ‘same,’ or
   6432           ‘work’, then that indicates that rebase applied that commit
   6433           but that you then reset ‘HEAD’ to an earlier commit (likely to
   6434           split it up into multiple commits), and that there are some
   6435           uncommitted changes remaining which likely (but not
   6436           necessarily) originate from that commit.
   6437 
   6438              • When a commit is prefixed with ‘goal’, then that
   6439                indicates that it is still possible to create a new
   6440                commit with the exact same tree (the "goal") without
   6441                manually editing any files, by committing the index, or
   6442                by staging all changes and then committing that.  This is
   6443                the case when the original tree still exists in the index
   6444                or worktree in untainted form.
   6445 
   6446              • When a commit is prefixed with a yellow ‘same’, then that
   6447                indicates that it is no longer possible to create a
   6448                commit with the exact same tree, but that it is still
   6449                possible to create a commit with the same patch-id.  This
   6450                would be the case if you created a new commit with other
   6451                changes, but the changes from the original commit still
   6452                exist in the index or working tree in untainted form.
   6453 
   6454              • When a commit is prefixed with ‘work’, then that
   6455                indicates that you reset ‘HEAD’ to an earlier commit, and
   6456                that there are some staged and/or unstaged changes
   6457                (likely, but not necessarily) originating from that
   6458                commit.  However it is no longer possible to create a new
   6459                commit with the same tree or at least the same patch-id
   6460                because you have already made other changes.
   6461 
   6462         • When a commit is prefixed with ‘poof’ or ‘gone’, then that
   6463           indicates that rebase applied that commit but that you then
   6464           reset ‘HEAD’ to an earlier commit (likely to split it up into
   6465           multiple commits), and that there are no uncommitted changes.
   6466 
   6467              • When a commit is prefixed with ‘poof’, then that
   6468                indicates that it is no longer reachable from ‘HEAD’, but
   6469                that it has been replaced with one or more commits, which
   6470                together have the exact same effect.
   6471 
   6472              • When a commit is prefixed with ‘gone’, then that
   6473                indicates that it is no longer reachable from ‘HEAD’ and
   6474                that we also cannot determine whether its changes are
   6475                still in effect in one or more new commits.  They might
   6476                be, but if so, then there must also be other changes
   6477                which makes it impossible to know for sure.
   6478 
   6479    Do not worry if you do not fully understand the above.  That’s okay,
   6480 you will acquire a good enough understanding through practice.
   6481 
   6482    For other sequence operations such as cherry-picking, a similar
   6483 section is displayed, but they lack some of the features described
   6484 above, due to limitations in the git commands used to implement them.
   6485 Most importantly these sequences only support "picking" a commit but not
   6486 other actions such as "rewording", and they do not keep track of the
   6487 commits which have already been applied.
   6488 
   6489    ---------- Footnotes ----------
   6490 
   6491    (1) The patch-id is a hash of the _changes_ introduced by a commit.
   6492 It differs from the hash of the commit itself, which is a hash of the
   6493 result of applying that change (i.e., the resulting trees and blobs) as
   6494 well as author and committer information, the commit message, and the
   6495 hashes of the parents of the commit.  The patch-id hash on the other
   6496 hand is created only from the added and removed lines, even line numbers
   6497 and whitespace changes are ignored when calculating this hash.  The
   6498 patch-ids of two commits can be used to answer the question "Do these
   6499 commits make the same change?".
   6500 
   6501 
   6502 File: magit.info,  Node: Cherry Picking,  Next: Resetting,  Prev: Rebasing,  Up: Manipulating
   6503 
   6504 6.10 Cherry Picking
   6505 ===================
   6506 
   6507 Also see *note (gitman)git-cherry-pick::.
   6508 
   6509 ‘A’ (‘magit-cherry-pick’)
   6510      This transient prefix command binds the following suffix commands
   6511      along with the appropriate infix arguments and displays them in a
   6512      temporary buffer until a suffix is invoked.
   6513 
   6514    When no cherry-pick or revert is in progress, then the transient
   6515 features the following suffix commands.
   6516 
   6517 ‘A A’ (‘magit-cherry-copy’)
   6518      This command copies COMMITS from another branch onto the current
   6519      branch.  If the region selects multiple commits, then those are
   6520      copied, without prompting.  Otherwise the user is prompted for a
   6521      commit or range, defaulting to the commit at point.
   6522 
   6523 ‘A a’ (‘magit-cherry-apply’)
   6524      This command applies the changes in COMMITS from another branch
   6525      onto the current branch.  If the region selects multiple commits,
   6526      then those are used, without prompting.  Otherwise the user is
   6527      prompted for a commit or range, defaulting to the commit at point.
   6528 
   6529      This command also has a top-level binding, which can be invoked
   6530      without using the transient by typing ‘a’ at the top-level.
   6531 
   6532    The following commands not only apply some commits to some branch,
   6533 but also remove them from some other branch.  The removal is performed
   6534 using either ‘git-update-ref’ or if necessary ‘git-rebase’.  Both
   6535 applying commits as well as removing them using ‘git-rebase’ can lead to
   6536 conflicts.  If that happens, then these commands abort and you not only
   6537 have to resolve the conflicts but also finish the process the same way
   6538 you would have to if these commands didn’t exist at all.
   6539 
   6540 ‘A h’ (‘magit-cherry-harvest’)
   6541      This command moves the selected COMMITS that must be located on
   6542      another BRANCH onto the current branch instead, removing them from
   6543      the former.  When this command succeeds, then the same branch is
   6544      current as before.
   6545 
   6546      Applying the commits on the current branch or removing them from
   6547      the other branch can lead to conflicts.  When that happens, then
   6548      this command stops and you have to resolve the conflicts and then
   6549      finish the process manually.
   6550 
   6551 ‘A d’ (‘magit-cherry-donate’)
   6552      This command moves the selected COMMITS from the current branch
   6553      onto another existing BRANCH, removing them from the former.  When
   6554      this command succeeds, then the same branch is current as before.
   6555      ‘HEAD’ is allowed to be detached initially.
   6556 
   6557      Applying the commits on the other branch or removing them from the
   6558      current branch can lead to conflicts.  When that happens, then this
   6559      command stops and you have to resolve the conflicts and then finish
   6560      the process manually.
   6561 
   6562 ‘A n’ (‘magit-cherry-spinout’)
   6563      This command moves the selected COMMITS from the current branch
   6564      onto a new branch BRANCH, removing them from the former.  When this
   6565      command succeeds, then the same branch is current as before.
   6566 
   6567      Applying the commits on the other branch or removing them from the
   6568      current branch can lead to conflicts.  When that happens, then this
   6569      command stops and you have to resolve the conflicts and then finish
   6570      the process manually.
   6571 
   6572 ‘A s’ (‘magit-cherry-spinoff’)
   6573      This command moves the selected COMMITS from the current branch
   6574      onto a new branch BRANCH, removing them from the former.  When this
   6575      command succeeds, then the new branch is checked out.
   6576 
   6577      Applying the commits on the other branch or removing them from the
   6578      current branch can lead to conflicts.  When that happens, then this
   6579      command stops and you have to resolve the conflicts and then finish
   6580      the process manually.
   6581 
   6582    When a cherry-pick or revert is in progress, then the transient
   6583 instead features the following suffix commands.
   6584 
   6585 ‘A A’ (‘magit-sequence-continue’)
   6586      Resume the current cherry-pick or revert sequence.
   6587 
   6588 ‘A s’ (‘magit-sequence-skip’)
   6589      Skip the stopped at commit during a cherry-pick or revert sequence.
   6590 
   6591 ‘A a’ (‘magit-sequence-abort’)
   6592      Abort the current cherry-pick or revert sequence.  This discards
   6593      all changes made since the sequence started.
   6594 
   6595 * Menu:
   6596 
   6597 * Reverting::
   6598 
   6599 
   6600 File: magit.info,  Node: Reverting,  Up: Cherry Picking
   6601 
   6602 6.10.1 Reverting
   6603 ----------------
   6604 
   6605 ‘V’ (‘magit-revert’)
   6606      This transient prefix command binds the following suffix commands
   6607      along with the appropriate infix arguments and displays them in a
   6608      temporary buffer until a suffix is invoked.
   6609 
   6610    When no cherry-pick or revert is in progress, then the transient
   6611 features the following suffix commands.
   6612 
   6613 ‘V V’ (‘magit-revert-and-commit’)
   6614      Revert a commit by creating a new commit.  Prompt for a commit,
   6615      defaulting to the commit at point.  If the region selects multiple
   6616      commits, then revert all of them, without prompting.
   6617 
   6618 ‘V v’ (‘magit-revert-no-commit’)
   6619      Revert a commit by applying it in reverse to the working tree.
   6620      Prompt for a commit, defaulting to the commit at point.  If the
   6621      region selects multiple commits, then revert all of them, without
   6622      prompting.
   6623 
   6624    When a cherry-pick or revert is in progress, then the transient
   6625 instead features the following suffix commands.
   6626 
   6627 ‘V V’ (‘magit-sequence-continue’)
   6628      Resume the current cherry-pick or revert sequence.
   6629 
   6630 ‘V s’ (‘magit-sequence-skip’)
   6631      Skip the stopped at commit during a cherry-pick or revert sequence.
   6632 
   6633 ‘V a’ (‘magit-sequence-abort’)
   6634      Abort the current cherry-pick or revert sequence.  This discards
   6635      all changes made since the sequence started.
   6636 
   6637 
   6638 File: magit.info,  Node: Resetting,  Next: Stashing,  Prev: Cherry Picking,  Up: Manipulating
   6639 
   6640 6.11 Resetting
   6641 ==============
   6642 
   6643 Also see *note (gitman)git-reset::.
   6644 
   6645 ‘x’ (‘magit-reset-quickly’)
   6646      Reset the ‘HEAD’ and index to some commit read from the user and
   6647      defaulting to the commit at point, and possibly also reset the
   6648      working tree.  With a prefix argument reset the working tree
   6649      otherwise don’t.
   6650 
   6651 ‘X m’ (‘magit-reset-mixed’)
   6652      Reset the ‘HEAD’ and index to some commit read from the user and
   6653      defaulting to the commit at point.  The working tree is kept as-is.
   6654 
   6655 ‘X s’ (‘magit-reset-soft’)
   6656      Reset the ‘HEAD’ to some commit read from the user and defaulting
   6657      to the commit at point.  The index and the working tree are kept
   6658      as-is.
   6659 
   6660 ‘X h’ (‘magit-reset-hard’)
   6661      Reset the ‘HEAD’, index, and working tree to some commit read from
   6662      the user and defaulting to the commit at point.
   6663 
   6664 ‘X k’ (‘magit-reset-keep’)
   6665      Reset the ‘HEAD’, index, and working tree to some commit read from
   6666      the user and defaulting to the commit at point.  Uncommitted
   6667      changes are kept as-is.
   6668 
   6669 ‘X i’ (‘magit-reset-index’)
   6670      Reset the index to some commit read from the user and defaulting to
   6671      the commit at point.  Keep the ‘HEAD’ and working tree as-is, so if
   6672      the commit refers to the ‘HEAD’, then this effectively unstages all
   6673      changes.
   6674 
   6675 ‘X w’ (‘magit-reset-worktree’)
   6676      Reset the working tree to some commit read from the user and
   6677      defaulting to the commit at point.  Keep the ‘HEAD’ and index
   6678      as-is.
   6679 
   6680 ‘X f’ (‘magit-file-checkout’)
   6681      Update file in the working tree and index to the contents from a
   6682      revision.  Both the revision and file are read from the user.
   6683 
   6684 
   6685 File: magit.info,  Node: Stashing,  Prev: Resetting,  Up: Manipulating
   6686 
   6687 6.12 Stashing
   6688 =============
   6689 
   6690 Also see *note (gitman)git-stash::.
   6691 
   6692 ‘z’ (‘magit-stash’)
   6693      This transient prefix command binds the following suffix commands
   6694      along with the appropriate infix arguments and displays them in a
   6695      temporary buffer until a suffix is invoked.
   6696 
   6697 ‘z z’ (‘magit-stash-both’)
   6698      Create a stash of the index and working tree.  Untracked files are
   6699      included according to infix arguments.  One prefix argument is
   6700      equivalent to ‘--include-untracked’ while two prefix arguments are
   6701      equivalent to ‘--all’.
   6702 
   6703 ‘z i’ (‘magit-stash-index’)
   6704      Create a stash of the index only.  Unstaged and untracked changes
   6705      are not stashed.
   6706 
   6707 ‘z w’ (‘magit-stash-worktree’)
   6708      Create a stash of unstaged changes in the working tree.  Untracked
   6709      files are included according to infix arguments.  One prefix
   6710      argument is equivalent to ‘--include-untracked’ while two prefix
   6711      arguments are equivalent to ‘--all’.
   6712 
   6713 ‘z x’ (‘magit-stash-keep-index’)
   6714      Create a stash of the index and working tree, keeping index intact.
   6715      Untracked files are included according to infix arguments.  One
   6716      prefix argument is equivalent to ‘--include-untracked’ while two
   6717      prefix arguments are equivalent to ‘--all’.
   6718 
   6719 ‘z Z’ (‘magit-snapshot-both’)
   6720      Create a snapshot of the index and working tree.  Untracked files
   6721      are included according to infix arguments.  One prefix argument is
   6722      equivalent to ‘--include-untracked’ while two prefix arguments are
   6723      equivalent to ‘--all’.
   6724 
   6725 ‘z I’ (‘magit-snapshot-index’)
   6726      Create a snapshot of the index only.  Unstaged and untracked
   6727      changes are not stashed.
   6728 
   6729 ‘z W’ (‘magit-snapshot-worktree’)
   6730      Create a snapshot of unstaged changes in the working tree.
   6731      Untracked files are included according to infix arguments.  One
   6732      prefix argument is equivalent to ‘--include-untracked’ while two
   6733      prefix arguments are equivalent to ‘--all’-.
   6734 
   6735 ‘z a’ (‘magit-stash-apply’)
   6736      Apply a stash to the working tree.
   6737 
   6738      First try ‘git stash apply --index’, which tries to preserve the
   6739      index stored in the stash, if any.  This may fail because applying
   6740      the stash could result in conflicts and those have to be stored in
   6741      the index, making it impossible to also store the stash’s index
   6742      there as well.
   6743 
   6744      If the above failed, then try ‘git stash apply’.  This fails (with
   6745      or without ‘--index’) if there are any uncommitted changes to files
   6746      that are also modified in the stash.
   6747 
   6748      If both of the above failed, then apply using ‘git apply’.  If
   6749      there are no conflicting files, use ‘--3way’.  If there are
   6750      conflicting files, then using ‘--3way’ requires that those files
   6751      are staged first, which may be undesirable, so prompt the user
   6752      whether to use ‘--3way’ or ‘--reject’.
   6753 
   6754      Customize ‘magit-no-confirm’ if you want to always use ‘--3way’,
   6755      without being prompted.
   6756 
   6757 ‘z p’ (‘magit-stash-pop’)
   6758      Apply a stash to the working tree.  On complete success (if the
   6759      stash can be applied without any conflicts, and while preserving
   6760      the stash’s index) then remove the stash from stash list.
   6761 
   6762      First try ‘git stash pop --index’, which tries to preserve the
   6763      index stored in the stash, if any.  This may fail because applying
   6764      the stash could result in conflicts and those have to be stored in
   6765      the index, making it impossible to also store the stash’s index
   6766      there as well.
   6767 
   6768      If the above failed, then try ‘git stash apply’.  This fails (with
   6769      or without ‘--index’) if there are any uncommitted changes to files
   6770      that are also modified in the stash.
   6771 
   6772      If both of the above failed, then apply using ‘git apply’.  If
   6773      there are no conflicting files, use ‘--3way’.  If there are
   6774      conflicting files, then using ‘--3way’ requires that those files
   6775      are staged first, which may be undesirable, so prompt the user
   6776      whether to use ‘--3way’ or ‘--reject’.
   6777 
   6778      Customize ‘magit-no-confirm’ if you want to always use ‘--3way’,
   6779      without being prompted.
   6780 
   6781 ‘z k’ (‘magit-stash-drop’)
   6782      Remove a stash from the stash list.  When the region is active,
   6783      offer to drop all contained stashes.
   6784 
   6785 ‘z v’ (‘magit-stash-show’)
   6786      Show all diffs of a stash in a buffer.
   6787 
   6788 ‘z b’ (‘magit-stash-branch’)
   6789      Create and checkout a new branch from an existing stash.  The new
   6790      branch starts at the commit that was current when the stash was
   6791      created.
   6792 
   6793 ‘z B’ (‘magit-stash-branch-here’)
   6794      Create and checkout a new branch from an existing stash.  Use the
   6795      current branch or ‘HEAD’ as the starting-point of the new branch.
   6796      Then apply the stash, dropping it if it applies cleanly.
   6797 
   6798 ‘z f’ (‘magit-stash-format-patch’)
   6799      Create a patch from STASH.
   6800 
   6801 ‘k’ (‘magit-stash-clear’)
   6802      Remove all stashes saved in REF’s reflog by deleting REF.
   6803 
   6804 ‘z l’ (‘magit-stash-list’)
   6805      List all stashes in a buffer.
   6806 
   6807  -- User Option: magit-stashes-margin
   6808      This option specifies whether the margin is initially shown in
   6809      stashes buffers and how it is formatted.
   6810 
   6811      The value has the form ‘(INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH)’.
   6812 
   6813         • If INIT is non-nil, then the margin is shown initially.
   6814         • STYLE controls how to format the author or committer date.  It
   6815           can be one of ‘age’ (to show the age of the commit),
   6816           ‘age-abbreviated’ (to abbreviate the time unit to a
   6817           character), or a string (suitable for ‘format-time-string’) to
   6818           show the actual date.  Option
   6819           ‘magit-log-margin-show-committer-date’ controls which date is
   6820           being displayed.
   6821         • WIDTH controls the width of the margin.  This exists for
   6822           forward compatibility and currently the value should not be
   6823           changed.
   6824         • AUTHOR controls whether the name of the author is also shown
   6825           by default.
   6826         • AUTHOR-WIDTH has to be an integer.  When the name of the
   6827           author is shown, then this specifies how much space is used to
   6828           do so.
   6829 
   6830 
   6831 File: magit.info,  Node: Transferring,  Next: Miscellaneous,  Prev: Manipulating,  Up: Top
   6832 
   6833 7 Transferring
   6834 **************
   6835 
   6836 * Menu:
   6837 
   6838 * Remotes::
   6839 * Fetching::
   6840 * Pulling::
   6841 * Pushing::
   6842 * Plain Patches::
   6843 * Maildir Patches::
   6844 
   6845 
   6846 File: magit.info,  Node: Remotes,  Next: Fetching,  Up: Transferring
   6847 
   6848 7.1 Remotes
   6849 ===========
   6850 
   6851 * Menu:
   6852 
   6853 * Remote Commands::
   6854 * Remote Git Variables::
   6855 
   6856 
   6857 File: magit.info,  Node: Remote Commands,  Next: Remote Git Variables,  Up: Remotes
   6858 
   6859 7.1.1 Remote Commands
   6860 ---------------------
   6861 
   6862 The transient prefix command ‘magit-remote’ is used to add remotes and
   6863 to make changes to existing remotes.  This command only deals with
   6864 remotes themselves, not with branches or the transfer of commits.  Those
   6865 features are available from separate transient commands.
   6866 
   6867    Also see *note (gitman)git-remote::.
   6868 
   6869 ‘M’ (‘magit-remote’)
   6870      This transient prefix command binds the following suffix commands
   6871      and displays them in a temporary buffer until a suffix is invoked.
   6872 
   6873      By default it also binds and displays the values of some
   6874      remote-related Git variables and allows changing their values.
   6875 
   6876  -- User Option: magit-remote-direct-configure
   6877      This option controls whether remote-related Git variables are
   6878      accessible directly from the transient ‘magit-remote’.
   6879 
   6880      If ‘t’ (the default) and a local branch is checked out, then
   6881      ‘magit-remote’ features the variables for the upstream remote of
   6882      that branch, or if ‘HEAD’ is detached, for ‘origin’, provided that
   6883      exists.
   6884 
   6885      If ‘nil’, then ‘magit-remote-configure’ has to be used to do so.
   6886 
   6887 ‘M C’ (‘magit-remote-configure’)
   6888      This transient prefix command binds commands that set the value of
   6889      remote-related variables and displays them in a temporary buffer
   6890      until the transient is exited.
   6891 
   6892      With a prefix argument, this command always prompts for a remote.
   6893 
   6894      Without a prefix argument this depends on whether it was invoked as
   6895      a suffix of ‘magit-remote’ and on the
   6896      ‘magit-remote-direct-configure’ option.  If ‘magit-remote’ already
   6897      displays the variables for the upstream, then it does not make
   6898      sense to invoke another transient that displays them for the same
   6899      remote.  In that case this command prompts for a remote.
   6900 
   6901    The variables are described in *note Remote Git Variables::.
   6902 
   6903 ‘M a’ (‘magit-remote-add’)
   6904      This command add a remote and fetches it.  The remote name and url
   6905      are read in the minibuffer.
   6906 
   6907 ‘M r’ (‘magit-remote-rename’)
   6908      This command renames a remote.  Both the old and the new names are
   6909      read in the minibuffer.
   6910 
   6911 ‘M u’ (‘magit-remote-set-url’)
   6912      This command changes the url of a remote.  Both the remote and the
   6913      new url are read in the minibuffer.
   6914 
   6915 ‘M k’ (‘magit-remote-remove’)
   6916      This command deletes a remote, read in the minibuffer.
   6917 
   6918 ‘M p’ (‘magit-remote-prune’)
   6919      This command removes stale remote-tracking branches for a remote
   6920      read in the minibuffer.
   6921 
   6922 ‘M P’ (‘magit-remote-prune-refspecs’)
   6923      This command removes stale refspecs for a remote read in the
   6924      minibuffer.
   6925 
   6926      A refspec is stale if there no longer exists at least one branch on
   6927      the remote that would be fetched due to that refspec.  A stale
   6928      refspec is problematic because its existence causes Git to refuse
   6929      to fetch according to the remaining non-stale refspecs.
   6930 
   6931      If only stale refspecs remain, then this command offers to either
   6932      delete the remote or to replace the stale refspecs with the default
   6933      refspec ("+refs/heads/*:refs/remotes/REMOTE/*").
   6934 
   6935      This command also removes the remote-tracking branches that were
   6936      created due to the now stale refspecs.  Other stale branches are
   6937      not removed.
   6938 
   6939  -- User Option: magit-remote-add-set-remote.pushDefault
   6940      This option controls whether the user is asked whether they want to
   6941      set ‘remote.pushDefault’ after adding a remote.
   6942 
   6943      If ‘ask’, then users is always ask.  If ‘ask-if-unset’, then the
   6944      user is only if the variable isn’t set already.  If ‘nil’, then the
   6945      user isn’t asked and the variable isn’t set.  If the value is a
   6946      string, then the variable is set without the user being asked,
   6947      provided that the name of the added remote is equal to that string
   6948      and the variable isn’t already set.
   6949 
   6950 
   6951 File: magit.info,  Node: Remote Git Variables,  Prev: Remote Commands,  Up: Remotes
   6952 
   6953 7.1.2 Remote Git Variables
   6954 --------------------------
   6955 
   6956 These variables can be set from the transient prefix command
   6957 ‘magit-remote-configure’.  By default they can also be set from
   6958 ‘magit-remote’.  See *note Remote Commands::.
   6959 
   6960  -- Variable: remote.NAME.url
   6961      This variable specifies the url of the remote named NAME.  It can
   6962      have multiple values.
   6963 
   6964  -- Variable: remote.NAME.fetch
   6965      The refspec used when fetching from the remote named NAME.  It can
   6966      have multiple values.
   6967 
   6968  -- Variable: remote.NAME.pushurl
   6969      This variable specifies the url used for pushing to the remote
   6970      named NAME.  If it is not specified, then ‘remote.NAME.url’ is used
   6971      instead.  It can have multiple values.
   6972 
   6973  -- Variable: remote.NAME.push
   6974      The refspec used when pushing to the remote named NAME.  It can
   6975      have multiple values.
   6976 
   6977  -- Variable: remote.NAME.tagOpts
   6978      This variable specifies what tags are fetched by default.  If the
   6979      value is ‘--no-tags’ then no tags are fetched.  If the value is
   6980      ‘--tags’, then all tags are fetched.  If this variable has no
   6981      value, then only tags are fetched that are reachable from fetched
   6982      branches.
   6983 
   6984 
   6985 File: magit.info,  Node: Fetching,  Next: Pulling,  Prev: Remotes,  Up: Transferring
   6986 
   6987 7.2 Fetching
   6988 ============
   6989 
   6990 Also see *note (gitman)git-fetch::.  For information about the upstream
   6991 and the push-remote, see *note The Two Remotes::.
   6992 
   6993 ‘f’ (‘magit-fetch’)
   6994      This transient prefix command binds the following suffix commands
   6995      along with the appropriate infix arguments and displays them in a
   6996      temporary buffer until a suffix is invoked.
   6997 
   6998 ‘f p’ (‘magit-fetch-from-pushremote’)
   6999      This command fetches from the current push-remote.
   7000 
   7001      With a prefix argument or when the push-remote is either not
   7002      configured or unusable, then let the user first configure the
   7003      push-remote.
   7004 
   7005 ‘f u’ (‘magit-fetch-from-upstream’)
   7006      This command fetch from the upstream of the current branch.
   7007 
   7008      If the upstream is configured for the current branch and names an
   7009      existing remote, then use that.  Otherwise try to use another
   7010      remote: If only a single remote is configured, then use that.
   7011      Otherwise if a remote named "origin" exists, then use that.
   7012 
   7013      If no remote can be determined, then this command is not available
   7014      from the ‘magit-fetch’ transient prefix and invoking it directly
   7015      results in an error.
   7016 
   7017 ‘f e’ (‘magit-fetch-other’)
   7018      This command fetch from a repository read from the minibuffer.
   7019 
   7020 ‘f o’ (‘magit-fetch-branch’)
   7021      This command fetches a branch from a remote, both of which are read
   7022      from the minibuffer.
   7023 
   7024 ‘f r’ (‘magit-fetch-refspec’)
   7025      This command fetches from a remote using an explicit refspec, both
   7026      of which are read from the minibuffer.
   7027 
   7028 ‘f a’ (‘magit-fetch-all’)
   7029      This command fetches from all remotes.
   7030 
   7031 ‘f m’ (‘magit-fetch-modules’)
   7032      This command fetches all submodules.  With a prefix argument, it
   7033      acts as a transient prefix command, allowing the caller to set
   7034      options.
   7035 
   7036  -- User Option: magit-pull-or-fetch
   7037      By default fetch and pull commands are available from separate
   7038      transient prefix command.  Setting this to ‘t’ adds some (but not
   7039      all) of the above suffix commands to the ‘magit-pull’ transient.
   7040 
   7041      If you do that, then you might also want to change the key binding
   7042      for these prefix commands, e.g.:
   7043 
   7044           (setq magit-pull-or-fetch t)
   7045           (define-key magit-mode-map "f" 'magit-pull) ; was magit-fetch
   7046           (define-key magit-mode-map "F" nil)         ; was magit-pull
   7047 
   7048 
   7049 File: magit.info,  Node: Pulling,  Next: Pushing,  Prev: Fetching,  Up: Transferring
   7050 
   7051 7.3 Pulling
   7052 ===========
   7053 
   7054 Also see *note (gitman)git-pull::.  For information about the upstream
   7055 and the push-remote, see *note The Two Remotes::.
   7056 
   7057 ‘F’ (‘magit-pull’)
   7058      This transient prefix command binds the following suffix commands
   7059      and displays them in a temporary buffer until a suffix is invoked.
   7060 
   7061 ‘F p’ (‘magit-pull-from-pushremote’)
   7062      This command pulls from the push-remote of the current branch.
   7063 
   7064      With a prefix argument or when the push-remote is either not
   7065      configured or unusable, then let the user first configure the
   7066      push-remote.
   7067 
   7068 ‘F u’ (‘magit-pull-from-upstream’)
   7069      This command pulls from the upstream of the current branch.
   7070 
   7071      With a prefix argument or when the upstream is either not
   7072      configured or unusable, then let the user first configure the
   7073      upstream.
   7074 
   7075 ‘F e’ (‘magit-pull-branch’)
   7076      This command pulls from a branch read in the minibuffer.
   7077 
   7078 
   7079 File: magit.info,  Node: Pushing,  Next: Plain Patches,  Prev: Pulling,  Up: Transferring
   7080 
   7081 7.4 Pushing
   7082 ===========
   7083 
   7084 Also see *note (gitman)git-push::.  For information about the upstream
   7085 and the push-remote, see *note The Two Remotes::.
   7086 
   7087 ‘P’ (‘magit-push’)
   7088      This transient prefix command binds the following suffix commands
   7089      along with the appropriate infix arguments and displays them in a
   7090      temporary buffer until a suffix is invoked.
   7091 
   7092 ‘P p’ (‘magit-push-current-to-pushremote’)
   7093      This command pushes the current branch to its push-remote.
   7094 
   7095      With a prefix argument or when the push-remote is either not
   7096      configured or unusable, then let the user first configure the
   7097      push-remote.
   7098 
   7099 ‘P u’ (‘magit-push-current-to-upstream’)
   7100      This command pushes the current branch to its upstream branch.
   7101 
   7102      With a prefix argument or when the upstream is either not
   7103      configured or unusable, then let the user first configure the
   7104      upstream.
   7105 
   7106 ‘P e’ (‘magit-push-current’)
   7107      This command pushes the current branch to a branch read in the
   7108      minibuffer.
   7109 
   7110 ‘P o’ (‘magit-push-other’)
   7111      This command pushes an arbitrary branch or commit somewhere.  Both
   7112      the source and the target are read in the minibuffer.
   7113 
   7114 ‘P r’ (‘magit-push-refspecs’)
   7115      This command pushes one or multiple refspecs to a remote, both of
   7116      which are read in the minibuffer.
   7117 
   7118      To use multiple refspecs, separate them with commas.  Completion is
   7119      only available for the part before the colon, or when no colon is
   7120      used.
   7121 
   7122 ‘P m’ (‘magit-push-matching’)
   7123      This command pushes all matching branches to another repository.
   7124 
   7125      If only one remote exists, then push to that.  Otherwise prompt for
   7126      a remote, offering the remote configured for the current branch as
   7127      default.
   7128 
   7129 ‘P t’ (‘magit-push-tags’)
   7130      This command pushes all tags to another repository.
   7131 
   7132      If only one remote exists, then push to that.  Otherwise prompt for
   7133      a remote, offering the remote configured for the current branch as
   7134      default.
   7135 
   7136 ‘P T’ (‘magit-push-tag’)
   7137      This command pushes a tag to another repository.
   7138 
   7139    One of the infix arguments, ‘--force-with-lease’, deserves a word of
   7140 caution.  It is passed without a value, which means "permit a force push
   7141 as long as the remote-tracking branches match their counterparts on the
   7142 remote end".  If you’ve set up a tool to do automatic fetches (Magit
   7143 itself does not provide such functionality), using ‘--force-with-lease’
   7144 can be dangerous because you don’t actually control or know the state of
   7145 the remote-tracking refs.  In that case, you should consider setting
   7146 ‘push.useForceIfIncludes’ to ‘true’ (available since Git 2.30).
   7147 
   7148    Two more push commands exist, which by default are not available from
   7149 the push transient.  See their doc-strings for instructions on how to
   7150 add them to the transient.
   7151 
   7152  -- Command: magit-push-implicitly args
   7153      This command pushes somewhere without using an explicit refspec.
   7154 
   7155      This command simply runs ‘git push -v [ARGS]’.  ARGS are the infix
   7156      arguments.  No explicit refspec arguments are used.  Instead the
   7157      behavior depends on at least these Git variables: ‘push.default’,
   7158      ‘remote.pushDefault’, ‘branch.<branch>.pushRemote’,
   7159      ‘branch.<branch>.remote’, ‘branch.<branch>.merge’, and
   7160      ‘remote.<remote>.push’.
   7161 
   7162      If you add this suffix to a transient prefix without explicitly
   7163      specifying the description, then an attempt is made to predict what
   7164      this command will do.  For example:
   7165 
   7166           (transient-insert-suffix 'magit-push \"p\"
   7167             '(\"i\" magit-push-implicitly))"
   7168 
   7169  -- Command: magit-push-to-remote remote args
   7170      This command pushes to the remote REMOTE without using an explicit
   7171      refspec.  The remote is read in the minibuffer.
   7172 
   7173      This command simply runs ‘git push -v [ARGS] REMOTE’.  ARGS are the
   7174      infix arguments.  No refspec arguments are used.  Instead the
   7175      behavior depends on at least these Git variables: ‘push.default’,
   7176      ‘remote.pushDefault’, ‘branch.<branch>.pushRemote’,
   7177      ‘branch.<branch>.remote’, ‘branch.<branch>.merge’, and
   7178      ‘remote.<remote>.push’.
   7179 
   7180 
   7181 File: magit.info,  Node: Plain Patches,  Next: Maildir Patches,  Prev: Pushing,  Up: Transferring
   7182 
   7183 7.5 Plain Patches
   7184 =================
   7185 
   7186 ‘W’ (‘magit-patch’)
   7187      This transient prefix command binds the following suffix commands
   7188      along with the appropriate infix arguments and displays them in a
   7189      temporary buffer until a suffix is invoked.
   7190 
   7191 ‘W c’ (‘magit-patch-create’)
   7192      This command creates patches for a set commits.  If the region
   7193      marks several commits, then it creates patches for all of them.
   7194      Otherwise it functions as a transient prefix command, which
   7195      features several infix arguments and binds itself as a suffix
   7196      command.  When this command is invoked as a suffix of itself, then
   7197      it creates a patch using the specified infix arguments.
   7198 
   7199 ‘w a’ (‘magit-patch-apply’)
   7200      This command applies a patch.  This is a transient prefix command,
   7201      which features several infix arguments and binds itself as a suffix
   7202      command.  When this command is invoked as a suffix of itself, then
   7203      it applies a patch using the specified infix arguments.
   7204 
   7205 ‘W s’ (‘magit-patch-save’)
   7206      This command creates a patch from the current diff.
   7207 
   7208      Inside ‘magit-diff-mode’ or ‘magit-revision-mode’ buffers, ‘C-x
   7209      C-w’ is also bound to this command.
   7210 
   7211    It is also possible to save a plain patch file by using ‘C-x C-w’
   7212 inside a ‘magit-diff-mode’ or ‘magit-revision-mode’ buffer.
   7213 
   7214 
   7215 File: magit.info,  Node: Maildir Patches,  Prev: Plain Patches,  Up: Transferring
   7216 
   7217 7.6 Maildir Patches
   7218 ===================
   7219 
   7220 Also see *note (gitman)git-am::.  and *note (gitman)git-apply::.
   7221 
   7222 ‘w’ (‘magit-am’)
   7223      This transient prefix command binds the following suffix commands
   7224      along with the appropriate infix arguments and displays them in a
   7225      temporary buffer until a suffix is invoked.
   7226 
   7227 ‘w w’ (‘magit-am-apply-patches’)
   7228      This command applies one or more patches.  If the region marks
   7229      files, then those are applied as patches.  Otherwise this command
   7230      reads a file-name in the minibuffer, defaulting to the file at
   7231      point.
   7232 
   7233 ‘w m’ (‘magit-am-apply-maildir’)
   7234      This command applies patches from a maildir.
   7235 
   7236 ‘w a’ (‘magit-patch-apply’)
   7237      This command applies a plain patch.  For a longer description see
   7238      *note Plain Patches::.  This command is only available from the
   7239      ‘magit-am’ transient for historic reasons.
   7240 
   7241    When an "am" operation is in progress, then the transient instead
   7242 features the following suffix commands.
   7243 
   7244 ‘w w’ (‘magit-am-continue’)
   7245      This command resumes the current patch applying sequence.
   7246 
   7247 ‘w s’ (‘magit-am-skip’)
   7248      This command skips the stopped at patch during a patch applying
   7249      sequence.
   7250 
   7251 ‘w a’ (‘magit-am-abort’)
   7252      This command aborts the current patch applying sequence.  This
   7253      discards all changes made since the sequence started.
   7254 
   7255 
   7256 File: magit.info,  Node: Miscellaneous,  Next: Customizing,  Prev: Transferring,  Up: Top
   7257 
   7258 8 Miscellaneous
   7259 ***************
   7260 
   7261 * Menu:
   7262 
   7263 * Tagging::
   7264 * Notes::
   7265 * Submodules::
   7266 * Subtree::
   7267 * Worktree::
   7268 * Sparse checkouts::
   7269 * Bundle::
   7270 * Common Commands::
   7271 * Wip Modes::
   7272 * Commands for Buffers Visiting Files::
   7273 * Minor Mode for Buffers Visiting Blobs::
   7274 
   7275 
   7276 File: magit.info,  Node: Tagging,  Next: Notes,  Up: Miscellaneous
   7277 
   7278 8.1 Tagging
   7279 ===========
   7280 
   7281 Also see *note (gitman)git-tag::.
   7282 
   7283 ‘t’ (‘magit-tag’)
   7284      This transient prefix command binds the following suffix commands
   7285      along with the appropriate infix arguments and displays them in a
   7286      temporary buffer until a suffix is invoked.
   7287 
   7288 ‘t t’ (‘magit-tag-create’)
   7289      This command creates a new tag with the given NAME at REV.  With a
   7290      prefix argument it creates an annotated tag.
   7291 
   7292 ‘t r’ (‘magit-tag-release’)
   7293      This commands creates a release tag.  It assumes that release tags
   7294      match ‘magit-release-tag-regexp’.
   7295 
   7296      First it prompts for the name of the new tag using the highest
   7297      existing tag as initial input and leaving it to the user to
   7298      increment the desired part of the version string.  If you use
   7299      unconventional release tags or version numbers (e.g.,
   7300      ‘v1.2.3-custom.1’), you can set the ‘magit-release-tag-regexp’ and
   7301      ‘magit-tag-version-regexp-alist’ variables.
   7302 
   7303      If ‘--annotate’ is enabled then it prompts for the message of the
   7304      new tag.  The proposed tag message is based on the message of the
   7305      highest tag, provided that that contains the corresponding version
   7306      string and substituting the new version string for that.  Otherwise
   7307      it proposes something like "Foo-Bar 1.2.3", given, for example, a
   7308      TAG "v1.2.3" and a repository located at something like
   7309      "/path/to/foo-bar".
   7310 
   7311 ‘t k’ (‘magit-tag-delete’)
   7312      This command deletes one or more tags.  If the region marks
   7313      multiple tags (and nothing else), then it offers to delete those.
   7314      Otherwise, it prompts for a single tag to be deleted, defaulting to
   7315      the tag at point.
   7316 
   7317 ‘t p’ (‘magit-tag-prune’)
   7318      This command offers to delete tags missing locally from REMOTE, and
   7319      vice versa.
   7320 
   7321 
   7322 File: magit.info,  Node: Notes,  Next: Submodules,  Prev: Tagging,  Up: Miscellaneous
   7323 
   7324 8.2 Notes
   7325 =========
   7326 
   7327 Also see *note (gitman)git-notes::.
   7328 
   7329 ‘T’ (‘magit-notes’)
   7330      This transient prefix command binds the following suffix commands
   7331      along with the appropriate infix arguments and displays them in a
   7332      temporary buffer until a suffix is invoked.
   7333 
   7334 ‘T T’ (‘magit-notes-edit’)
   7335      Edit the note attached to a commit, defaulting to the commit at
   7336      point.
   7337 
   7338      By default use the value of Git variable ‘core.notesRef’ or
   7339      "refs/notes/commits" if that is undefined.
   7340 
   7341 ‘T r’ (‘magit-notes-remove’)
   7342      Remove the note attached to a commit, defaulting to the commit at
   7343      point.
   7344 
   7345      By default use the value of Git variable ‘core.notesRef’ or
   7346      "refs/notes/commits" if that is undefined.
   7347 
   7348 ‘T p’ (‘magit-notes-prune’)
   7349      Remove notes about unreachable commits.
   7350 
   7351    It is possible to merge one note ref into another.  That may result
   7352 in conflicts which have to resolved in the temporary worktree
   7353 ".git/NOTES_MERGE_WORKTREE".
   7354 
   7355 ‘T m’ (‘magit-notes-merge’)
   7356      Merge the notes of a ref read from the user into the current notes
   7357      ref.  The current notes ref is the value of Git variable
   7358      ‘core.notesRef’ or "refs/notes/commits" if that is undefined.
   7359 
   7360    When a notes merge is in progress then the transient features the
   7361 following suffix commands, instead of those listed above.
   7362 
   7363 ‘T c’ (‘magit-notes-merge-commit’)
   7364      Commit the current notes ref merge, after manually resolving
   7365      conflicts.
   7366 
   7367 ‘T a’ (‘magit-notes-merge-abort’)
   7368      Abort the current notes ref merge.
   7369 
   7370    The following variables control what notes reference ‘magit-notes-*’,
   7371 ‘git notes’ and ‘git show’ act on and display.  Both the local and
   7372 global values are displayed and can be modified.
   7373 
   7374  -- Variable: core.notesRef
   7375      This variable specifies the notes ref that is displayed by default
   7376      and which commands act on by default.
   7377 
   7378  -- Variable: notes.displayRef
   7379      This variable specifies additional notes ref to be displayed in
   7380      addition to the ref specified by ‘core.notesRef’.  It can have
   7381      multiple values and may end with ‘*’ to display all refs in the
   7382      ‘refs/notes/’ namespace (or ‘**’ if some names contain slashes).
   7383 
   7384 
   7385 File: magit.info,  Node: Submodules,  Next: Subtree,  Prev: Notes,  Up: Miscellaneous
   7386 
   7387 8.3 Submodules
   7388 ==============
   7389 
   7390 Also see *note (gitman)git-submodule::.
   7391 
   7392 * Menu:
   7393 
   7394 * Listing Submodules::
   7395 * Submodule Transient::
   7396 
   7397 
   7398 File: magit.info,  Node: Listing Submodules,  Next: Submodule Transient,  Up: Submodules
   7399 
   7400 8.3.1 Listing Submodules
   7401 ------------------------
   7402 
   7403 The command ‘magit-list-submodules’ displays a list of the current
   7404 repository’s submodules in a separate buffer.  It’s also possible to
   7405 display information about submodules directly in the status buffer of
   7406 the super-repository by adding ‘magit-insert-modules’ to the hook
   7407 ‘magit-status-sections-hook’ as described in *note Status Module
   7408 Sections::.
   7409 
   7410  -- Command: magit-list-submodules
   7411      This command displays a list of the current repository’s populated
   7412      submodules in a separate buffer.
   7413 
   7414      It can be invoked by pressing ‘RET’ on the section titled
   7415      "Modules".
   7416 
   7417  -- User Option: magit-submodule-list-columns
   7418      This option controls what columns are displayed by the command
   7419      ‘magit-list-submodules’ and how they are displayed.
   7420 
   7421      Each element has the form ‘(HEADER WIDTH FORMAT PROPS)’.
   7422 
   7423      HEADER is the string displayed in the header.  WIDTH is the width
   7424      of the column.  FORMAT is a function that is called with one
   7425      argument, the repository identification (usually its basename), and
   7426      with ‘default-directory’ bound to the toplevel of its working tree.
   7427      It has to return a string to be inserted or nil.  PROPS is an alist
   7428      that supports the keys ‘:right-align’, ‘:pad-right’ and ‘:sort’.
   7429 
   7430      The ‘:sort’ function has a weird interface described in the
   7431      docstring of ‘tabulated-list--get-sort’.  Alternatively ‘<’ and
   7432      ‘magit-repolist-version<’ can be used as those functions are
   7433      automatically replaced with functions that satisfy the interface.
   7434      Set ‘:sort’ to ‘nil’ to inhibit sorting; if unspecified, then the
   7435      column is sortable using the default sorter.
   7436 
   7437      You may wish to display a range of numeric columns using just one
   7438      character per column and without any padding between columns, in
   7439      which case you should use an appropriate HEADER, set WIDTH to 1,
   7440      and set ‘:pad-right’ to 9.  ‘+’ is substituted for numbers higher
   7441      than 9.
   7442 
   7443 
   7444 File: magit.info,  Node: Submodule Transient,  Prev: Listing Submodules,  Up: Submodules
   7445 
   7446 8.3.2 Submodule Transient
   7447 -------------------------
   7448 
   7449 ‘o’ (‘magit-submodule’)
   7450      This transient prefix command binds the following suffix commands
   7451      along with the appropriate infix arguments and displays them in a
   7452      temporary buffer until a suffix is invoked.
   7453 
   7454    Some of the below commands default to act on the modules that are
   7455 selected using the region.  For brevity their description talk about
   7456 "the selected modules", but if no modules are selected, then they act on
   7457 the current module instead, or if point isn’t on a module, then the read
   7458 a single module to act on.  With a prefix argument these commands ignore
   7459 the selection and the current module and instead act on all suitable
   7460 modules.
   7461 
   7462 ‘o a’ (‘magit-submodule-add’)
   7463      This commands adds the repository at URL as a module.  Optional
   7464      PATH is the path to the module relative to the root of the
   7465      super-project.  If it is nil then the path is determined based on
   7466      URL.
   7467 
   7468 ‘o r’ (‘magit-submodule-register’)
   7469      This command registers the selected modules by copying their urls
   7470      from ".gitmodules" to "$GIT_DIR/config".  These values can then be
   7471      edited before running ‘magit-submodule-populate’.  If you don’t
   7472      need to edit any urls, then use the latter directly.
   7473 
   7474 ‘o p’ (‘magit-submodule-populate’)
   7475      This command creates the working directory or directories of the
   7476      selected modules, checking out the recorded commits.
   7477 
   7478 ‘o u’ (‘magit-submodule-update’)
   7479      This command updates the selected modules checking out the recorded
   7480      commits.
   7481 
   7482 ‘o s’ (‘magit-submodule-synchronize’)
   7483      This command synchronizes the urls of the selected modules, copying
   7484      the values from ".gitmodules" to the ".git/config" of the
   7485      super-project as well those of the modules.
   7486 
   7487 ‘o d’ (‘magit-submodule-unpopulate’)
   7488      This command removes the working directory of the selected modules.
   7489 
   7490 ‘o l’ (‘magit-list-submodules’)
   7491      This command displays a list of the current repository’s modules.
   7492 
   7493 ‘o f’ (‘magit-fetch-modules’)
   7494      This command fetches all populated modules.  With a prefix
   7495      argument, it acts as a transient prefix command, allowing the
   7496      caller to set options.
   7497 
   7498      Also fetch the super-repository, because ‘git fetch’ does not
   7499      support not doing that.
   7500 
   7501 
   7502 File: magit.info,  Node: Subtree,  Next: Worktree,  Prev: Submodules,  Up: Miscellaneous
   7503 
   7504 8.4 Subtree
   7505 ===========
   7506 
   7507 Also see *note (gitman)git-subtree::.
   7508 
   7509 ‘O’ (‘magit-subtree’)
   7510      This transient prefix command binds the two sub-transients; one for
   7511      importing a subtree and one for exporting a subtree.
   7512 
   7513 ‘O i’ (‘magit-subtree-import’)
   7514      This transient prefix command binds the following suffix commands
   7515      along with the appropriate infix arguments and displays them in a
   7516      temporary buffer until a suffix is invoked.
   7517 
   7518      The suffixes of this command import subtrees.
   7519 
   7520      If the ‘--prefix’ argument is set, then the suffix commands use
   7521      that prefix without prompting the user.  If it is unset, then they
   7522      read the prefix in the minibuffer.
   7523 
   7524 ‘O i a’ (‘magit-subtree-add’)
   7525      This command adds COMMIT from REPOSITORY as a new subtree at
   7526      PREFIX.
   7527 
   7528 ‘O i c’ (‘magit-subtree-add-commit’)
   7529      This command add COMMIT as a new subtree at PREFIX.
   7530 
   7531 ‘O i m’ (‘magit-subtree-merge’)
   7532      This command merges COMMIT into the PREFIX subtree.
   7533 
   7534 ‘O i f’ (‘magit-subtree-pull’)
   7535      This command pulls COMMIT from REPOSITORY into the PREFIX subtree.
   7536 
   7537 ‘O e’ (‘magit-subtree-export’)
   7538      This transient prefix command binds the following suffix commands
   7539      along with the appropriate infix arguments and displays them in a
   7540      temporary buffer until a suffix is invoked.
   7541 
   7542      The suffixes of this command export subtrees.
   7543 
   7544      If the ‘--prefix’ argument is set, then the suffix commands use
   7545      that prefix without prompting the user.  If it is unset, then they
   7546      read the prefix in the minibuffer.
   7547 
   7548 ‘O e p’ (‘magit-subtree-push’)
   7549      This command extract the history of the subtree PREFIX and pushes
   7550      it to REF on REPOSITORY.
   7551 
   7552 ‘O e s’ (‘magit-subtree-split’)
   7553      This command extracts the history of the subtree PREFIX.
   7554 
   7555 
   7556 File: magit.info,  Node: Worktree,  Next: Sparse checkouts,  Prev: Subtree,  Up: Miscellaneous
   7557 
   7558 8.5 Worktree
   7559 ============
   7560 
   7561 Also see *note (gitman)git-worktree::.
   7562 
   7563 ‘Z’ (‘magit-worktree’)
   7564      This transient prefix command binds the following suffix commands
   7565      and displays them in a temporary buffer until a suffix is invoked.
   7566 
   7567 ‘Z b’ (‘magit-worktree-checkout’)
   7568      Checkout BRANCH in a new worktree at PATH.
   7569 
   7570 ‘Z c’ (‘magit-worktree-branch’)
   7571      Create a new BRANCH and check it out in a new worktree at PATH.
   7572 
   7573 ‘Z m’ (‘magit-worktree-move’)
   7574      Move an existing worktree to a new PATH.
   7575 
   7576 ‘Z k’ (‘magit-worktree-delete’)
   7577      Delete a worktree, defaulting to the worktree at point.  The
   7578      primary worktree cannot be deleted.
   7579 
   7580 ‘Z g’ (‘magit-worktree-status’)
   7581      Show the status for the worktree at point.
   7582 
   7583      If there is no worktree at point, then read one in the minibuffer.
   7584      If the worktree at point is the one whose status is already being
   7585      displayed in the current buffer, then show it in Dired instead.
   7586 
   7587 
   7588 File: magit.info,  Node: Sparse checkouts,  Next: Bundle,  Prev: Worktree,  Up: Miscellaneous
   7589 
   7590 8.6 Sparse checkouts
   7591 ====================
   7592 
   7593 Sparse checkouts provide a way to restrict the working tree to a subset
   7594 of directories.  See *note (gitman)git-sparse-checkout::.
   7595 
   7596    *Warning*: Git introduced the ‘git sparse-checkout’ command in
   7597 version 2.25 and still advertises it as experimental and subject to
   7598 change.  Magit’s interface should be considered the same.  In
   7599 particular, if Git introduces a backward incompatible change, Magit’s
   7600 sparse checkout functionality may be updated in a way that requires a
   7601 more recent Git version.
   7602 
   7603 ‘>’ (‘magit-sparse-checkout’)
   7604      This transient prefix command binds the following suffix commands
   7605      and displays them in a temporary buffer until a suffix is invoked.
   7606 
   7607 ‘> e’ (‘magit-sparse-checkout-enable’)
   7608      This command initializes a sparse checkout that includes only the
   7609      files in the top-level directory.
   7610 
   7611      Note that ‘magit-sparse-checkout-set’ and
   7612      ‘magit-sparse-checkout-add’ automatically initialize a sparse
   7613      checkout if necessary.  However, you may want to call
   7614      ‘magit-sparse-checkout-enable’ explicitly to re-initialize a sparse
   7615      checkout after calling ‘magit-sparse-checkout-disable’, to pass
   7616      additional arguments to ‘git sparse-checkout init’, or to execute
   7617      the initialization asynchronously.
   7618 
   7619 ‘> s’ (‘magit-sparse-checkout-set’)
   7620      This command takes a list of directories and configures the sparse
   7621      checkout to include only files in those subdirectories.  Any
   7622      previously included directories are excluded unless they are in the
   7623      provided list of directories.
   7624 
   7625 ‘> a’ (‘magit-sparse-checkout-add’)
   7626      This command is like ‘magit-sparse-checkout-set’, but instead adds
   7627      the specified list of directories to the set of directories that is
   7628      already included in the sparse checkout.
   7629 
   7630 ‘> r’ (‘magit-sparse-checkout-reapply’)
   7631      This command applies the currently configured sparse checkout
   7632      patterns to the working tree.  This is useful to call if excluded
   7633      files have been checked out after operations such as merging or
   7634      rebasing.
   7635 
   7636 ‘> d’ (‘magit-sparse-checkout-disable’)
   7637      This command restores the full checkout.  To return to the previous
   7638      sparse checkout, call ‘magit-sparse-checkout-enable’.
   7639 
   7640    A sparse checkout can also be initiated when cloning a repository by
   7641 using the ‘magit-clone-sparse’ command in the ‘magit-clone’ transient
   7642 (see *note Cloning Repository::).
   7643 
   7644    If you want the status buffer to indicate when a sparse checkout is
   7645 enabled, add the function ‘magit-sparse-checkout-insert-header’ to
   7646 ‘magit-status-headers-hook’.
   7647 
   7648 
   7649 File: magit.info,  Node: Bundle,  Next: Common Commands,  Prev: Sparse checkouts,  Up: Miscellaneous
   7650 
   7651 8.7 Bundle
   7652 ==========
   7653 
   7654 Also see *note (gitman)git-bundle::.
   7655 
   7656  -- Command: magit-bundle
   7657      This transient prefix command binds several suffix commands for
   7658      running ‘git bundle’ subcommands and displays them in a temporary
   7659      buffer until a suffix is invoked.
   7660 
   7661 
   7662 File: magit.info,  Node: Common Commands,  Next: Wip Modes,  Prev: Bundle,  Up: Miscellaneous
   7663 
   7664 8.8 Common Commands
   7665 ===================
   7666 
   7667  -- Command: magit-switch-to-repository-buffer
   7668  -- Command: magit-switch-to-repository-buffer-other-window
   7669  -- Command: magit-switch-to-repository-buffer-other-frame
   7670  -- Command: magit-display-repository-buffer
   7671      These commands read any existing Magit buffer that belongs to the
   7672      current repository from the user and then switch to the selected
   7673      buffer (without refreshing it).
   7674 
   7675      The last variant uses ‘magit-display-buffer’ to do so and thus
   7676      respects ‘magit-display-buffer-function’.
   7677 
   7678    These are some of the commands that can be used in all buffers whose
   7679 major-modes derive from ‘magit-mode’.  There are other common commands
   7680 beside the ones below, but these didn’t fit well anywhere else.
   7681 
   7682 ‘C-w’ (‘magit-copy-section-value’)
   7683      This command saves the value of the current section to the
   7684      ‘kill-ring’, and, provided that the current section is a commit,
   7685      branch, or tag section, it also pushes the (referenced) revision to
   7686      the ‘magit-revision-stack’.
   7687 
   7688      When the current section is a branch or a tag, and a prefix
   7689      argument is used, then it saves the revision at its tip to the
   7690      ‘kill-ring’ instead of the reference name.
   7691 
   7692      When the region is active, this command saves that to the
   7693      ‘kill-ring’, like ‘kill-ring-save’ would, instead of behaving as
   7694      described above.  If a prefix argument is used and the region is
   7695      within a hunk, then it strips the diff marker column and keeps only
   7696      either the added or removed lines, depending on the sign of the
   7697      prefix argument.
   7698 
   7699 ‘M-w’ (‘magit-copy-buffer-revision’)
   7700      This command saves the revision being displayed in the current
   7701      buffer to the ‘kill-ring’ and also pushes it to the
   7702      ‘magit-revision-stack’.  It is mainly intended for use in
   7703      ‘magit-revision-mode’ buffers, the only buffers where it is always
   7704      unambiguous exactly which revision should be saved.
   7705 
   7706      Most other Magit buffers usually show more than one revision, in
   7707      some way or another, so this command has to select one of them, and
   7708      that choice might not always be the one you think would have been
   7709      the best pick.
   7710 
   7711    Outside of Magit ‘M-w’ and ‘C-w’ are usually bound to
   7712 ‘kill-ring-save’ and ‘kill-region’, and these commands would also be
   7713 useful in Magit buffers.  Therefore when the region is active, then both
   7714 of these commands behave like ‘kill-ring-save’ instead of as described
   7715 above.
   7716 
   7717 
   7718 File: magit.info,  Node: Wip Modes,  Next: Commands for Buffers Visiting Files,  Prev: Common Commands,  Up: Miscellaneous
   7719 
   7720 8.9 Wip Modes
   7721 =============
   7722 
   7723 Git keeps *committed* changes around long enough for users to recover
   7724 changes they have accidentally deleted.  It does so by not garbage
   7725 collecting any committed but no longer referenced objects for a certain
   7726 period of time, by default 30 days.
   7727 
   7728    But Git does *not* keep track of *uncommitted* changes in the working
   7729 tree and not even the index (the staging area).  Because Magit makes it
   7730 so convenient to modify uncommitted changes, it also makes it easy to
   7731 shoot yourself in the foot in the process.
   7732 
   7733    For that reason Magit provides a global mode that saves *tracked*
   7734 files to work-in-progress references after or before certain actions.
   7735 (At present untracked files are never saved and for technical reasons
   7736 nothing is saved before the first commit has been created).
   7737 
   7738    Two separate work-in-progress references are used to track the state
   7739 of the index and of the working tree: ‘refs/wip/index/<branchref>’ and
   7740 ‘refs/wip/wtree/<branchref>’, where ‘<branchref>’ is the full ref of the
   7741 current branch, e.g., ‘refs/heads/master’.  When the ‘HEAD’ is detached
   7742 then ‘HEAD’ is used in place of ‘<branchref>’.
   7743 
   7744    Checking out another branch (or detaching ‘HEAD’) causes the use of
   7745 different wip refs for subsequent changes.
   7746 
   7747  -- User Option: magit-wip-mode
   7748      When this mode is enabled, then uncommitted changes are committed
   7749      to dedicated work-in-progress refs whenever appropriate (i.e., when
   7750      dataloss would be a possibility otherwise).
   7751 
   7752      Setting this variable directly does not take effect; either use the
   7753      Custom interface to do so or call the respective mode function.
   7754 
   7755      For historic reasons this mode is implemented on top of four other
   7756      ‘magit-wip-*’ modes, which can also be used individually, if you
   7757      want finer control over when the wip refs are updated; but that is
   7758      discouraged.  See *note Legacy Wip Modes::.
   7759 
   7760    To view the log for a branch and its wip refs use the commands
   7761 ‘magit-wip-log’ and ‘magit-wip-log-current’.  You should use ‘--graph’
   7762 when using these commands.
   7763 
   7764  -- Command: magit-wip-log
   7765      This command shows the log for a branch and its wip refs.  With a
   7766      negative prefix argument only the worktree wip ref is shown.
   7767 
   7768      The absolute numeric value of the prefix argument controls how many
   7769      "branches" of each wip ref are shown.  This is only relevant if the
   7770      value of ‘magit-wip-merge-branch’ is ‘nil’.
   7771 
   7772  -- Command: magit-wip-log-current
   7773      This command shows the log for the current branch and its wip refs.
   7774      With a negative prefix argument only the worktree wip ref is shown.
   7775 
   7776      The absolute numeric value of the prefix argument controls how many
   7777      "branches" of each wip ref are shown.  This is only relevant if the
   7778      value of ‘magit-wip-merge-branch’ is ‘nil’.
   7779 
   7780 ‘X w’ (‘magit-reset-worktree’)
   7781      This command resets the working tree to some commit read from the
   7782      user and defaulting to the commit at point, while keeping the
   7783      ‘HEAD’ and index as-is.
   7784 
   7785      This can be used to restore files to the state committed to a wip
   7786      ref.  Note that this will discard any unstaged changes that might
   7787      have existed before invoking this command (but of course only after
   7788      committing that to the working tree wip ref).
   7789 
   7790    Note that even if you enable ‘magit-wip-mode’ this won’t give you
   7791 perfect protection.  The most likely scenario for losing changes despite
   7792 the use of ‘magit-wip-mode’ is making a change outside Emacs and then
   7793 destroying it also outside Emacs.  In some such a scenario, Magit, being
   7794 an Emacs package, didn’t get the opportunity to keep you from shooting
   7795 yourself in the foot.
   7796 
   7797    When you are unsure whether Magit did commit a change to the wip
   7798 refs, then you can explicitly request that all changes to all tracked
   7799 files are being committed.
   7800 
   7801 ‘M-x magit-wip-commit’
   7802      This command commits all changes to all tracked files to the index
   7803      and working tree work-in-progress refs.  Like the modes described
   7804      above, it does not commit untracked files, but it does check all
   7805      tracked files for changes.  Use this command when you suspect that
   7806      the modes might have overlooked a change made outside Emacs/Magit.
   7807 
   7808  -- User Option: magit-wip-namespace
   7809      The namespace used for work-in-progress refs.  It has to end with a
   7810      slash.  The wip refs are named ‘<namespace>index/<branchref>’ and
   7811      ‘<namespace>wtree/<branchref>’.  When snapshots are created while
   7812      the ‘HEAD’ is detached then ‘HEAD’ is used in place of
   7813      ‘<branchref>’.
   7814 
   7815  -- User Option: magit-wip-mode-lighter
   7816      Mode-line lighter for ‘magit-wip--mode’.
   7817 
   7818 * Menu:
   7819 
   7820 * Wip Graph::
   7821 * Legacy Wip Modes::
   7822 
   7823 
   7824 File: magit.info,  Node: Wip Graph,  Next: Legacy Wip Modes,  Up: Wip Modes
   7825 
   7826 8.9.1 Wip Graph
   7827 ---------------
   7828 
   7829  -- User Option: magit-wip-merge-branch
   7830      This option controls whether the current branch is merged into the
   7831      wip refs after a new commit was created on the branch.
   7832 
   7833      If non-nil and the current branch has new commits, then it is
   7834      merged into the wip ref before creating a new wip commit.  This
   7835      makes it easier to inspect wip history and the wip commits are
   7836      never garbage collected.
   7837 
   7838      If nil and the current branch has new commits, then the wip ref is
   7839      reset to the tip of the branch before creating a new wip commit.
   7840      With this setting wip commits are eventually garbage collected.
   7841 
   7842    When ‘magit-wip-merge-branch’ is ‘t’, then the history looks like
   7843 this:
   7844 
   7845        *--*--*--*--*--*       refs/wip/index/refs/heads/master
   7846       /     /     /
   7847      A-----B-----C            refs/heads/master
   7848 
   7849    When ‘magit-wip-merge-branch’ is ‘nil’, then creating a commit on the
   7850 real branch and then making a change causes the wip refs to be recreated
   7851 to fork from the new commit.  But the old commits on the wip refs are
   7852 not lost.  They are still available from the reflog.  To make it easier
   7853 to see when the fork point of a wip ref was changed, an additional
   7854 commit with the message "restart autosaving" is created on it (‘xxO’
   7855 commits below are such boundary commits).
   7856 
   7857    Starting with
   7858 
   7859            BI0---BI1    refs/wip/index/refs/heads/master
   7860           /
   7861      A---B              refs/heads/master
   7862           \
   7863            BW0---BW1    refs/wip/wtree/refs/heads/master
   7864 
   7865    and committing the staged changes and editing and saving a file would
   7866 result in
   7867 
   7868            BI0---BI1        refs/wip/index/refs/heads/master
   7869           /
   7870      A---B---C              refs/heads/master
   7871           \   \
   7872            \   CW0---CW1    refs/wip/wtree/refs/heads/master
   7873             \
   7874              BW0---BW1      refs/wip/wtree/refs/heads/master@{2}
   7875 
   7876    The fork-point of the index wip ref is not changed until some change
   7877 is being staged.  Likewise just checking out a branch or creating a
   7878 commit does not change the fork-point of the working tree wip ref.  The
   7879 fork-points are not adjusted until there actually is a change that
   7880 should be committed to the respective wip ref.
   7881 
   7882 
   7883 File: magit.info,  Node: Legacy Wip Modes,  Prev: Wip Graph,  Up: Wip Modes
   7884 
   7885 8.9.2 Legacy Wip Modes
   7886 ----------------------
   7887 
   7888 It is recommended that you use the mode ‘magit-wip-mode’ (which see) and
   7889 ignore the existence of the following modes, which are preserved for
   7890 historic reasons.
   7891 
   7892    Setting the following variables directly does not take effect; either
   7893 use the Custom interface to do so or call the respective mode functions.
   7894 
   7895  -- User Option: magit-wip-after-save-mode
   7896      When this mode is enabled, then saving a buffer that visits a file
   7897      tracked in a Git repository causes its current state to be
   7898      committed to the working tree wip ref for the current branch.
   7899 
   7900  -- User Option: magit-wip-after-apply-mode
   7901      When this mode is enabled, then applying (i.e., staging, unstaging,
   7902      discarding, reversing, and regularly applying) a change to a file
   7903      tracked in a Git repository causes its current state to be
   7904      committed to the index and/or working tree wip refs for the current
   7905      branch.
   7906 
   7907    If you only ever edit files using Emacs and only ever interact with
   7908 Git using Magit, then the above two modes should be enough to protect
   7909 each and every change from accidental loss.  In practice nobody does
   7910 that.  Two additional modes exists that do commit to the wip refs before
   7911 making changes that could cause the loss of earlier changes.
   7912 
   7913  -- User Option: magit-wip-before-change-mode
   7914      When this mode is enabled, then certain commands commit the
   7915      existing changes to the files they are about to make changes to.
   7916 
   7917  -- User Option: magit-wip-initial-backup-mode
   7918      When this mode is enabled, then the current version of a file is
   7919      committed to the worktree wip ref before the buffer visiting that
   7920      file is saved for the first time since the buffer was created.
   7921 
   7922      This backs up the same version of the file that ‘backup-buffer’
   7923      would save.  While ‘backup-buffer’ uses a backup file, this mode
   7924      uses the same worktree wip ref as used by the other Magit Wip
   7925      modes.  Like ‘backup-buffer’, it only does this once; unless you
   7926      kill the buffer and visit the file again only one backup will be
   7927      created per Emacs session.
   7928 
   7929      This mode ignores the variables that affect ‘backup-buffer’ and can
   7930      be used along-side that function, which is recommended because it
   7931      only backs up files that are tracked in a Git repository.
   7932 
   7933  -- User Option: magit-wip-after-save-local-mode-lighter
   7934      Mode-line lighter for ‘magit-wip-after-save-local-mode’.
   7935 
   7936  -- User Option: magit-wip-after-apply-mode-lighter
   7937      Mode-line lighter for ‘magit-wip-after-apply-mode’.
   7938 
   7939  -- User Option: magit-wip-before-change-mode-lighter
   7940      Mode-line lighter for ‘magit-wip-before-change-mode’.
   7941 
   7942  -- User Option: magit-wip-initial-backup-mode-lighter
   7943      Mode-line lighter for ‘magit-wip-initial-backup-mode’.
   7944 
   7945 
   7946 File: magit.info,  Node: Commands for Buffers Visiting Files,  Next: Minor Mode for Buffers Visiting Blobs,  Prev: Wip Modes,  Up: Miscellaneous
   7947 
   7948 8.10 Commands for Buffers Visiting Files
   7949 ========================================
   7950 
   7951 By default Magit defines a few global key bindings.  These bindings are
   7952 a compromise between providing no bindings at all and providing the
   7953 better bindings I would have liked to use instead.  Magit cannot provide
   7954 the set of recommended bindings by default because those key sequences
   7955 are strictly reserved for bindings added by the user.  Also see *note
   7956 Global Bindings:: and *note (elisp)Key Binding Conventions::.
   7957 
   7958    To use the recommended bindings, add this to your init file and
   7959 restart Emacs.
   7960 
   7961      (setq magit-define-global-key-bindings 'recommended)
   7962 
   7963    If you don’t want Magit to add any bindings to the global keymap at
   7964 all, add this to your init file and restart Emacs.
   7965 
   7966      (setq magit-define-global-key-bindings nil)
   7967 
   7968 ‘C-c f’ (‘magit-file-dispatch’)
   7969 ‘C-c f s’ (‘magit-stage-file’)
   7970 ‘C-c f s’ (‘magit-stage-buffer-file’)
   7971 ‘C-c f u’ (‘magit-unstage-file’)
   7972 ‘C-c f u’ (‘magit-unstage-buffer-file’)
   7973 ‘C-c f , x’ (‘magit-file-untrack’)
   7974 ‘C-c f , r’ (‘magit-file-rename’)
   7975 ‘C-c f , k’ (‘magit-file-delete’)
   7976 ‘C-c f , c’ (‘magit-file-checkout’)
   7977 ‘C-c f D’ (‘magit-diff’)
   7978 ‘C-c f d’ (‘magit-diff-buffer-file’)
   7979 ‘C-c f L’ (‘magit-log’)
   7980 ‘C-c f l’ (‘magit-log-buffer-file’)
   7981 ‘C-c f t’ (‘magit-log-trace-definition’)
   7982 ‘C-c f M’ (‘magit-log-merged’)
   7983 ‘C-c f B’ (‘magit-blame’)
   7984 ‘C-c f b’ (‘magit-blame-additions’)
   7985 ‘C-c f r’ (‘magit-blame-removal’)
   7986 ‘C-c f f’ (‘magit-blame-reverse’)
   7987 ‘C-c f m’ (‘magit-blame-echo’)
   7988 ‘C-c f q’ (‘magit-blame-quit’)
   7989 ‘C-c f p’ (‘magit-blob-previous’)
   7990 ‘C-c f n’ (‘magit-blob-next’)
   7991 ‘C-c f v’ (‘magit-find-file’)
   7992 ‘C-c f V’ (‘magit-blob-visit-file’)
   7993 ‘C-c f g’ (‘magit-status-here’)
   7994 ‘C-c f G’ (‘magit-display-repository-buffer’)
   7995 ‘C-c f c’ (‘magit-commit’)
   7996 ‘C-c f e’ (‘magit-edit-line-commit’)
   7997      Each of these commands is documented individually right below,
   7998      alongside their default key bindings.  The bindings shown above are
   7999      the recommended bindings, which you can enable by following the
   8000      instructions further up.
   8001 
   8002 ‘C-c M-g’ (‘magit-file-dispatch’)
   8003      This transient prefix command binds the following suffix commands
   8004      and displays them in a temporary buffer until a suffix is invoked.
   8005 
   8006 ‘C-c M-g s’ (‘magit-stage-file’)
   8007 ‘C-c M-g s’ (‘magit-stage-buffer-file’)
   8008      Stage all changes to the file being visited in the current buffer.
   8009      When not visiting a file, then the first command is used, which
   8010      prompts for a file.
   8011 
   8012 ‘C-c M-g u’ (‘magit-unstage-file’)
   8013 ‘C-c M-g u’ (‘magit-unstage-buffer-file’)
   8014      Unstage all changes to the file being visited in the current
   8015      buffer.  When not visiting a file, then the first command is used,
   8016      which prompts for a file.
   8017 
   8018 ‘C-c M-g , x’ (‘magit-file-untrack’)
   8019      This command untracks a file read from the user, defaulting to the
   8020      visited file.
   8021 
   8022 ‘C-c M-g , r’ (‘magit-file-rename’)
   8023      This command renames a file read from the user, defaulting to the
   8024      visited file.
   8025 
   8026 ‘C-c M-g , k’ (‘magit-file-delete’)
   8027      This command deletes a file read from the user, defaulting to the
   8028      visited file.
   8029 
   8030 ‘C-c M-g , c’ (‘magit-file-checkout’)
   8031      This command updates a file in the working tree and index to the
   8032      contents from a revision.  Both the revision and file are read from
   8033      the user.
   8034 
   8035 ‘C-c M-g D’ (‘magit-diff’)
   8036      This transient prefix command binds several diff suffix commands
   8037      and infix arguments and displays them in a temporary buffer until a
   8038      suffix is invoked.  See *note Diffing::.
   8039 
   8040      This is the same command that ‘d’ is bound to in Magit buffers.  If
   8041      this command is invoked from a file-visiting buffer, then the
   8042      initial value of the option (‘--’) that limits the diff to certain
   8043      file(s) is set to the visited file.
   8044 
   8045 ‘C-c M-g d’ (‘magit-diff-buffer-file’)
   8046      This command shows the diff for the file of blob that the current
   8047      buffer visits.
   8048 
   8049  -- User Option: magit-diff-buffer-file-locked
   8050      This option controls whether ‘magit-diff-buffer-file’ uses a
   8051      dedicated buffer.  See *note Modes and Buffers::.
   8052 
   8053 ‘C-c M-g L’ (‘magit-log’)
   8054      This transient prefix command binds several log suffix commands and
   8055      infix arguments and displays them in a temporary buffer until a
   8056      suffix is invoked.  See *note Logging::.
   8057 
   8058      This is the same command that ‘l’ is bound to in Magit buffers.  If
   8059      this command is invoked from a file-visiting buffer, then the
   8060      initial value of the option (‘--’) that limits the log to certain
   8061      file(s) is set to the visited file.
   8062 
   8063 ‘C-c M-g l’ (‘magit-log-buffer-file’)
   8064      This command shows the log for the file of blob that the current
   8065      buffer visits.  Renames are followed when a prefix argument is used
   8066      or when ‘--follow’ is an active log argument.  When the region is
   8067      active, the log is restricted to the selected line range.
   8068 
   8069  -- User Option: magit-log-buffer-file-locked
   8070      This option controls whether ‘magit-log-buffer-file’ uses a
   8071      dedicated buffer.  See *note Modes and Buffers::.
   8072 
   8073 ‘C-c M-g t’ (‘magit-log-trace-definition’)
   8074      This command shows the log for the definition at point.
   8075 
   8076 ‘C-c M-g M’ (‘magit-log-merged’)
   8077      This command reads a commit and a branch in shows a log concerning
   8078      the merge of the former into the latter.  This shows multiple
   8079      commits even in case of a fast-forward merge.
   8080 
   8081 ‘C-c M-g B’ (‘magit-blame’)
   8082      This transient prefix command binds all blaming suffix commands
   8083      along with the appropriate infix arguments and displays them in a
   8084      temporary buffer until a suffix is invoked.
   8085 
   8086      For more information about this and the following commands also see
   8087      *note Blaming::.
   8088 
   8089      In addition to the ‘magit-blame’ sub-transient, the dispatch
   8090      transient also binds several blaming suffix commands directly.  See
   8091      *note Blaming:: for information about those commands and bindings.
   8092 
   8093 ‘C-c M-g p’ (‘magit-blob-previous’)
   8094      This command visits the previous blob which modified the current
   8095      file.
   8096 
   8097 ‘C-c M-g n’ (‘magit-blob-next’)
   8098      This command visits the next blob which modified the current file.
   8099 
   8100 ‘C-c M-g v’ (‘magit-find-file’)
   8101      This command reads a revision and file and visits the respective
   8102      blob.
   8103 
   8104 ‘C-c M-g V’ (‘magit-blob-visit-file’)
   8105      This command visits the file from the working tree, corresponding
   8106      to the current blob.  When visiting a blob or the version from the
   8107      index, then it goes to the same location in the respective file in
   8108      the working tree.
   8109 
   8110 ‘C-c M-g g’ (‘magit-status-here’)
   8111      This command displays the status of the current repository in a
   8112      buffer, like ‘magit-status’ does.  Additionally it tries to go to
   8113      the position in that buffer, which corresponds to the position in
   8114      the current file-visiting buffer (if any).
   8115 
   8116 ‘C-c M-g G’ (‘magit-display-repository-buffer’)
   8117      This command reads and displays a Magit buffer belonging to the
   8118      current repository, without refreshing it.
   8119 
   8120 ‘C-c M-g c’ (‘magit-commit’)
   8121      This transient prefix command binds the following suffix commands
   8122      along with the appropriate infix arguments and displays them in a
   8123      temporary buffer until a suffix is invoked.  See *note Initiating a
   8124      Commit::.
   8125 
   8126 ‘C-c M-g e’ (‘magit-edit-line-commit’)
   8127      This command makes the commit editable that added the current line.
   8128 
   8129      With a prefix argument it makes the commit editable that removes
   8130      the line, if any.  The commit is determined using ‘git blame’ and
   8131      made editable using ‘git rebase --interactive’ if it is reachable
   8132      from ‘HEAD’, or by checking out the commit (or a branch that points
   8133      at it) otherwise.
   8134 
   8135 
   8136 File: magit.info,  Node: Minor Mode for Buffers Visiting Blobs,  Prev: Commands for Buffers Visiting Files,  Up: Miscellaneous
   8137 
   8138 8.11 Minor Mode for Buffers Visiting Blobs
   8139 ==========================================
   8140 
   8141 The ‘magit-blob-mode’ enables certain Magit features in blob-visiting
   8142 buffers.  Such buffers can be created using ‘magit-find-file’ and some
   8143 of the commands mentioned below, which also take care of turning on this
   8144 minor mode.  Currently this mode only establishes a few key bindings,
   8145 but this might be extended.
   8146 
   8147 ‘p’ (‘magit-blob-previous’)
   8148      Visit the previous blob which modified the current file.
   8149 
   8150 ‘n’ (‘magit-blob-next’)
   8151      Visit the next blob which modified the current file.
   8152 
   8153 ‘q’ (‘magit-kill-this-buffer’)
   8154      Kill the current buffer.
   8155 
   8156 
   8157 File: magit.info,  Node: Customizing,  Next: Plumbing,  Prev: Miscellaneous,  Up: Top
   8158 
   8159 9 Customizing
   8160 *************
   8161 
   8162 Both Git and Emacs are highly customizable.  Magit is both a Git
   8163 porcelain as well as an Emacs package, so it makes sense to customize it
   8164 using both Git variables as well as Emacs options.  However this
   8165 flexibility doesn’t come without problems, including but not limited to
   8166 the following.
   8167 
   8168    • Some Git variables automatically have an effect in Magit without
   8169      requiring any explicit support.  Sometimes that is desirable - in
   8170      other cases, it breaks Magit.
   8171 
   8172      When a certain Git setting breaks Magit but you want to keep using
   8173      that setting on the command line, then that can be accomplished by
   8174      overriding the value for Magit only by appending something like
   8175      ‘("-c" "some.variable=compatible-value")’ to
   8176      ‘magit-git-global-arguments’.
   8177 
   8178    • Certain settings like ‘fetch.prune=true’ are respected by Magit
   8179      commands (because they simply call the respective Git command) but
   8180      their value is not reflected in the respective transient buffers.
   8181      In this case the ‘--prune’ argument in ‘magit-fetch’ might be
   8182      active or inactive, but that doesn’t keep the Git variable from
   8183      being honored by the suffix commands anyway.  So pruning might
   8184      happen despite the ‘--prune’ arguments being displayed in a way
   8185      that seems to indicate that no pruning will happen.
   8186 
   8187    I intend to address these and similar issues in a future release.
   8188 
   8189 * Menu:
   8190 
   8191 * Per-Repository Configuration::
   8192 * Essential Settings::
   8193 
   8194 
   8195 File: magit.info,  Node: Per-Repository Configuration,  Next: Essential Settings,  Up: Customizing
   8196 
   8197 9.1 Per-Repository Configuration
   8198 ================================
   8199 
   8200 Magit can be configured on a per-repository level using both Git
   8201 variables as well as Emacs options.
   8202 
   8203    To set a Git variable for one repository only, simply set it in
   8204 ‘/path/to/repo/.git/config’ instead of ‘$HOME/.gitconfig’ or
   8205 ‘/etc/gitconfig’.  See *note (gitman)git-config::.
   8206 
   8207    Similarly, Emacs options can be set for one repository only by
   8208 editing ‘/path/to/repo/.dir-locals.el’.  See *note (emacs)Directory
   8209 Variables::.  For example to disable automatic refreshes of
   8210 file-visiting buffers in just one huge repository use this:
   8211 
   8212    • ‘/path/to/huge/repo/.dir-locals.el’
   8213 
   8214           ((nil . ((magit-refresh-buffers . nil))))
   8215 
   8216    It might only be costly to insert certain information into Magit
   8217 buffers for repositories that are exceptionally large, in which case you
   8218 can disable the respective section inserters just for that repository:
   8219 
   8220    • ‘/path/to/tag/invested/repo/.dir-locals.el’
   8221 
   8222           ((magit-status-mode
   8223             . ((eval . (magit-disable-section-inserter 'magit-insert-tags-header)))))
   8224 
   8225  -- Function: magit-disable-section-inserter fn
   8226      This function disables the section inserter FN in the current
   8227      repository.  It is only intended for use in ‘.dir-locals.el’ and
   8228      ‘.dir-locals-2.el’.
   8229 
   8230    If you want to apply the same settings to several, but not all,
   8231 repositories then keeping the repository-local config files in sync
   8232 would quickly become annoying.  To avoid that you can create config
   8233 files for certain classes of repositories (e.g., "huge repositories")
   8234 and then include those files in the per-repository config files.  For
   8235 example:
   8236 
   8237    • ‘/path/to/huge/repo/.git/config’
   8238 
   8239           [include]
   8240                   path = /path/to/huge-gitconfig
   8241 
   8242    • ‘/path/to/huge-gitconfig’
   8243 
   8244           [status]
   8245                   showUntrackedFiles = no
   8246 
   8247    • ‘$HOME/.emacs.d/init.el’
   8248 
   8249           (dir-locals-set-class-variables 'huge-git-repository
   8250              '((nil . ((magit-refresh-buffers . nil)))))
   8251 
   8252           (dir-locals-set-directory-class
   8253              "/path/to/huge/repo/" 'huge-git-repository)
   8254 
   8255 
   8256 File: magit.info,  Node: Essential Settings,  Prev: Per-Repository Configuration,  Up: Customizing
   8257 
   8258 9.2 Essential Settings
   8259 ======================
   8260 
   8261 The next three sections list and discuss several variables that many
   8262 users might want to customize, for safety and/or performance reasons.
   8263 
   8264 * Menu:
   8265 
   8266 * Safety::
   8267 * Performance::
   8268 * Global Bindings::
   8269 
   8270 
   8271 File: magit.info,  Node: Safety,  Next: Performance,  Up: Essential Settings
   8272 
   8273 9.2.1 Safety
   8274 ------------
   8275 
   8276 This section discusses various variables that you might want to change
   8277 (or *not* change) for safety reasons.
   8278 
   8279    Git keeps *committed* changes around long enough for users to recover
   8280 changes they have accidentally been deleted.  It does not do the same
   8281 for *uncommitted* changes in the working tree and not even the index
   8282 (the staging area).  Because Magit makes it so easy to modify
   8283 uncommitted changes, it also makes it easy to shoot yourself in the foot
   8284 in the process.  For that reason Magit provides three global modes that
   8285 save *tracked* files to work-in-progress references after or before
   8286 certain actions.  See *note Wip Modes::.
   8287 
   8288    These modes are not enabled by default because of performance
   8289 concerns.  Instead a lot of potentially destructive commands require
   8290 confirmation every time they are used.  In many cases this can be
   8291 disabled by adding a symbol to ‘magit-no-confirm’ (see *note Completion
   8292 and Confirmation::).  If you enable the various wip modes then you
   8293 should add ‘safe-with-wip’ to this list.
   8294 
   8295    Similarly it isn’t necessary to require confirmation before moving a
   8296 file to the system trash - if you trashed a file by mistake then you can
   8297 recover it from there.  Option ‘magit-delete-by-moving-to-trash’
   8298 controls whether the system trash is used, which is the case by default.
   8299 Nevertheless, ‘trash’ isn’t a member of ‘magit-no-confirm’ - you might
   8300 want to change that.
   8301 
   8302    By default buffers visiting files are automatically reverted when the
   8303 visited file changes on disk.  This isn’t as risky as it might seem, but
   8304 to make an informed decision you should see *note Risk of Reverting
   8305 Automatically::.
   8306 
   8307 
   8308 File: magit.info,  Node: Performance,  Next: Global Bindings,  Prev: Safety,  Up: Essential Settings
   8309 
   8310 9.2.2 Performance
   8311 -----------------
   8312 
   8313 After Magit has run ‘git’ for side-effects, it also refreshes the
   8314 current Magit buffer and the respective status buffer.  This is
   8315 necessary because otherwise outdated information might be displayed
   8316 without the user noticing.  Magit buffers are updated by recreating
   8317 their content from scratch, which makes updating simpler and less
   8318 error-prone, but also more costly.  Keeping it simple and just
   8319 re-creating everything from scratch is an old design decision and
   8320 departing from that will require major refactoring.
   8321 
   8322    Meanwhile you can tell Magit to only automatically refresh the
   8323 current Magit buffer, but not the status buffer.  If you do that, then
   8324 the status buffer is only refreshed automatically if it is the current
   8325 buffer.
   8326 
   8327      (setq magit-refresh-status-buffer nil)
   8328 
   8329    You should also check whether any third-party packages have added
   8330 anything to ‘magit-refresh-buffer-hook’, ‘magit-pre-refresh-hook’, and
   8331 ‘magit-post-refresh-hook’.  If so, then check whether those additions
   8332 impact performance significantly.
   8333 
   8334    Magit can be told to refresh buffers verbosely using ‘M-x
   8335 magit-toggle-verbose-refresh’.  Enabling this helps figuring out which
   8336 sections are bottlenecks.  Each line printed to the ‘*Messages*’ buffer
   8337 contains a section name, the number of seconds it took to show this
   8338 section, and from 0 to 2 exclamation marks: the more exclamation marks
   8339 the slower the section is.
   8340 
   8341    Magit also reverts buffers for visited files located inside the
   8342 current repository when the visited file changes on disk.  That is
   8343 implemented on top of ‘auto-revert-mode’ from the built-in library
   8344 ‘autorevert’.  To figure out whether that impacts performance, check
   8345 whether performance is significantly worse, when many buffers exist
   8346 and/or when some buffers visit files using TRAMP.  If so, then this
   8347 should help.
   8348 
   8349      (setq auto-revert-buffer-list-filter
   8350            'magit-auto-revert-repository-buffer-p)
   8351 
   8352    For alternative approaches see *note Automatic Reverting of
   8353 File-Visiting Buffers::.
   8354 
   8355    If you have enabled any features that are disabled by default, then
   8356 you should check whether they impact performance significantly.  It’s
   8357 likely that they were not enabled by default because it is known that
   8358 they reduce performance at least in large repositories.
   8359 
   8360    If performance is only slow inside certain unusually large
   8361 repositories, then you might want to disable certain features on a
   8362 per-repository or per-repository-class basis only.  See *note
   8363 Per-Repository Configuration::.  For example it takes a long time to
   8364 determine the next and current tag in repository with exceptional
   8365 numbers of tags.  It would therefore be a good idea to disable
   8366 ‘magit-insert-tags-headers’, as explained at the mentioned node.
   8367 
   8368 * Menu:
   8369 
   8370 * Microsoft Windows Performance::
   8371 * MacOS Performance::
   8372 
   8373 Log Performance
   8374 ...............
   8375 
   8376 When showing logs, Magit limits the number of commits initially shown in
   8377 the hope that this avoids unnecessary work.  When ‘--graph’ is used,
   8378 then this unfortunately does not have the desired effect for large
   8379 histories.  Junio, Git’s maintainer, said on the Git mailing list
   8380 (<https://www.spinics.net/lists/git/msg232230.html>): "‘--graph’ wants
   8381 to compute the whole history and the max-count only affects the output
   8382 phase after ‘--graph’ does its computation".
   8383 
   8384    In other words, it’s not that Git is slow at outputting the
   8385 differences, or that Magit is slow at parsing the output - the problem
   8386 is that Git first goes outside and has a smoke.
   8387 
   8388    We actually work around this issue by limiting the number of commits
   8389 not only by using ‘-<N>’ but by also using a range.  But unfortunately
   8390 that’s not always possible.
   8391 
   8392    When more than a few thousand commits are shown, then the use of
   8393 ‘--graph’ can slow things down.
   8394 
   8395    Using ‘--color --graph’ is even slower.  Magit uses code that is part
   8396 of Emacs to turn control characters into faces.  That code is pretty
   8397 slow and this is quite noticeable when showing a log with many branches
   8398 and merges.  For that reason ‘--color’ is not enabled by default
   8399 anymore.  Consider leaving it at that.
   8400 
   8401 Diff Performance
   8402 ................
   8403 
   8404 If diffs are slow, then consider turning off some optional diff features
   8405 by setting all or some of the following variables to ‘nil’:
   8406 ‘magit-diff-highlight-indentation’, ‘magit-diff-highlight-trailing’,
   8407 ‘magit-diff-paint-whitespace’, ‘magit-diff-highlight-hunk-body’, and
   8408 ‘magit-diff-refine-hunk’.
   8409 
   8410    When showing a commit instead of some arbitrary diff, then some
   8411 additional information is displayed.  Calculating this information can
   8412 be quite expensive given certain circumstances.  If looking at a commit
   8413 using ‘magit-revision-mode’ takes considerably more time than looking at
   8414 the same commit in ‘magit-diff-mode’, then consider setting
   8415 ‘magit-revision-insert-related-refs’ to ‘nil’.
   8416 
   8417    When you are often confronted with diffs that contain deleted files,
   8418 then you might want to enable the ‘--irreversible-delete’ argument.  If
   8419 you do that then diffs still show that a file was deleted but without
   8420 also showing the complete deleted content of the file.  This argument is
   8421 not available by default, see *note (transient)Enabling and Disabling
   8422 Suffixes::.  Once you have done that you should enable it and save that
   8423 setting, see *note (transient)Saving Values::.  You should do this in
   8424 both the diff (‘d’) and the diff refresh (‘D’) transient popups.
   8425 
   8426 Refs Buffer Performance
   8427 .......................
   8428 
   8429 When refreshing the "references buffer" is slow, then that’s usually
   8430 because several hundred refs are being displayed.  The best way to
   8431 address that is to display fewer refs, obviously.
   8432 
   8433    If you are not, or only mildly, interested in seeing the list of
   8434 tags, then start by not displaying them:
   8435 
   8436      (remove-hook 'magit-refs-sections-hook 'magit-insert-tags)
   8437 
   8438    Then you should also make sure that the listed remote branches
   8439 actually all exist.  You can do so by pruning branches which no longer
   8440 exist using ‘f-pa’.
   8441 
   8442 Committing Performance
   8443 ......................
   8444 
   8445 When you initiate a commit, then Magit by default automatically shows a
   8446 diff of the changes you are about to commit.  For large commits this can
   8447 take a long time, which is especially distracting when you are
   8448 committing large amounts of generated data which you don’t actually
   8449 intend to inspect before committing.  This behavior can be turned off
   8450 using:
   8451 
   8452      (remove-hook 'server-switch-hook 'magit-commit-diff)
   8453      (remove-hook 'with-editor-filter-visit-hook 'magit-commit-diff)
   8454 
   8455    Then you can type ‘C-c C-d’ to show the diff when you actually want
   8456 to see it, but only then.  Alternatively you can leave the hook alone
   8457 and just type ‘C-g’ in those cases when it takes too long to generate
   8458 the diff.  If you do that, then you will end up with a broken diff
   8459 buffer, but doing it this way has the advantage that you usually get to
   8460 see the diff, which is useful because it increases the odds that you
   8461 spot potential issues.
   8462 
   8463 
   8464 File: magit.info,  Node: Microsoft Windows Performance,  Next: MacOS Performance,  Up: Performance
   8465 
   8466 Microsoft Windows Performance
   8467 .............................
   8468 
   8469 In order to update the status buffer, ‘git’ has to be run a few dozen
   8470 times.  That is problematic on Microsoft Windows, because that operating
   8471 system is exceptionally slow at starting processes.  Sadly this is an
   8472 issue that can only be fixed by Microsoft itself, and they don’t appear
   8473 to be particularly interested in doing so.
   8474 
   8475    Beside the subprocess issue, there are also other Windows-specific
   8476 performance issues.  Some of these have workarounds.  The maintainers of
   8477 "Git for Windows" try to improve performance on Windows.  Always use the
   8478 latest release in order to benefit from the latest performance tweaks.
   8479 Magit too tries to work around some Windows-specific issues.
   8480 
   8481    According to some sources, setting the following Git variables can
   8482 also help.
   8483 
   8484      git config --global core.preloadindex true   # default since v2.1
   8485      git config --global core.fscache true        # default since v2.8
   8486      git config --global gc.auto 256
   8487 
   8488    You should also check whether an anti-virus program is affecting
   8489 performance.
   8490 
   8491 
   8492 File: magit.info,  Node: MacOS Performance,  Prev: Microsoft Windows Performance,  Up: Performance
   8493 
   8494 MacOS Performance
   8495 .................
   8496 
   8497 Before Emacs 26.1 child processes were created using ‘fork’ on macOS.
   8498 That needlessly copied GUI resources, which is expensive.  The result
   8499 was that forking took about 30 times as long on Darwin than on Linux,
   8500 and because Magit starts many ‘git’ processes that made quite a
   8501 difference.
   8502 
   8503    So make sure that you are using at least Emacs 26.1, in which case
   8504 the faster ‘vfork’ will be used.  (The creation of child processes still
   8505 takes about twice as long on Darwin compared to Linux.)  See (1) for
   8506 more information.
   8507 
   8508    Additionally, ‘git’ installed from a package manager like ‘brew’ or
   8509 ‘nix’ seems to be slower than the native executable.  Profile the ‘git’
   8510 executable you’re running against the one at ‘/usr/bin/git’, and if you
   8511 notice a notable difference try using the latter as
   8512 ‘magit-git-executable’.
   8513 
   8514    ---------- Footnotes ----------
   8515 
   8516    (1) 
   8517 <https://lists.gnu.org/archive/html/bug-gnu-emacs/2017-04/msg00201.html>
   8518 
   8519 
   8520 File: magit.info,  Node: Global Bindings,  Prev: Performance,  Up: Essential Settings
   8521 
   8522 9.2.3 Global Bindings
   8523 ---------------------
   8524 
   8525  -- User Option: magit-define-global-key-bindings
   8526      This option controls which set of Magit key bindings, if any, may
   8527      be added to the global keymap, even before Magit is first used in
   8528      the current Emacs session.
   8529 
   8530         • If the value is ‘nil’, no bindings are added.
   8531 
   8532         • If ‘default’, maybe add:
   8533 
   8534           ‘C-x g’     ‘magit-status’
   8535           ‘C-x M-g’   ‘magit-dispatch’
   8536           ‘C-c M-g’   ‘magit-file-dispatch’
   8537 
   8538         • If ‘recommended’, maybe add:
   8539 
   8540           ‘C-x g’   ‘magit-status’
   8541           ‘C-c g’   ‘magit-dispatch’
   8542           ‘C-c f’   ‘magit-file-dispatch’
   8543 
   8544           These bindings are strongly recommended, but we cannot use
   8545           them by default, because the ‘C-c <LETTER>’ namespace is
   8546           strictly reserved for bindings added by the user (see *note
   8547           (elisp)Key Binding Conventions::).
   8548 
   8549      The bindings in the chosen set may be added when ‘after-init-hook’
   8550      is run.  Each binding is added if, and only if, at that time no
   8551      other key is bound to the same command, and no other command is
   8552      bound to the same key.  In other words we try to avoid adding
   8553      bindings that are unnecessary, as well as bindings that conflict
   8554      with other bindings.
   8555 
   8556      Adding these bindings is delayed until ‘after-init-hook’ is run to
   8557      allow users to set the variable anywhere in their init file
   8558      (without having to make sure to do so before ‘magit’ is loaded or
   8559      autoloaded) and to increase the likelihood that all the potentially
   8560      conflicting user bindings have already been added.
   8561 
   8562      To set this variable use either ‘setq’ or the Custom interface.  Do
   8563      not use the function ‘customize-set-variable’ because doing that
   8564      would cause Magit to be loaded immediately, when that form is
   8565      evaluated (this differs from ‘custom-set-variables’, which doesn’t
   8566      load the libraries that define the customized variables).
   8567 
   8568      Setting this variable has no effect if ‘after-init-hook’ has
   8569      already been run.
   8570 
   8571 
   8572 File: magit.info,  Node: Plumbing,  Next: FAQ,  Prev: Customizing,  Up: Top
   8573 
   8574 10 Plumbing
   8575 ***********
   8576 
   8577 The following sections describe how to use several of Magit’s core
   8578 abstractions to extend Magit itself or implement a separate extension.
   8579 
   8580    A few of the low-level features used by Magit have been factored out
   8581 into separate libraries/packages, so that they can be used by other
   8582 packages, without having to depend on Magit.  See *note
   8583 (with-editor)Top:: for information about ‘with-editor’.  ‘transient’
   8584 doesn’t have a manual yet.
   8585 
   8586    If you are trying to find an unused key that you can bind to a
   8587 command provided by your own Magit extension, then checkout
   8588 <https://github.com/magit/magit/wiki/Plugin-Dispatch-Key-Registry>.
   8589 
   8590 * Menu:
   8591 
   8592 * Calling Git::
   8593 * Section Plumbing::
   8594 * Refreshing Buffers::
   8595 * Conventions::
   8596 
   8597 
   8598 File: magit.info,  Node: Calling Git,  Next: Section Plumbing,  Up: Plumbing
   8599 
   8600 10.1 Calling Git
   8601 ================
   8602 
   8603 Magit provides many specialized functions for calling Git.  All of these
   8604 functions are defined in either ‘magit-git.el’ or ‘magit-process.el’ and
   8605 have one of the prefixes ‘magit-run-’, ‘magit-call-’, ‘magit-start-’, or
   8606 ‘magit-git-’ (which is also used for other things).
   8607 
   8608    All of these functions accept an indefinite number of arguments,
   8609 which are strings that specify command line arguments for Git (or in
   8610 some cases an arbitrary executable).  These arguments are flattened
   8611 before being passed on to the executable; so instead of strings they can
   8612 also be lists of strings and arguments that are ‘nil’ are silently
   8613 dropped.  Some of these functions also require a single mandatory
   8614 argument before these command line arguments.
   8615 
   8616    Roughly speaking, these functions run Git either to get some value or
   8617 for side-effects.  The functions that return a value are useful to
   8618 collect the information necessary to populate a Magit buffer, while the
   8619 others are used to implement Magit commands.
   8620 
   8621    The functions in the value-only group always run synchronously, and
   8622 they never trigger a refresh.  The function in the side-effect group can
   8623 be further divided into subgroups depending on whether they run Git
   8624 synchronously or asynchronously, and depending on whether they trigger a
   8625 refresh when the executable has finished.
   8626 
   8627 * Menu:
   8628 
   8629 * Getting a Value from Git::
   8630 * Calling Git for Effect::
   8631 
   8632 
   8633 File: magit.info,  Node: Getting a Value from Git,  Next: Calling Git for Effect,  Up: Calling Git
   8634 
   8635 10.1.1 Getting a Value from Git
   8636 -------------------------------
   8637 
   8638 These functions run Git in order to get a value, an exit status, or
   8639 output.  Of course you could also use them to run Git commands that have
   8640 side-effects, but that should be avoided.
   8641 
   8642  -- Function: magit-git-exit-code &rest args
   8643      Executes git with ARGS and returns its exit code.
   8644 
   8645  -- Function: magit-git-success &rest args
   8646      Executes git with ARGS and returns ‘t’ if the exit code is ‘0’,
   8647      ‘nil’ otherwise.
   8648 
   8649  -- Function: magit-git-failure &rest args
   8650      Executes git with ARGS and returns ‘t’ if the exit code is ‘1’,
   8651      ‘nil’ otherwise.
   8652 
   8653  -- Function: magit-git-true &rest args
   8654      Executes git with ARGS and returns ‘t’ if the first line printed by
   8655      git is the string "true", ‘nil’ otherwise.
   8656 
   8657  -- Function: magit-git-false &rest args
   8658      Executes git with ARGS and returns ‘t’ if the first line printed by
   8659      git is the string "false", ‘nil’ otherwise.
   8660 
   8661  -- Function: magit-git-insert &rest args
   8662      Executes git with ARGS and inserts its output at point.
   8663 
   8664  -- Function: magit-git-string &rest args
   8665      Executes git with ARGS and returns the first line of its output.
   8666      If there is no output or if it begins with a newline character,
   8667      then this returns ‘nil’.
   8668 
   8669  -- Function: magit-git-lines &rest args
   8670      Executes git with ARGS and returns its output as a list of lines.
   8671      Empty lines anywhere in the output are omitted.
   8672 
   8673  -- Function: magit-git-items &rest args
   8674      Executes git with ARGS and returns its null-separated output as a
   8675      list.  Empty items anywhere in the output are omitted.
   8676 
   8677      If the value of option ‘magit-git-debug’ is non-nil and git exits
   8678      with a non-zero exit status, then warn about that in the echo area
   8679      and add a section containing git’s standard error in the current
   8680      repository’s process buffer.
   8681 
   8682  -- Function: magit-process-git destination &rest args
   8683      Calls Git synchronously in a separate process, returning its exit
   8684      code.  DESTINATION specifies how to handle the output, like for
   8685      ‘call-process’, except that file handlers are supported.  Enables
   8686      Cygwin’s "noglob" option during the call and ensures unix eol
   8687      conversion.
   8688 
   8689  -- Function: magit-process-file process &optional infile buffer display
   8690           &rest args
   8691      Processes files synchronously in a separate process.  Identical to
   8692      ‘process-file’ but temporarily enables Cygwin’s "noglob" option
   8693      during the call and ensures unix eol conversion.
   8694 
   8695    If an error occurs when using one of the above functions, then that
   8696 is usually due to a bug, i.e., using an argument which is not actually
   8697 supported.  Such errors are usually not reported, but when they occur we
   8698 need to be able to debug them.
   8699 
   8700  -- User Option: magit-git-debug
   8701      Whether to report errors that occur when using ‘magit-git-insert’,
   8702      ‘magit-git-string’, ‘magit-git-lines’, or ‘magit-git-items’.  This
   8703      does not actually raise an error.  Instead a message is shown in
   8704      the echo area, and git’s standard error is insert into a new
   8705      section in the current repository’s process buffer.
   8706 
   8707  -- Function: magit-git-str &rest args
   8708      This is a variant of ‘magit-git-string’ that ignores the option
   8709      ‘magit-git-debug’.  It is mainly intended to be used while handling
   8710      errors in functions that do respect that option.  Using such a
   8711      function while handing an error could cause yet another error and
   8712      therefore lead to an infinite recursion.  You probably won’t ever
   8713      need to use this function.
   8714 
   8715 
   8716 File: magit.info,  Node: Calling Git for Effect,  Prev: Getting a Value from Git,  Up: Calling Git
   8717 
   8718 10.1.2 Calling Git for Effect
   8719 -----------------------------
   8720 
   8721 These functions are used to run git to produce some effect.  Most Magit
   8722 commands that actually run git do so by using such a function.
   8723 
   8724    Because we do not need to consume git’s output when using these
   8725 functions, their output is instead logged into a per-repository buffer,
   8726 which can be shown using ‘$’ from a Magit buffer or ‘M-x magit-process’
   8727 elsewhere.
   8728 
   8729    These functions can have an effect in two distinct ways.  Firstly,
   8730 running git may change something, i.e., create or push a new commit.
   8731 Secondly, that change may require that Magit buffers are refreshed to
   8732 reflect the changed state of the repository.  But refreshing isn’t
   8733 always desirable, so only some of these functions do perform such a
   8734 refresh after git has returned.
   8735 
   8736    Sometimes it is useful to run git asynchronously.  For example, when
   8737 the user has just initiated a push, then there is no reason to make her
   8738 wait until that has completed.  In other cases it makes sense to wait
   8739 for git to complete before letting the user do something else.  For
   8740 example after staging a change it is useful to wait until after the
   8741 refresh because that also automatically moves to the next change.
   8742 
   8743  -- Function: magit-call-git &rest args
   8744      Calls git synchronously with ARGS.
   8745 
   8746  -- Function: magit-call-process program &rest args
   8747      Calls PROGRAM synchronously with ARGS.
   8748 
   8749  -- Function: magit-run-git &rest args
   8750      Calls git synchronously with ARGS and then refreshes.
   8751 
   8752  -- Function: magit-run-git-with-input &rest args
   8753      Calls git synchronously with ARGS and sends it the content of the
   8754      current buffer on standard input.
   8755 
   8756      If the current buffer’s ‘default-directory’ is on a remote
   8757      filesystem, this function actually runs git asynchronously.  But
   8758      then it waits for the process to return, so the function itself is
   8759      synchronous.
   8760 
   8761  -- Function: magit-git &rest args
   8762      Calls git synchronously with ARGS for side-effects only.  This
   8763      function does not refresh the buffer.
   8764 
   8765  -- Function: magit-git-wash washer &rest args
   8766      Execute Git with ARGS, inserting washed output at point.  Actually
   8767      first insert the raw output at point.  If there is no output call
   8768      ‘magit-cancel-section’.  Otherwise temporarily narrow the buffer to
   8769      the inserted text, move to its beginning, and then call function
   8770      WASHER with ARGS as its sole argument.
   8771 
   8772    And now for the asynchronous variants.
   8773 
   8774  -- Function: magit-run-git-async &rest args
   8775      Start Git, prepare for refresh, and return the process object.
   8776      ARGS is flattened and then used as arguments to Git.
   8777 
   8778      Display the command line arguments in the echo area.
   8779 
   8780      After Git returns some buffers are refreshed: the buffer that was
   8781      current when this function was called (if it is a Magit buffer and
   8782      still alive), as well as the respective Magit status buffer.
   8783      Unmodified buffers visiting files that are tracked in the current
   8784      repository are reverted if ‘magit-revert-buffers’ is non-nil.
   8785 
   8786  -- Function: magit-run-git-with-editor &rest args
   8787      Export GIT_EDITOR and start Git.  Also prepare for refresh and
   8788      return the process object.  ARGS is flattened and then used as
   8789      arguments to Git.
   8790 
   8791      Display the command line arguments in the echo area.
   8792 
   8793      After Git returns some buffers are refreshed: the buffer that was
   8794      current when this function was called (if it is a Magit buffer and
   8795      still alive), as well as the respective Magit status buffer.
   8796 
   8797  -- Function: magit-start-git input &rest args
   8798      Start Git, prepare for refresh, and return the process object.
   8799 
   8800      If INPUT is non-nil, it has to be a buffer or the name of an
   8801      existing buffer.  The buffer content becomes the processes standard
   8802      input.
   8803 
   8804      Option ‘magit-git-executable’ specifies the Git executable and
   8805      option ‘magit-git-global-arguments’ specifies constant arguments.
   8806      The remaining arguments ARGS specify arguments to Git.  They are
   8807      flattened before use.
   8808 
   8809      After Git returns, some buffers are refreshed: the buffer that was
   8810      current when this function was called (if it is a Magit buffer and
   8811      still alive), as well as the respective Magit status buffer.
   8812      Unmodified buffers visiting files that are tracked in the current
   8813      repository are reverted if ‘magit-revert-buffers’ is non-nil.
   8814 
   8815  -- Function: magit-start-process &rest args
   8816      Start PROGRAM, prepare for refresh, and return the process object.
   8817 
   8818      If optional argument INPUT is non-nil, it has to be a buffer or the
   8819      name of an existing buffer.  The buffer content becomes the
   8820      processes standard input.
   8821 
   8822      The process is started using ‘start-file-process’ and then setup to
   8823      use the sentinel ‘magit-process-sentinel’ and the filter
   8824      ‘magit-process-filter’.  Information required by these functions is
   8825      stored in the process object.  When this function returns the
   8826      process has not started to run yet so it is possible to override
   8827      the sentinel and filter.
   8828 
   8829      After the process returns, ‘magit-process-sentinel’ refreshes the
   8830      buffer that was current when ‘magit-start-process’ was called (if
   8831      it is a Magit buffer and still alive), as well as the respective
   8832      Magit status buffer.  Unmodified buffers visiting files that are
   8833      tracked in the current repository are reverted if
   8834      ‘magit-revert-buffers’ is non-nil.
   8835 
   8836  -- Variable: magit-this-process
   8837      The child process which is about to start.  This can be used to
   8838      change the filter and sentinel.
   8839 
   8840  -- Variable: magit-process-raise-error
   8841      When this is non-nil, then ‘magit-process-sentinel’ raises an error
   8842      if git exits with a non-zero exit status.  For debugging purposes.
   8843 
   8844 
   8845 File: magit.info,  Node: Section Plumbing,  Next: Refreshing Buffers,  Prev: Calling Git,  Up: Plumbing
   8846 
   8847 10.2 Section Plumbing
   8848 =====================
   8849 
   8850 * Menu:
   8851 
   8852 * Creating Sections::
   8853 * Section Selection::
   8854 * Matching Sections::
   8855 
   8856 
   8857 File: magit.info,  Node: Creating Sections,  Next: Section Selection,  Up: Section Plumbing
   8858 
   8859 10.2.1 Creating Sections
   8860 ------------------------
   8861 
   8862  -- Macro: magit-insert-section &rest args
   8863      Insert a section at point.
   8864 
   8865      TYPE is the section type, a symbol.  Many commands that act on the
   8866      current section behave differently depending on that type.  Also if
   8867      a variable ‘magit-TYPE-section-map’ exists, then use that as the
   8868      text-property ‘keymap’ of all text belonging to the section (but
   8869      this may be overwritten in subsections).  TYPE can also have the
   8870      form ‘(eval FORM)’ in which case FORM is evaluated at runtime.
   8871 
   8872      Optional VALUE is the value of the section, usually a string that
   8873      is required when acting on the section.
   8874 
   8875      When optional HIDE is non-nil collapse the section body by default,
   8876      i.e., when first creating the section, but not when refreshing the
   8877      buffer.  Otherwise, expand it by default.  This can be overwritten
   8878      using ‘magit-section-set-visibility-hook’.  When a section is
   8879      recreated during a refresh, then the visibility of predecessor is
   8880      inherited and HIDE is ignored (but the hook is still honored).
   8881 
   8882      BODY is any number of forms that actually insert the section’s
   8883      heading and body.  Optional NAME, if specified, has to be a symbol,
   8884      which is then bound to the struct of the section being inserted.
   8885 
   8886      Before BODY is evaluated the ‘start’ of the section object is set
   8887      to the value of ‘point’ and after BODY was evaluated its ‘end’ is
   8888      set to the new value of ‘point’; BODY is responsible for moving
   8889      ‘point’ forward.
   8890 
   8891      If it turns out inside BODY that the section is empty, then
   8892      ‘magit-cancel-section’ can be used to abort and remove all traces
   8893      of the partially inserted section.  This can happen when creating a
   8894      section by washing Git’s output and Git didn’t actually output
   8895      anything this time around.
   8896 
   8897  -- Function: magit-insert-heading &rest args
   8898      Insert the heading for the section currently being inserted.
   8899 
   8900      This function should only be used inside ‘magit-insert-section’.
   8901 
   8902      When called without any arguments, then just set the ‘content’ slot
   8903      of the object representing the section being inserted to a marker
   8904      at ‘point’.  The section should only contain a single line when
   8905      this function is used like this.
   8906 
   8907      When called with arguments ARGS, which have to be strings, then
   8908      insert those strings at point.  The section should not contain any
   8909      text before this happens and afterwards it should again only
   8910      contain a single line.  If the ‘face’ property is set anywhere
   8911      inside any of these strings, then insert all of them unchanged.
   8912      Otherwise use the ‘magit-section-heading’ face for all inserted
   8913      text.
   8914 
   8915      The ‘content’ property of the section struct is the end of the
   8916      heading (which lasts from ‘start’ to ‘content’) and the beginning
   8917      of the body (which lasts from ‘content’ to ‘end’).  If the value of
   8918      ‘content’ is nil, then the section has no heading and its body
   8919      cannot be collapsed.  If a section does have a heading then its
   8920      height must be exactly one line, including a trailing newline
   8921      character.  This isn’t enforced; you are responsible for getting it
   8922      right.  The only exception is that this function does insert a
   8923      newline character if necessary.
   8924 
   8925  -- Function: magit-cancel-section
   8926      Cancel the section currently being inserted.  This exits the
   8927      innermost call to ‘magit-insert-section’ and removes all traces of
   8928      what has already happened inside that call.
   8929 
   8930  -- Function: magit-define-section-jumper sym title &optional value
   8931      Define an interactive function to go to section SYM.  TITLE is the
   8932      displayed title of the section.
   8933 
   8934 
   8935 File: magit.info,  Node: Section Selection,  Next: Matching Sections,  Prev: Creating Sections,  Up: Section Plumbing
   8936 
   8937 10.2.2 Section Selection
   8938 ------------------------
   8939 
   8940  -- Function: magit-current-section
   8941      Return the section at point.
   8942 
   8943  -- Function: magit-region-sections &optional condition multiple
   8944      Return a list of the selected sections.
   8945 
   8946      When the region is active and constitutes a valid section
   8947      selection, then return a list of all selected sections.  This is
   8948      the case when the region begins in the heading of a section and
   8949      ends in the heading of the same section or in that of a sibling
   8950      section.  If optional MULTIPLE is non-nil, then the region cannot
   8951      begin and end in the same section.
   8952 
   8953      When the selection is not valid, then return nil.  In this case,
   8954      most commands that can act on the selected sections will instead
   8955      act on the section at point.
   8956 
   8957      When the region looks like it would in any other buffer then the
   8958      selection is invalid.  When the selection is valid then the region
   8959      uses the ‘magit-section-highlight’ face.  This does not apply to
   8960      diffs where things get a bit more complicated, but even here if the
   8961      region looks like it usually does, then that’s not a valid
   8962      selection as far as this function is concerned.
   8963 
   8964      If optional CONDITION is non-nil, then the selection not only has
   8965      to be valid; all selected sections additionally have to match
   8966      CONDITION, or nil is returned.  See ‘magit-section-match’ for the
   8967      forms CONDITION can take.
   8968 
   8969  -- Function: magit-region-values &optional condition multiple
   8970      Return a list of the values of the selected sections.
   8971 
   8972      Return the values that themselves would be returned by
   8973      ‘magit-region-sections’ (which see).
   8974 
   8975 
   8976 File: magit.info,  Node: Matching Sections,  Prev: Section Selection,  Up: Section Plumbing
   8977 
   8978 10.2.3 Matching Sections
   8979 ------------------------
   8980 
   8981 ‘M-x magit-describe-section-briefly’
   8982      Show information about the section at point.  This command is
   8983      intended for debugging purposes.
   8984 
   8985  -- Function: magit-section-ident section
   8986      Return an unique identifier for SECTION.  The return value has the
   8987      form ‘((TYPE . VALUE)...)’.
   8988 
   8989  -- Function: magit-get-section ident &optional root
   8990      Return the section identified by IDENT.  IDENT has to be a list as
   8991      returned by ‘magit-section-ident’.
   8992 
   8993  -- Function: magit-section-match condition &optional section
   8994      Return ‘t’ if SECTION matches CONDITION.  SECTION defaults to the
   8995      section at point.  If SECTION is not specified and there also is no
   8996      section at point, then return ‘nil’.
   8997 
   8998      CONDITION can take the following forms:
   8999         • ‘(CONDITION...)’
   9000 
   9001           matches if any of the CONDITIONs matches.
   9002 
   9003         • ‘[CLASS...]’
   9004 
   9005           matches if the section’s class is the same as the first CLASS
   9006           or a subclass of that; the section’s parent class matches the
   9007           second CLASS; and so on.
   9008 
   9009         • ‘[* CLASS...]’
   9010 
   9011           matches sections that match ‘[CLASS...]’ and also recursively
   9012           all their child sections.
   9013 
   9014         • ‘CLASS’
   9015 
   9016           matches if the section’s class is the same as CLASS or a
   9017           subclass of that; regardless of the classes of the parent
   9018           sections.
   9019 
   9020      Each CLASS should be a class symbol, identifying a class that
   9021      derives from ‘magit-section’.  For backward compatibility CLASS can
   9022      also be a "type symbol".  A section matches such a symbol if the
   9023      value of its ‘type’ slot is ‘eq’.  If a type symbol has an entry in
   9024      ‘magit--section-type-alist’, then a section also matches that type
   9025      if its class is a subclass of the class that corresponds to the
   9026      type as per that alist.
   9027 
   9028      Note that it is not necessary to specify the complete section
   9029      lineage as printed by ‘magit-describe-section-briefly’, unless of
   9030      course you want to be that precise.
   9031 
   9032  -- Function: magit-section-value-if condition &optional section
   9033      If the section at point matches CONDITION, then return its value.
   9034 
   9035      If optional SECTION is non-nil then test whether that matches
   9036      instead.  If there is no section at point and SECTION is nil, then
   9037      return nil.  If the section does not match, then return nil.
   9038 
   9039      See ‘magit-section-match’ for the forms CONDITION can take.
   9040 
   9041  -- Function: magit-section-case &rest clauses
   9042      Choose among clauses on the type of the section at point.
   9043 
   9044      Each clause looks like (CONDITION BODY...).  The type of the
   9045      section is compared against each CONDITION; the BODY forms of the
   9046      first match are evaluated sequentially and the value of the last
   9047      form is returned.  Inside BODY the symbol ‘it’ is bound to the
   9048      section at point.  If no clause succeeds or if there is no section
   9049      at point return nil.
   9050 
   9051      See ‘magit-section-match’ for the forms CONDITION can take.
   9052      Additionally a CONDITION of t is allowed in the final clause and
   9053      matches if no other CONDITION match, even if there is no section at
   9054      point.
   9055 
   9056  -- Variable: magit-root-section
   9057      The root section in the current buffer.  All other sections are
   9058      descendants of this section.  The value of this variable is set by
   9059      ‘magit-insert-section’ and you should never modify it.
   9060 
   9061    For diff related sections a few additional tools exist.
   9062 
   9063  -- Function: magit-diff-type &optional section
   9064      Return the diff type of SECTION.
   9065 
   9066      The returned type is one of the symbols ‘staged’, ‘unstaged’,
   9067      ‘committed’, or ‘undefined’.  This type serves a similar purpose as
   9068      the general type common to all sections (which is stored in the
   9069      ‘type’ slot of the corresponding ‘magit-section’ struct) but takes
   9070      additional information into account.  When the SECTION isn’t
   9071      related to diffs and the buffer containing it also isn’t a
   9072      diff-only buffer, then return nil.
   9073 
   9074      Currently the type can also be one of ‘tracked’ and ‘untracked’,
   9075      but these values are not handled explicitly in every place they
   9076      should be.  A possible fix could be to just return nil here.
   9077 
   9078      The section has to be a ‘diff’ or ‘hunk’ section, or a section
   9079      whose children are of type ‘diff’.  If optional SECTION is nil,
   9080      return the diff type for the current section.  In buffers whose
   9081      major mode is ‘magit-diff-mode’ SECTION is ignored and the type is
   9082      determined using other means.  In ‘magit-revision-mode’ buffers the
   9083      type is always ‘committed’.
   9084 
   9085  -- Function: magit-diff-scope &optional section strict
   9086      Return the diff scope of SECTION or the selected section(s).
   9087 
   9088      A diff’s "scope" describes what part of a diff is selected, it is a
   9089      symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or
   9090      ‘list’.  Do not confuse this with the diff "type", as returned by
   9091      ‘magit-diff-type’.
   9092 
   9093      If optional SECTION is non-nil, then return the scope of that,
   9094      ignoring the sections selected by the region.  Otherwise return the
   9095      scope of the current section, or if the region is active and
   9096      selects a valid group of diff related sections, the type of these
   9097      sections, i.e., ‘hunks’ or ‘files’.  If SECTION (or if the current
   9098      section that is nil) is a ‘hunk’ section and the region starts and
   9099      ends inside the body of a that section, then the type is ‘region’.
   9100 
   9101      If optional STRICT is non-nil then return nil if the diff type of
   9102      the section at point is ‘untracked’ or the section at point is not
   9103      actually a ‘diff’ but a ‘diffstat’ section.
   9104 
   9105 
   9106 File: magit.info,  Node: Refreshing Buffers,  Next: Conventions,  Prev: Section Plumbing,  Up: Plumbing
   9107 
   9108 10.3 Refreshing Buffers
   9109 =======================
   9110 
   9111 All commands that create a new Magit buffer or change what is being
   9112 displayed in an existing buffer do so by calling ‘magit-mode-setup’.
   9113 Among other things, that function sets the buffer local values of
   9114 ‘default-directory’ (to the top-level of the repository),
   9115 ‘magit-refresh-function’, and ‘magit-refresh-args’.
   9116 
   9117    Buffers are refreshed by calling the function that is the local value
   9118 of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’,
   9119 where ‘*’ may be something like ‘diff’) with the value of
   9120 ‘magit-refresh-args’ as arguments.
   9121 
   9122  -- Macro: magit-mode-setup buffer switch-func mode refresh-func
   9123           &optional refresh-args
   9124      This function displays and selects BUFFER, turns on MODE, and
   9125      refreshes a first time.
   9126 
   9127      This function displays and optionally selects BUFFER by calling
   9128      ‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as
   9129      arguments.  Then it sets the local value of
   9130      ‘magit-refresh-function’ to REFRESH-FUNC and that of
   9131      ‘magit-refresh-args’ to REFRESH-ARGS.  Finally it creates the
   9132      buffer content by calling REFRESH-FUNC with REFRESH-ARGS as
   9133      arguments.
   9134 
   9135      All arguments are evaluated before switching to BUFFER.
   9136 
   9137  -- Function: magit-mode-display-buffer buffer mode &optional
   9138           switch-function
   9139      This function display BUFFER in some window and select it.  BUFFER
   9140      may be a buffer or a string, the name of a buffer.  The buffer is
   9141      returned.
   9142 
   9143      Unless BUFFER is already displayed in the selected frame, store the
   9144      previous window configuration as a buffer local value, so that it
   9145      can later be restored by ‘magit-mode-bury-buffer’.
   9146 
   9147      The buffer is displayed and selected using SWITCH-FUNCTION.  If
   9148      that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s
   9149      major mode derives from ‘magit-mode’.  Otherwise ‘switch-to-buffer’
   9150      is used.
   9151 
   9152  -- Variable: magit-refresh-function
   9153      The value of this buffer-local variable is the function used to
   9154      refresh the current buffer.  It is called with ‘magit-refresh-args’
   9155      as arguments.
   9156 
   9157  -- Variable: magit-refresh-args
   9158      The list of arguments used by ‘magit-refresh-function’ to refresh
   9159      the current buffer.  ‘magit-refresh-function’ is called with these
   9160      arguments.
   9161 
   9162      The value is usually set using ‘magit-mode-setup’, but in some
   9163      cases it’s also useful to provide commands that can change the
   9164      value.  For example, the ‘magit-diff-refresh’ transient can be used
   9165      to change any of the arguments used to display the diff, without
   9166      having to specify again which differences should be shown, but
   9167      ‘magit-diff-more-context’, ‘magit-diff-less-context’ and
   9168      ‘magit-diff-default-context’ change just the ‘-U<N>’ argument.  In
   9169      both case this is done by changing the value of this variable and
   9170      then calling this ‘magit-refresh-function’.
   9171 
   9172 
   9173 File: magit.info,  Node: Conventions,  Prev: Refreshing Buffers,  Up: Plumbing
   9174 
   9175 10.4 Conventions
   9176 ================
   9177 
   9178 Also see *note Completion and Confirmation::.
   9179 
   9180 * Menu:
   9181 
   9182 * Theming Faces::
   9183 
   9184 
   9185 File: magit.info,  Node: Theming Faces,  Up: Conventions
   9186 
   9187 10.4.1 Theming Faces
   9188 --------------------
   9189 
   9190 The default theme uses blue for local branches, green for remote
   9191 branches, and goldenrod (brownish yellow) for tags.  When creating a new
   9192 theme, you should probably follow that example.  If your theme already
   9193 uses other colors, then stick to that.
   9194 
   9195    In older releases these reference faces used to have a background
   9196 color and a box around them.  The basic default faces no longer do so,
   9197 to make Magit buffers much less noisy, and you should follow that
   9198 example at least with regards to boxes.  (Boxes were used in the past to
   9199 work around a conflict between the highlighting overlay and text
   9200 property backgrounds.  That’s no longer necessary because highlighting
   9201 no longer causes other background colors to disappear.)  Alternatively
   9202 you can keep the background color and/or box, but then have to take
   9203 special care to adjust ‘magit-branch-current’ accordingly.  By default
   9204 it looks mostly like ‘magit-branch-local’, but with a box (by default
   9205 the former is the only face that uses a box, exactly so that it sticks
   9206 out).  If the former also uses a box, then you have to make sure that it
   9207 differs in some other way from the latter.
   9208 
   9209    The most difficult faces to theme are those related to diffs,
   9210 headings, highlighting, and the region.  There are faces that fall into
   9211 all four groups - expect to spend some time getting this right.
   9212 
   9213    The ‘region’ face in the default theme, in both the light and dark
   9214 variants, as well as in many other themes, distributed with Emacs or by
   9215 third-parties, is very ugly.  It is common to use a background color
   9216 that really sticks out, which is ugly but if that were the only problem
   9217 then it would be acceptable.  Unfortunately many themes also set the
   9218 foreground color, which ensures that all text within the region is
   9219 readable.  Without doing that there might be cases where some foreground
   9220 color is too close to the region background color to still be readable.
   9221 But it also means that text within the region loses all syntax
   9222 highlighting.
   9223 
   9224    I consider the work that went into getting the ‘region’ face right to
   9225 be a good indicator for the general quality of a theme.  My
   9226 recommendation for the ‘region’ face is this: use a background color
   9227 slightly different from the background color of the ‘default’ face, and
   9228 do not set the foreground color at all.  So for a light theme you might
   9229 use a light (possibly tinted) gray as the background color of ‘default’
   9230 and a somewhat darker gray for the background of ‘region’.  That should
   9231 usually be enough to not collide with the foreground color of any other
   9232 face.  But if some other faces also set a light gray as background
   9233 color, then you should also make sure it doesn’t collide with those (in
   9234 some cases it might be acceptable though).
   9235 
   9236    Magit only uses the ‘region’ face when the region is "invalid" by its
   9237 own definition.  In a Magit buffer the region is used to either select
   9238 multiple sibling sections, so that commands which support it act on all
   9239 of these sections instead of just the current section, or to select
   9240 lines within a single hunk section.  In all other cases, the section is
   9241 considered invalid and Magit won’t act on it.  But such invalid sections
   9242 happen, either because the user has not moved point enough yet to make
   9243 it valid or because she wants to use a non-magit command to act on the
   9244 region, e.g., ‘kill-region’.
   9245 
   9246    So using the regular ‘region’ face for invalid sections is a feature.
   9247 It tells the user that Magit won’t be able to act on it.  It’s
   9248 acceptable if that face looks a bit odd and even (but less so) if it
   9249 collides with the background colors of section headings and other things
   9250 that have a background color.
   9251 
   9252    Magit highlights the current section.  If a section has subsections,
   9253 then all of them are highlighted.  This is done using faces that have
   9254 "highlight" in their names.  For most sections,
   9255 ‘magit-section-highlight’ is used for both the body and the heading.
   9256 Like the ‘region’ face, it should only set the background color to
   9257 something similar to that of ‘default’.  The highlight background color
   9258 must be different from both the ‘region’ background color and the
   9259 ‘default’ background color.
   9260 
   9261    For diff related sections Magit uses various faces to highlight
   9262 different parts of the selected section(s).  Note that hunk headings,
   9263 unlike all other section headings, by default have a background color,
   9264 because it is useful to have very visible separators between hunks.
   9265 That face ‘magit-diff-hunk-heading’, should be different from both
   9266 ‘magit-diff-hunk-heading-highlight’ and ‘magit-section-highlight’, as
   9267 well as from ‘magit-diff-context’ and ‘magit-diff-context-highlight’.
   9268 By default we do that by changing the foreground color.  Changing the
   9269 background color would lead to complications, and there are already
   9270 enough we cannot get around.  (Also note that it is generally a good
   9271 idea for section headings to always be bold, but only for sections that
   9272 have subsections).
   9273 
   9274    When there is a valid region selecting diff-related sibling sections,
   9275 i.e., multiple files or hunks, then the bodies of all these sections use
   9276 the respective highlight faces, but additionally the headings instead
   9277 use one of the faces ‘magit-diff-file-heading-selection’ or
   9278 ‘magit-diff-hunk-heading-selection’.  These faces have to be different
   9279 from the regular highlight variants to provide explicit visual
   9280 indication that the region is active.
   9281 
   9282    When theming diff related faces, start by setting the option
   9283 ‘magit-diff-refine-hunk’ to ‘all’.  You might personally prefer to only
   9284 refine the current hunk or not use hunk refinement at all, but some of
   9285 the users of your theme want all hunks to be refined, so you have to
   9286 cater to that.
   9287 
   9288    (Also turn on ‘magit-diff-highlight-indentation’,
   9289 ‘magit-diff-highlight-trailing’, and ‘magit-diff-paint-whitespace’; and
   9290 insert some whitespace errors into the code you use for testing.)
   9291 
   9292    For added lines you have to adjust three faces: ‘magit-diff-added’,
   9293 ‘magit-diff-added-highlight’, and ‘diff-refined-added’.  Make sure that
   9294 the latter works well with both of the former, as well as ‘smerge-other’
   9295 and ‘diff-added’.  Then do the same for the removed lines, context
   9296 lines, lines added by us, and lines added by them.  Also make sure the
   9297 respective added, removed, and context faces use approximately the same
   9298 saturation for both the highlighted and unhighlighted variants.  Also
   9299 make sure the file and diff headings work nicely with context lines
   9300 (e.g., make them look different).  Line faces should set both the
   9301 foreground and the background color.  For example, for added lines use
   9302 two different greens.
   9303 
   9304    It’s best if the foreground color of both the highlighted and the
   9305 unhighlighted variants are the same, so you will need to have to find a
   9306 color that works well on the highlight and unhighlighted background, the
   9307 refine background, and the highlight context background.  When there is
   9308 an hunk internal region, then the added- and removed-lines background
   9309 color is used only within that region.  Outside the region the
   9310 highlighted context background color is used.  This makes it easier to
   9311 see what is being staged.  With an hunk internal region the hunk heading
   9312 is shown using ‘magit-diff-hunk-heading-selection’, and so are the thin
   9313 lines that are added around the lines that fall within the region.  The
   9314 background color of that has to be distinct enough from the various
   9315 other involved background colors.
   9316 
   9317    Nobody said this would be easy.  If your theme restricts itself to a
   9318 certain set of colors, then you should make an exception here.
   9319 Otherwise it would be impossible to make the diffs look good in each and
   9320 every variation.  Actually you might want to just stick to the default
   9321 definitions for these faces.  You have been warned.  Also please note
   9322 that if you do not get this right, this will in some cases look to users
   9323 like bugs in Magit - so please do it right or not at all.
   9324 
   9325 
   9326 File: magit.info,  Node: FAQ,  Next: Debugging Tools,  Prev: Plumbing,  Up: Top
   9327 
   9328 Appendix A FAQ
   9329 **************
   9330 
   9331 The next two nodes lists frequently asked questions.  For a list of
   9332 frequently *and recently* asked questions, i.e., questions that haven’t
   9333 made it into the manual yet, see
   9334 <https://github.com/magit/magit/wiki/FAQ>.
   9335 
   9336    Please also see *note Debugging Tools::.
   9337 
   9338 * Menu:
   9339 
   9340 * FAQ - How to ...?::
   9341 * FAQ - Issues and Errors::
   9342 
   9343 
   9344 File: magit.info,  Node: FAQ - How to ...?,  Next: FAQ - Issues and Errors,  Up: FAQ
   9345 
   9346 A.1 FAQ - How to ...?
   9347 =====================
   9348 
   9349 * Menu:
   9350 
   9351 * How to pronounce Magit?::
   9352 * How to show git's output?::
   9353 * How to install the gitman info manual?::
   9354 * How to show diffs for gpg-encrypted files?::
   9355 * How does branching and pushing work?::
   9356 * Should I disable VC?::
   9357 
   9358 
   9359 File: magit.info,  Node: How to pronounce Magit?,  Next: How to show git's output?,  Up: FAQ - How to ...?
   9360 
   9361 A.1.1 How to pronounce Magit?
   9362 -----------------------------
   9363 
   9364 Either ‘mu[m's] git’ or ‘magi{c => t}’ is fine.
   9365 
   9366    The slogan is "It’s Magit!  The magical Git client", so it makes
   9367 sense to pronounce Magit like magic, while taking into account that C
   9368 and T do not sound the same.
   9369 
   9370    The German "Magie" is not pronounced the same as the English "magic",
   9371 so if you speak German then you can use the above rationale to justify
   9372 using the former pronunciation; ‘Mag{ie => it}’.
   9373 
   9374    You can also choose to use the former pronunciation just because you
   9375 like it better.
   9376 
   9377    Also see <https://magit.vc/assets/videos/magic.mp4>.  Also see
   9378 <https://emacs.stackexchange.com/questions/13696>.
   9379 
   9380 
   9381 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 ...?
   9382 
   9383 A.1.2 How to show git’s output?
   9384 -------------------------------
   9385 
   9386 To show the output of recently run git commands, press ‘$’ (or, if that
   9387 isn’t available, ‘M-x magit-process-buffer’).  This will show a buffer
   9388 containing a section per git invocation; as always press ‘TAB’ to expand
   9389 or collapse them.
   9390 
   9391    By default, git’s output is only inserted into the process buffer if
   9392 it is run for side-effects.  When the output is consumed in some way,
   9393 also inserting it into the process buffer would be too expensive.  For
   9394 debugging purposes, it’s possible to do so anyway by setting
   9395 ‘magit-git-debug’ to ‘t’.
   9396 
   9397 
   9398 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 ...?
   9399 
   9400 A.1.3 How to install the gitman info manual?
   9401 --------------------------------------------
   9402 
   9403 Git’s manpages can be exported as an info manual called ‘gitman’.
   9404 Magit’s own info manual links to nodes in that manual instead of the
   9405 actual manpages because Info doesn’t support linking to manpages.
   9406 
   9407    Unfortunately some distributions do not install the ‘gitman’ manual
   9408 by default and you will have to install a separate documentation package
   9409 to get it.
   9410 
   9411    Magit patches Info adding the ability to visit links to the ‘gitman’
   9412 Info manual by instead viewing the respective manpage.  If you prefer
   9413 that approach, then set the value of ‘magit-view-git-manual-method’ to
   9414 one of the supported packages ‘man’ or ‘woman’, e.g.:
   9415 
   9416      (setq magit-view-git-manual-method 'man)
   9417 
   9418 
   9419 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 ...?
   9420 
   9421 A.1.4 How to show diffs for gpg-encrypted files?
   9422 ------------------------------------------------
   9423 
   9424 Git supports showing diffs for encrypted files, but has to be told to do
   9425 so.  Since Magit just uses Git to get the diffs, configuring Git also
   9426 affects the diffs displayed inside Magit.
   9427 
   9428      git config --global diff.gpg.textconv "gpg --no-tty --decrypt"
   9429      echo "*.gpg filter=gpg diff=gpg" > .gitattributes
   9430 
   9431 
   9432 File: magit.info,  Node: How does branching and pushing work?,  Next: Should I disable VC?,  Prev: How to show diffs for gpg-encrypted files?,  Up: FAQ - How to ...?
   9433 
   9434 A.1.5 How does branching and pushing work?
   9435 ------------------------------------------
   9436 
   9437 Please see *note Branching:: and
   9438 <https://emacsair.me/2016/01/17/magit-2.4>
   9439 
   9440 
   9441 File: magit.info,  Node: Should I disable VC?,  Prev: How does branching and pushing work?,  Up: FAQ - How to ...?
   9442 
   9443 A.1.6 Should I disable VC?
   9444 --------------------------
   9445 
   9446 If you don’t use VC (the built-in version control interface) then you
   9447 might be tempted to disable it, not least because we used to recommend
   9448 that you do that.
   9449 
   9450    We no longer recommend that you disable VC.  Doing so would break
   9451 useful third-party packages (such as ‘diff-hl’), which depend on VC
   9452 being enabled.
   9453 
   9454    If you choose to disable VC anyway, then you can do so by changing
   9455 the value of ‘vc-handled-backends’.
   9456 
   9457 
   9458 File: magit.info,  Node: FAQ - Issues and Errors,  Prev: FAQ - How to ...?,  Up: FAQ
   9459 
   9460 A.2 FAQ - Issues and Errors
   9461 ===========================
   9462 
   9463 * Menu:
   9464 
   9465 * Magit is slow::
   9466 * I changed several thousand files at once and now Magit is unusable::
   9467 * I am having problems committing::
   9468 * I am using MS Windows and cannot push with Magit::
   9469 * I am using macOS and SOMETHING works in shell, but not in Magit: I am using macOS and SOMETHING works in shell but not in Magit.
   9470 * Expanding a file to show the diff causes it to disappear::
   9471 * Point is wrong in the COMMIT_EDITMSG buffer::
   9472 * The mode-line information isn't always up-to-date::
   9473 * A branch and tag sharing the same name breaks SOMETHING::
   9474 * My Git hooks work on the command-line but not inside Magit::
   9475 * git-commit-mode isn't used when committing from the command-line::
   9476 * Point ends up inside invisible text when jumping to a file-visiting buffer::
   9477 * I am no longer able to save popup defaults::
   9478 
   9479 
   9480 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
   9481 
   9482 A.2.1 Magit is slow
   9483 -------------------
   9484 
   9485 See *note Performance:: and *note I changed several thousand files at
   9486 once and now Magit is unusable::.
   9487 
   9488 
   9489 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
   9490 
   9491 A.2.2 I changed several thousand files at once and now Magit is unusable
   9492 ------------------------------------------------------------------------
   9493 
   9494 Magit is currently not expected to work well under such conditions.  It
   9495 sure would be nice if it did.  Reaching satisfactory performance under
   9496 such conditions will require some heavy refactoring.  This is no small
   9497 task but I hope to eventually find the time to make it happen.
   9498 
   9499    But for now we recommend you use the command line to complete this
   9500 one commit.  Also see *note Performance::.
   9501 
   9502 
   9503 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
   9504 
   9505 A.2.3 I am having problems committing
   9506 -------------------------------------
   9507 
   9508 That likely means that Magit is having problems finding an appropriate
   9509 emacsclient executable.  See *note (with-editor)Configuring
   9510 With-Editor:: and *note (with-editor)Debugging::.
   9511 
   9512 
   9513 File: magit.info,  Node: I am using MS Windows and cannot push with Magit,  Next: I am using macOS and SOMETHING works in shell but not in Magit,  Prev: I am having problems committing,  Up: FAQ - Issues and Errors
   9514 
   9515 A.2.4 I am using MS Windows and cannot push with Magit
   9516 ------------------------------------------------------
   9517 
   9518 It’s almost certain that Magit is only incidental to this issue.  It is
   9519 much more likely that this is a configuration issue, even if you can
   9520 push on the command line.
   9521 
   9522    Detailed setup instructions can be found at
   9523 <https://github.com/magit/magit/wiki/Pushing-with-Magit-from-Windows>.
   9524 
   9525 
   9526 File: magit.info,  Node: I am using macOS 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
   9527 
   9528 A.2.5 I am using macOS and SOMETHING works in shell, but not in Magit
   9529 ---------------------------------------------------------------------
   9530 
   9531 This usually occurs because Emacs doesn’t have the same environment
   9532 variables as your shell.  Try installing and configuring
   9533 <https://github.com/purcell/exec-path-from-shell>.  By default it
   9534 synchronizes ‘$PATH’, which helps Magit find the same ‘git’ as the one
   9535 you are using on the shell.
   9536 
   9537    If SOMETHING is "passphrase caching with gpg-agent for commit and/or
   9538 tag signing", then you’ll also need to synchronize ‘$GPG_AGENT_INFO’.
   9539 
   9540 
   9541 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 macOS and SOMETHING works in shell but not in Magit,  Up: FAQ - Issues and Errors
   9542 
   9543 A.2.6 Expanding a file to show the diff causes it to disappear
   9544 --------------------------------------------------------------
   9545 
   9546 This is probably caused by a customization of a ‘diff.*’ Git variable.
   9547 You probably set that variable for a reason, and should therefore only
   9548 undo that setting in Magit by customizing ‘magit-git-global-arguments’.
   9549 
   9550 
   9551 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
   9552 
   9553 A.2.7 Point is wrong in the ‘COMMIT_EDITMSG’ buffer
   9554 ---------------------------------------------------
   9555 
   9556 Neither Magit nor ‘git-commit.el’ fiddle with point in the buffer used
   9557 to write commit messages, so something else must be doing it.
   9558 
   9559    You have probably globally enabled a mode which restores point in
   9560 file-visiting buffers.  It might be a bit surprising, but when you write
   9561 a commit message, then you are actually editing a file.
   9562 
   9563    So you have to figure out which package is doing it.  ‘saveplace’,
   9564 ‘pointback’, and ‘session’ are likely candidates.  These snippets might
   9565 help:
   9566 
   9567      (setq session-name-disable-regexp "\\(?:\\`'\\.git/[A-Z_]+\\'\\)")
   9568 
   9569      (with-eval-after-load 'pointback
   9570        (lambda ()
   9571          (when (or git-commit-mode git-rebase-mode)
   9572            (pointback-mode -1))))
   9573 
   9574 
   9575 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
   9576 
   9577 A.2.8 The mode-line information isn’t always up-to-date
   9578 -------------------------------------------------------
   9579 
   9580 Magit is not responsible for the version control information that is
   9581 being displayed in the mode-line and looks something like ‘Git-master’.
   9582 The built-in "Version Control" package, also known as "VC", updates that
   9583 information, and can be told to do so more often:
   9584 
   9585      (setq auto-revert-check-vc-info t)
   9586 
   9587    But doing so isn’t good for performance.  For more (overly
   9588 optimistic) information see *note (emacs)VC Mode Line::.
   9589 
   9590    If you don’t really care about seeing this information in the
   9591 mode-line, but just don’t want to see _incorrect_ information, then
   9592 consider simply not displaying it in the mode-line:
   9593 
   9594      (setq-default mode-line-format
   9595                    (delete '(vc-mode vc-mode) mode-line-format))
   9596 
   9597 
   9598 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
   9599 
   9600 A.2.9 A branch and tag sharing the same name breaks SOMETHING
   9601 -------------------------------------------------------------
   9602 
   9603 Or more generally, ambiguous refnames break SOMETHING.
   9604 
   9605    Magit assumes that refs are named non-ambiguously across the
   9606 "refs/heads/", "refs/tags/", and "refs/remotes/" namespaces (i.e., all
   9607 the names remain unique when those prefixes are stripped).  We consider
   9608 ambiguous refnames unsupported and recommend that you use a
   9609 non-ambiguous naming scheme.  However, if you do work with a repository
   9610 that has ambiguous refnames, please report any issues you encounter, so
   9611 that we can investigate whether there is a simple fix.
   9612 
   9613 
   9614 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
   9615 
   9616 A.2.10 My Git hooks work on the command-line but not inside Magit
   9617 -----------------------------------------------------------------
   9618 
   9619 When Magit calls ‘git’ it adds a few global arguments including
   9620 ‘--literal-pathspecs’ and the ‘git’ process started by Magit then passes
   9621 that setting on to other ‘git’ process it starts itself.  It does so by
   9622 setting the environment variable ‘GIT_LITERAL_PATHSPECS’, not by calling
   9623 subprocesses with the ‘--literal-pathspecs’ argument.  You can therefore
   9624 override this setting in hook scripts using ‘unset
   9625 GIT_LITERAL_PATHSPECS’.
   9626 
   9627 
   9628 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
   9629 
   9630 A.2.11 ‘git-commit-mode’ isn’t used when committing from the command-line
   9631 -------------------------------------------------------------------------
   9632 
   9633 The reason for this is that ‘git-commit.el’ has not been loaded yet
   9634 and/or that the server has not been started yet.  These things have
   9635 always already been taken care of when you commit from Magit because in
   9636 order to do so, Magit has to be loaded and doing that involves loading
   9637 ‘git-commit’ and starting the server.
   9638 
   9639    If you want to commit from the command-line, then you have to take
   9640 care of these things yourself.  Your ‘init.el’ file should contain:
   9641 
   9642      (require 'git-commit)
   9643      (server-mode)
   9644 
   9645    Instead of ‘(require ’git-commit)‘ you may also use:
   9646 
   9647      (load "/path/to/magit-autoloads.el")
   9648 
   9649    You might want to do that because loading ‘git-commit’ causes large
   9650 parts of Magit to be loaded.
   9651 
   9652    There are also some variations of ‘(server-mode)’ that you might want
   9653 to try.  Personally I use:
   9654 
   9655      (use-package server
   9656        :config (or (server-running-p) (server-mode)))
   9657 
   9658    Now you can use:
   9659 
   9660      $ emacs&
   9661      $ EDITOR=emacsclient git commit
   9662 
   9663    However you cannot use:
   9664 
   9665      $ killall emacs
   9666      $ EDITOR="emacsclient --alternate-editor emacs" git commit
   9667 
   9668    This will actually end up using ‘emacs’, not ‘emacsclient’.  If you
   9669 do this, then you can still edit the commit message but
   9670 ‘git-commit-mode’ won’t be used and you have to exit ‘emacs’ to finish
   9671 the process.
   9672 
   9673    Tautology ahead.  If you want to be able to use ‘emacsclient’ to
   9674 connect to a running ‘emacs’ instance, even though no ‘emacs’ instance
   9675 is running, then you cannot use ‘emacsclient’ directly.
   9676 
   9677    Instead you have to create a script that does something like this:
   9678 
   9679    Try to use ‘emacsclient’ (without using ‘--alternate-editor’).  If
   9680 that succeeds, do nothing else.  Otherwise start ‘emacs &’ (and
   9681 ‘init.el’ must call ‘server-start’) and try to use ‘emacsclient’ again.
   9682 
   9683 
   9684 File: magit.info,  Node: Point ends up inside invisible text when jumping to a file-visiting buffer,  Next: I am no longer able to save popup defaults,  Prev: git-commit-mode isn't used when committing from the command-line,  Up: FAQ - Issues and Errors
   9685 
   9686 A.2.12 Point ends up inside invisible text when jumping to a file-visiting buffer
   9687 ---------------------------------------------------------------------------------
   9688 
   9689 This can happen when you type ‘RET’ on a hunk to visit the respective
   9690 file at the respective position.  One solution to this problem is to use
   9691 ‘global-reveal-mode’.  It makes sure that text around point is always
   9692 visible.  If that is too drastic for your taste, then you may instead
   9693 use ‘magit-diff-visit-file-hook’ to reveal the text, possibly using
   9694 ‘reveal-post-command’ or for Org buffers ‘org-reveal’.
   9695 
   9696 
   9697 File: magit.info,  Node: 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
   9698 
   9699 A.2.13 I am no longer able to save popup defaults
   9700 -------------------------------------------------
   9701 
   9702 Magit used to use Magit-Popup to implement the transient popup menus.
   9703 Now it used Transient instead, which is Magit-Popup’s successor.
   9704 
   9705    In the older Magit-Popup menus, it was possible to save user settings
   9706 (e.g., setting the gpg signing key for commits) by using ‘C-c C-c’ in
   9707 the popup buffer.  This would dismiss the popup, but save the settings
   9708 as the defaults for future popups.
   9709 
   9710    When switching to Transient menus, this functionality is now
   9711 available via ‘C-x C-s’ instead; the ‘C-x’ prefix has other options as
   9712 well when using Transient, which will be displayed when it is typed.
   9713 See <https://magit.vc/manual/transient/Saving-Values.html#Saving-Values>
   9714 for more details.
   9715 
   9716 
   9717 File: magit.info,  Node: Debugging Tools,  Next: Keystroke Index,  Prev: FAQ,  Up: Top
   9718 
   9719 B Debugging Tools
   9720 *****************
   9721 
   9722 Magit and its dependencies provide a few debugging tools, and we
   9723 appreciate it very much if you use those tools before reporting an
   9724 issue.  Please include all relevant output when reporting an issue.
   9725 
   9726 ‘M-x magit-version’
   9727      This command shows the currently used versions of Magit, Git, and
   9728      Emacs in the echo area.  Non-interactively this just returns the
   9729      Magit version.
   9730 
   9731 ‘M-x magit-emacs-Q-command’
   9732      This command shows a debugging shell command in the echo area and
   9733      adds it to the kill ring.  Paste that command into a shell and run
   9734      it.
   9735 
   9736      This shell command starts ‘emacs’ with only ‘magit’ and its
   9737      dependencies loaded.  Neither your configuration nor other
   9738      installed packages are loaded.  This makes it easier to determine
   9739      whether some issue lays with Magit or something else.
   9740 
   9741      If you run Magit from its Git repository, then you should be able
   9742      to use ‘make emacs-Q’ instead of the output of this command.
   9743 
   9744 ‘M-x magit-toggle-git-debug’
   9745      This command toggles whether additional git errors are reported.
   9746 
   9747      Magit basically calls git for one of these two reasons: for
   9748      side-effects or to do something with its standard output.
   9749 
   9750      When git is run for side-effects then its output, including error
   9751      messages, go into the process buffer which is shown when using ‘$’.
   9752 
   9753      When git’s output is consumed in some way, then it would be too
   9754      expensive to also insert it into this buffer, but when this option
   9755      is non-nil and git returns with a non-zero exit status, then at
   9756      least its standard error is inserted into this buffer.
   9757 
   9758      This is only intended for debugging purposes.  Do not enable this
   9759      permanently, that would negatively affect performance.  Also note
   9760      that just because git exits with a non-zero exit status and prints
   9761      an error message that usually doesn’t mean that it is an error as
   9762      far as Magit is concerned, which is another reason we usually hide
   9763      these error messages.  Whether some error message is relevant in
   9764      the context of some unexpected behavior has to be judged on a case
   9765      by case basis.
   9766 
   9767 ‘M-x magit-toggle-verbose-refresh’
   9768      This command toggles whether Magit refreshes buffers verbosely.
   9769      Enabling this helps figuring out which sections are bottlenecks.
   9770      The additional output can be found in the ‘*Messages*’ buffer.
   9771 
   9772 ‘M-x magit-debug-git-executable’
   9773      This command displays a buffer containing information about the
   9774      available and used ‘git’ executable(s), and can be useful when
   9775      investigating ‘exec-path’ issues.
   9776 
   9777      Also see *note Git Executable::.
   9778 
   9779 ‘M-x with-editor-debug’
   9780      This command displays a buffer containing information about the
   9781      available and used ‘emacsclient’ executable(s), and can be useful
   9782      when investigating why Magit (or rather ‘with-editor’) cannot find
   9783      an appropriate ‘emacsclient’ executable.
   9784 
   9785      Also see *note (with-editor)Debugging::.
   9786 
   9787 Please also see *note FAQ::.
   9788 
   9789 
   9790 File: magit.info,  Node: Keystroke Index,  Next: Function and Command Index,  Prev: Debugging Tools,  Up: Top
   9791 
   9792 Appendix C Keystroke Index
   9793 **************************
   9794 
   9795 
   9796 * Menu:
   9797 
   9798 * !:                                     Running Git Manually.
   9799                                                               (line  13)
   9800 * ! !:                                   Running Git Manually.
   9801                                                               (line  17)
   9802 * ! a:                                   Running Git Manually.
   9803                                                               (line  53)
   9804 * ! b:                                   Running Git Manually.
   9805                                                               (line  56)
   9806 * ! g:                                   Running Git Manually.
   9807                                                               (line  59)
   9808 * ! k:                                   Running Git Manually.
   9809                                                               (line  50)
   9810 * ! m:                                   Running Git Manually.
   9811                                                               (line  62)
   9812 * ! p:                                   Running Git Manually.
   9813                                                               (line  25)
   9814 * ! s:                                   Running Git Manually.
   9815                                                               (line  34)
   9816 * ! S:                                   Running Git Manually.
   9817                                                               (line  38)
   9818 * $:                                     Viewing Git Output.  (line  17)
   9819 * +:                                     Log Buffer.          (line  64)
   9820 * + <1>:                                 Refreshing Diffs.    (line  65)
   9821 * -:                                     Log Buffer.          (line  67)
   9822 * - <1>:                                 Refreshing Diffs.    (line  62)
   9823 * 0:                                     Refreshing Diffs.    (line  68)
   9824 * 1:                                     Section Visibility.  (line  39)
   9825 * 2:                                     Section Visibility.  (line  39)
   9826 * 3:                                     Section Visibility.  (line  39)
   9827 * 4:                                     Section Visibility.  (line  39)
   9828 * 5:                                     Repository List.     (line 115)
   9829 * ::                                     Running Git Manually.
   9830                                                               (line  25)
   9831 * =:                                     Log Buffer.          (line  59)
   9832 * >:                                     Sparse checkouts.    (line  17)
   9833 * > a:                                   Sparse checkouts.    (line  39)
   9834 * > d:                                   Sparse checkouts.    (line  50)
   9835 * > e:                                   Sparse checkouts.    (line  21)
   9836 * > r:                                   Sparse checkouts.    (line  44)
   9837 * > s:                                   Sparse checkouts.    (line  33)
   9838 * ^:                                     Section Movement.    (line  28)
   9839 * a:                                     Applying.            (line  34)
   9840 * A:                                     Cherry Picking.      (line   9)
   9841 * A A:                                   Cherry Picking.      (line  17)
   9842 * A a:                                   Cherry Picking.      (line  23)
   9843 * A A <1>:                               Cherry Picking.      (line  85)
   9844 * A a <1>:                               Cherry Picking.      (line  91)
   9845 * A d:                                   Cherry Picking.      (line  51)
   9846 * A h:                                   Cherry Picking.      (line  40)
   9847 * A n:                                   Cherry Picking.      (line  62)
   9848 * A s:                                   Cherry Picking.      (line  72)
   9849 * A s <1>:                               Cherry Picking.      (line  88)
   9850 * B:                                     Bisecting.           (line   9)
   9851 * b:                                     Blaming.             (line 115)
   9852 * b <1>:                                 Branch Commands.     (line  13)
   9853 * b <2>:                                 Editing Rebase Sequences.
   9854                                                               (line  70)
   9855 * B B:                                   Bisecting.           (line  16)
   9856 * B b:                                   Bisecting.           (line  32)
   9857 * b b:                                   Branch Commands.     (line  47)
   9858 * b C:                                   Branch Commands.     (line  31)
   9859 * b c:                                   Branch Commands.     (line  63)
   9860 * B g:                                   Bisecting.           (line  36)
   9861 * B k:                                   Bisecting.           (line  46)
   9862 * b k:                                   Branch Commands.     (line 138)
   9863 * b l:                                   Branch Commands.     (line  69)
   9864 * B m:                                   Bisecting.           (line  40)
   9865 * b m:                                   Branch Commands.     (line 149)
   9866 * b n:                                   Branch Commands.     (line  54)
   9867 * B r:                                   Bisecting.           (line  51)
   9868 * B s:                                   Bisecting.           (line  26)
   9869 * b s:                                   Branch Commands.     (line  91)
   9870 * b S:                                   Branch Commands.     (line 118)
   9871 * b x:                                   Branch Commands.     (line 123)
   9872 * c:                                     Blaming.             (line 141)
   9873 * C:                                     Cloning Repository.  (line  20)
   9874 * c <1>:                                 Initiating a Commit. (line   9)
   9875 * c <2>:                                 Editing Rebase Sequences.
   9876                                                               (line  59)
   9877 * C >:                                   Cloning Repository.  (line  38)
   9878 * c a:                                   Initiating a Commit. (line  18)
   9879 * c A:                                   Initiating a Commit. (line  59)
   9880 * C b:                                   Cloning Repository.  (line  44)
   9881 * C C:                                   Cloning Repository.  (line  28)
   9882 * c c:                                   Initiating a Commit. (line  14)
   9883 * C d:                                   Cloning Repository.  (line  55)
   9884 * C e:                                   Cloning Repository.  (line  61)
   9885 * c e:                                   Initiating a Commit. (line  21)
   9886 * c f:                                   Initiating a Commit. (line  39)
   9887 * c F:                                   Initiating a Commit. (line  46)
   9888 * C m:                                   Cloning Repository.  (line  48)
   9889 * C s:                                   Cloning Repository.  (line  32)
   9890 * c s:                                   Initiating a Commit. (line  49)
   9891 * c S:                                   Initiating a Commit. (line  56)
   9892 * c w:                                   Initiating a Commit. (line  30)
   9893 * C-<return>:                            Visiting Files and Blobs from a Diff.
   9894                                                               (line  50)
   9895 * C-<tab>:                               Section Visibility.  (line  14)
   9896 * C-c C-a:                               Commit Pseudo Headers.
   9897                                                               (line  16)
   9898 * C-c C-b:                               Log Buffer.          (line  20)
   9899 * C-c C-b <1>:                           Refreshing Diffs.    (line  84)
   9900 * C-c C-c:                               Select from Log.     (line  21)
   9901 * C-c C-c <1>:                           Editing Commit Messages.
   9902                                                               (line  18)
   9903 * C-c C-c <2>:                           Editing Rebase Sequences.
   9904                                                               (line   7)
   9905 * C-c C-d:                               Refreshing Diffs.    (line  75)
   9906 * C-c C-d <1>:                           Editing Commit Messages.
   9907                                                               (line  54)
   9908 * C-c C-e:                               Commands Available in Diffs.
   9909                                                               (line  24)
   9910 * C-c C-f:                               Log Buffer.          (line  23)
   9911 * C-c C-f <1>:                           Refreshing Diffs.    (line  87)
   9912 * C-c C-i:                               Commit Pseudo Headers.
   9913                                                               (line  13)
   9914 * C-c C-k:                               Select from Log.     (line  26)
   9915 * C-c C-k <1>:                           Editing Commit Messages.
   9916                                                               (line  22)
   9917 * C-c C-k <2>:                           Editing Rebase Sequences.
   9918                                                               (line  11)
   9919 * C-c C-n:                               Log Buffer.          (line  26)
   9920 * C-c C-o:                               Commit Pseudo Headers.
   9921                                                               (line  28)
   9922 * C-c C-p:                               Commit Pseudo Headers.
   9923                                                               (line  31)
   9924 * C-c C-r:                               Commit Pseudo Headers.
   9925                                                               (line  19)
   9926 * C-c C-s:                               Commit Pseudo Headers.
   9927                                                               (line  22)
   9928 * C-c C-t:                               Commands Available in Diffs.
   9929                                                               (line  15)
   9930 * C-c C-t <1>:                           Commit Pseudo Headers.
   9931                                                               (line  25)
   9932 * C-c C-w:                               Using the Revision Stack.
   9933                                                               (line   7)
   9934 * C-c f:                                 Commands for Buffers Visiting Files.
   9935                                                               (line  52)
   9936 * C-c f , c:                             Commands for Buffers Visiting Files.
   9937                                                               (line  52)
   9938 * C-c f , k:                             Commands for Buffers Visiting Files.
   9939                                                               (line  52)
   9940 * C-c f , r:                             Commands for Buffers Visiting Files.
   9941                                                               (line  52)
   9942 * C-c f , x:                             Commands for Buffers Visiting Files.
   9943                                                               (line  52)
   9944 * C-c f B:                               Blaming.             (line  28)
   9945 * C-c f b:                               Blaming.             (line  28)
   9946 * C-c f B <1>:                           Commands for Buffers Visiting Files.
   9947                                                               (line  52)
   9948 * C-c f b <1>:                           Commands for Buffers Visiting Files.
   9949                                                               (line  52)
   9950 * C-c f B b:                             Blaming.             (line  28)
   9951 * C-c f B e:                             Blaming.             (line  28)
   9952 * C-c f B f:                             Blaming.             (line  28)
   9953 * C-c f B q:                             Blaming.             (line  28)
   9954 * C-c f B r:                             Blaming.             (line  28)
   9955 * C-c f c:                               Commands for Buffers Visiting Files.
   9956                                                               (line  52)
   9957 * C-c f D:                               Commands for Buffers Visiting Files.
   9958                                                               (line  52)
   9959 * C-c f d:                               Commands for Buffers Visiting Files.
   9960                                                               (line  52)
   9961 * C-c f e:                               Blaming.             (line  28)
   9962 * C-c f e <1>:                           Commands for Buffers Visiting Files.
   9963                                                               (line  52)
   9964 * C-c f f:                               Blaming.             (line  28)
   9965 * C-c f f <1>:                           Commands for Buffers Visiting Files.
   9966                                                               (line  52)
   9967 * C-c f g:                               Commands for Buffers Visiting Files.
   9968                                                               (line  52)
   9969 * C-c f G:                               Commands for Buffers Visiting Files.
   9970                                                               (line  52)
   9971 * C-c f L:                               Commands for Buffers Visiting Files.
   9972                                                               (line  52)
   9973 * C-c f l:                               Commands for Buffers Visiting Files.
   9974                                                               (line  52)
   9975 * C-c f M:                               Commands for Buffers Visiting Files.
   9976                                                               (line  52)
   9977 * C-c f m:                               Commands for Buffers Visiting Files.
   9978                                                               (line  52)
   9979 * C-c f n:                               Commands for Buffers Visiting Files.
   9980                                                               (line  52)
   9981 * C-c f p:                               Commands for Buffers Visiting Files.
   9982                                                               (line  52)
   9983 * C-c f q:                               Blaming.             (line  28)
   9984 * C-c f q <1>:                           Commands for Buffers Visiting Files.
   9985                                                               (line  52)
   9986 * C-c f r:                               Blaming.             (line  28)
   9987 * C-c f r <1>:                           Commands for Buffers Visiting Files.
   9988                                                               (line  52)
   9989 * C-c f s:                               Commands for Buffers Visiting Files.
   9990                                                               (line  52)
   9991 * C-c f s <1>:                           Commands for Buffers Visiting Files.
   9992                                                               (line  52)
   9993 * C-c f t:                               Commands for Buffers Visiting Files.
   9994                                                               (line  52)
   9995 * C-c f u:                               Commands for Buffers Visiting Files.
   9996                                                               (line  52)
   9997 * C-c f u <1>:                           Commands for Buffers Visiting Files.
   9998                                                               (line  52)
   9999 * C-c f v:                               Commands for Buffers Visiting Files.
  10000                                                               (line  52)
  10001 * C-c f V:                               Commands for Buffers Visiting Files.
  10002                                                               (line  52)
  10003 * C-c g:                                 Transient Commands.  (line  20)
  10004 * C-c M-g:                               Commands for Buffers Visiting Files.
  10005                                                               (line  58)
  10006 * C-c M-g , c:                           Commands for Buffers Visiting Files.
  10007                                                               (line  86)
  10008 * C-c M-g , k:                           Commands for Buffers Visiting Files.
  10009                                                               (line  82)
  10010 * C-c M-g , r:                           Commands for Buffers Visiting Files.
  10011                                                               (line  78)
  10012 * C-c M-g , x:                           Commands for Buffers Visiting Files.
  10013                                                               (line  74)
  10014 * C-c M-g B:                             Blaming.             (line  34)
  10015 * C-c M-g b:                             Blaming.             (line  45)
  10016 * C-c M-g B <1>:                         Commands for Buffers Visiting Files.
  10017                                                               (line 137)
  10018 * C-c M-g B b:                           Blaming.             (line  45)
  10019 * C-c M-g B e:                           Blaming.             (line  76)
  10020 * C-c M-g B f:                           Blaming.             (line  68)
  10021 * C-c M-g B q:                           Blaming.             (line  87)
  10022 * C-c M-g B r:                           Blaming.             (line  60)
  10023 * C-c M-g c:                             Commands for Buffers Visiting Files.
  10024                                                               (line 176)
  10025 * C-c M-g D:                             Commands for Buffers Visiting Files.
  10026                                                               (line  91)
  10027 * C-c M-g d:                             Commands for Buffers Visiting Files.
  10028                                                               (line 101)
  10029 * C-c M-g e:                             Blaming.             (line  76)
  10030 * C-c M-g e <1>:                         Commands for Buffers Visiting Files.
  10031                                                               (line 182)
  10032 * C-c M-g f:                             Blaming.             (line  68)
  10033 * C-c M-g g:                             Commands for Buffers Visiting Files.
  10034                                                               (line 166)
  10035 * C-c M-g G:                             Commands for Buffers Visiting Files.
  10036                                                               (line 172)
  10037 * C-c M-g L:                             Commands for Buffers Visiting Files.
  10038                                                               (line 109)
  10039 * C-c M-g l:                             Commands for Buffers Visiting Files.
  10040                                                               (line 119)
  10041 * C-c M-g M:                             Commands for Buffers Visiting Files.
  10042                                                               (line 132)
  10043 * C-c M-g n:                             Commands for Buffers Visiting Files.
  10044                                                               (line 153)
  10045 * C-c M-g p:                             Commands for Buffers Visiting Files.
  10046                                                               (line 149)
  10047 * C-c M-g q:                             Blaming.             (line  87)
  10048 * C-c M-g r:                             Blaming.             (line  60)
  10049 * C-c M-g s:                             Commands for Buffers Visiting Files.
  10050                                                               (line  63)
  10051 * C-c M-g s <1>:                         Commands for Buffers Visiting Files.
  10052                                                               (line  63)
  10053 * C-c M-g t:                             Commands for Buffers Visiting Files.
  10054                                                               (line 129)
  10055 * C-c M-g u:                             Commands for Buffers Visiting Files.
  10056                                                               (line  69)
  10057 * C-c M-g u <1>:                         Commands for Buffers Visiting Files.
  10058                                                               (line  69)
  10059 * C-c M-g v:                             Commands for Buffers Visiting Files.
  10060                                                               (line 156)
  10061 * C-c M-g V:                             Commands for Buffers Visiting Files.
  10062                                                               (line 160)
  10063 * C-c M-i:                               Commit Pseudo Headers.
  10064                                                               (line  35)
  10065 * C-c M-s:                               Editing Commit Messages.
  10066                                                               (line  33)
  10067 * C-c TAB:                               Section Visibility.  (line  14)
  10068 * C-w:                                   Common Commands.     (line  22)
  10069 * C-x g:                                 Status Buffer.       (line  23)
  10070 * C-x M-g:                               Transient Commands.  (line  20)
  10071 * C-x u:                                 Editing Rebase Sequences.
  10072                                                               (line  77)
  10073 * d:                                     Diffing.             (line  22)
  10074 * D:                                     Refreshing Diffs.    (line  16)
  10075 * d c:                                   Diffing.             (line  63)
  10076 * d d:                                   Diffing.             (line  27)
  10077 * D f:                                   Refreshing Diffs.    (line  45)
  10078 * D F:                                   Refreshing Diffs.    (line  49)
  10079 * D g:                                   Refreshing Diffs.    (line  21)
  10080 * d p:                                   Diffing.             (line  56)
  10081 * d r:                                   Diffing.             (line  30)
  10082 * D r:                                   Refreshing Diffs.    (line  41)
  10083 * d s:                                   Diffing.             (line  48)
  10084 * D s:                                   Refreshing Diffs.    (line  25)
  10085 * d t:                                   Diffing.             (line  67)
  10086 * D t:                                   Refreshing Diffs.    (line  38)
  10087 * d u:                                   Diffing.             (line  53)
  10088 * d w:                                   Diffing.             (line  43)
  10089 * D w:                                   Refreshing Diffs.    (line  31)
  10090 * DEL:                                   Log Buffer.          (line  50)
  10091 * DEL <1>:                               Commands Available in Diffs.
  10092                                                               (line  56)
  10093 * DEL <2>:                               Blaming.             (line 103)
  10094 * DEL <3>:                               Editing Rebase Sequences.
  10095                                                               (line  25)
  10096 * e:                                     Ediffing.            (line  10)
  10097 * E:                                     Ediffing.            (line  21)
  10098 * e <1>:                                 Editing Rebase Sequences.
  10099                                                               (line  46)
  10100 * E c:                                   Ediffing.            (line 100)
  10101 * E i:                                   Ediffing.            (line  94)
  10102 * E m:                                   Ediffing.            (line  33)
  10103 * E M:                                   Ediffing.            (line  48)
  10104 * E r:                                   Ediffing.            (line  25)
  10105 * E s:                                   Ediffing.            (line  87)
  10106 * E t:                                   Ediffing.            (line  79)
  10107 * E u:                                   Ediffing.            (line  91)
  10108 * E w:                                   Ediffing.            (line  97)
  10109 * E z:                                   Ediffing.            (line 103)
  10110 * f:                                     Repository List.     (line 111)
  10111 * f <1>:                                 Editing Rebase Sequences.
  10112                                                               (line  52)
  10113 * f <2>:                                 Fetching.            (line  10)
  10114 * F:                                     Pulling.             (line  10)
  10115 * f a:                                   Fetching.            (line  45)
  10116 * f C:                                   Branch Commands.     (line  31)
  10117 * F C:                                   Branch Commands.     (line  31)
  10118 * f e:                                   Fetching.            (line  34)
  10119 * F e:                                   Pulling.             (line  28)
  10120 * f m:                                   Fetching.            (line  48)
  10121 * f o:                                   Fetching.            (line  37)
  10122 * f p:                                   Fetching.            (line  15)
  10123 * F p:                                   Pulling.             (line  14)
  10124 * f r:                                   Fetching.            (line  41)
  10125 * f u:                                   Fetching.            (line  22)
  10126 * F u:                                   Pulling.             (line  21)
  10127 * g:                                     Automatic Refreshing of Magit Buffers.
  10128                                                               (line  26)
  10129 * G:                                     Automatic Refreshing of Magit Buffers.
  10130                                                               (line  34)
  10131 * H:                                     Section Types and Values.
  10132                                                               (line  14)
  10133 * I:                                     Creating Repository. (line   7)
  10134 * j:                                     Log Buffer.          (line  31)
  10135 * j <1>:                                 Commands Available in Diffs.
  10136                                                               (line  43)
  10137 * k:                                     Viewing Git Output.  (line  24)
  10138 * k <1>:                                 Applying.            (line  40)
  10139 * k <2>:                                 Editing Rebase Sequences.
  10140                                                               (line  56)
  10141 * k <3>:                                 Stashing.            (line 118)
  10142 * l:                                     Logging.             (line  28)
  10143 * L:                                     Refreshing Logs.     (line  12)
  10144 * L <1>:                                 Log Buffer.          (line   7)
  10145 * L <2>:                                 Log Margin.          (line  52)
  10146 * l <1>:                                 Editing Rebase Sequences.
  10147                                                               (line  94)
  10148 * l a:                                   Logging.             (line  59)
  10149 * l b:                                   Logging.             (line  56)
  10150 * L d:                                   Log Margin.          (line  66)
  10151 * L g:                                   Refreshing Logs.     (line  17)
  10152 * l h:                                   Logging.             (line  38)
  10153 * l H:                                   Reflog.              (line  18)
  10154 * l l:                                   Logging.             (line  33)
  10155 * l L:                                   Logging.             (line  53)
  10156 * L L:                                   Refreshing Logs.     (line  34)
  10157 * L L <1>:                               Log Margin.          (line  60)
  10158 * L l:                                   Log Margin.          (line  63)
  10159 * l o:                                   Logging.             (line  47)
  10160 * l O:                                   Reflog.              (line  15)
  10161 * l r:                                   Reflog.              (line  12)
  10162 * L s:                                   Refreshing Logs.     (line  21)
  10163 * l u:                                   Logging.             (line  41)
  10164 * L w:                                   Refreshing Logs.     (line  27)
  10165 * m:                                     Repository List.     (line 105)
  10166 * m <1>:                                 Merging.             (line  10)
  10167 * M:                                     Remote Commands.     (line  14)
  10168 * m a:                                   Merging.             (line  42)
  10169 * m a <1>:                               Merging.             (line  91)
  10170 * M a:                                   Remote Commands.     (line  48)
  10171 * M C:                                   Remote Commands.     (line  32)
  10172 * m e:                                   Merging.             (line  30)
  10173 * m i:                                   Merging.             (line  54)
  10174 * M k:                                   Remote Commands.     (line  60)
  10175 * m m:                                   Merging.             (line  18)
  10176 * m m <1>:                               Merging.             (line  86)
  10177 * m n:                                   Merging.             (line  36)
  10178 * m p:                                   Merging.             (line  75)
  10179 * M p:                                   Remote Commands.     (line  63)
  10180 * M P:                                   Remote Commands.     (line  67)
  10181 * M r:                                   Remote Commands.     (line  52)
  10182 * m s:                                   Merging.             (line  67)
  10183 * M u:                                   Remote Commands.     (line  56)
  10184 * M-1:                                   Section Visibility.  (line  45)
  10185 * M-2:                                   Section Visibility.  (line  45)
  10186 * M-3:                                   Section Visibility.  (line  45)
  10187 * M-4:                                   Section Visibility.  (line  45)
  10188 * M-<tab>:                               Section Visibility.  (line  29)
  10189 * M-n:                                   Section Movement.    (line  24)
  10190 * M-n <1>:                               Editing Commit Messages.
  10191                                                               (line  41)
  10192 * M-n <2>:                               Editing Rebase Sequences.
  10193                                                               (line  40)
  10194 * M-p:                                   Section Movement.    (line  19)
  10195 * M-p <1>:                               Editing Commit Messages.
  10196                                                               (line  36)
  10197 * M-p <2>:                               Editing Rebase Sequences.
  10198                                                               (line  37)
  10199 * M-w:                                   Blaming.             (line 134)
  10200 * M-w <1>:                               Common Commands.     (line  39)
  10201 * MM:                                    Editing Rebase Sequences.
  10202                                                               (line 102)
  10203 * Mt:                                    Editing Rebase Sequences.
  10204                                                               (line 108)
  10205 * n:                                     Section Movement.    (line  16)
  10206 * n <1>:                                 Blaming.             (line 118)
  10207 * N:                                     Blaming.             (line 121)
  10208 * n <2>:                                 Editing Rebase Sequences.
  10209                                                               (line  34)
  10210 * n <3>:                                 Minor Mode for Buffers Visiting Blobs.
  10211                                                               (line  16)
  10212 * o:                                     Submodule Transient. (line   7)
  10213 * O:                                     Subtree.             (line   9)
  10214 * o a:                                   Submodule Transient. (line  20)
  10215 * o d:                                   Submodule Transient. (line  45)
  10216 * O e:                                   Subtree.             (line  37)
  10217 * O e p:                                 Subtree.             (line  48)
  10218 * O e s:                                 Subtree.             (line  52)
  10219 * o f:                                   Submodule Transient. (line  51)
  10220 * O i:                                   Subtree.             (line  13)
  10221 * O i a:                                 Subtree.             (line  24)
  10222 * O i c:                                 Subtree.             (line  28)
  10223 * O i f:                                 Subtree.             (line  34)
  10224 * O i m:                                 Subtree.             (line  31)
  10225 * o l:                                   Submodule Transient. (line  48)
  10226 * o p:                                   Submodule Transient. (line  32)
  10227 * o r:                                   Submodule Transient. (line  26)
  10228 * o s:                                   Submodule Transient. (line  40)
  10229 * o u:                                   Submodule Transient. (line  36)
  10230 * p:                                     Section Movement.    (line  11)
  10231 * p <1>:                                 Blaming.             (line 124)
  10232 * P:                                     Blaming.             (line 127)
  10233 * p <2>:                                 Editing Rebase Sequences.
  10234                                                               (line  31)
  10235 * P <1>:                                 Pushing.             (line  10)
  10236 * p <3>:                                 Minor Mode for Buffers Visiting Blobs.
  10237                                                               (line  13)
  10238 * P C:                                   Branch Commands.     (line  31)
  10239 * P e:                                   Pushing.             (line  29)
  10240 * P m:                                   Pushing.             (line  45)
  10241 * P o:                                   Pushing.             (line  33)
  10242 * P p:                                   Pushing.             (line  15)
  10243 * P r:                                   Pushing.             (line  37)
  10244 * P t:                                   Pushing.             (line  52)
  10245 * P T:                                   Pushing.             (line  59)
  10246 * P u:                                   Pushing.             (line  22)
  10247 * q:                                     Quitting Windows.    (line   7)
  10248 * q <1>:                                 Log Buffer.          (line  14)
  10249 * q <2>:                                 Blaming.             (line 130)
  10250 * q <3>:                                 Minor Mode for Buffers Visiting Blobs.
  10251                                                               (line  19)
  10252 * r:                                     Rebasing.            (line  10)
  10253 * r <1>:                                 Editing Rebase Sequences.
  10254                                                               (line  43)
  10255 * r a:                                   Rebasing.            (line 111)
  10256 * r e:                                   Rebasing.            (line  42)
  10257 * r e <1>:                               Rebasing.            (line 107)
  10258 * r f:                                   Rebasing.            (line  79)
  10259 * r i:                                   Rebasing.            (line  76)
  10260 * r k:                                   Rebasing.            (line  91)
  10261 * r m:                                   Rebasing.            (line  83)
  10262 * r p:                                   Rebasing.            (line  28)
  10263 * r r:                                   Rebasing.            (line  97)
  10264 * r s:                                   Rebasing.            (line  47)
  10265 * r s <1>:                               Rebasing.            (line 103)
  10266 * r u:                                   Rebasing.            (line  35)
  10267 * r w:                                   Rebasing.            (line  87)
  10268 * RET:                                   Repository List.     (line 102)
  10269 * RET <1>:                               References Buffer.   (line 159)
  10270 * RET <2>:                               Visiting Files and Blobs from a Diff.
  10271                                                               (line   9)
  10272 * RET <3>:                               Blaming.             (line  91)
  10273 * RET <4>:                               Editing Rebase Sequences.
  10274                                                               (line  15)
  10275 * s:                                     Staging and Unstaging.
  10276                                                               (line  29)
  10277 * S:                                     Staging and Unstaging.
  10278                                                               (line  36)
  10279 * s <1>:                                 Editing Rebase Sequences.
  10280                                                               (line  49)
  10281 * S-<tab>:                               Section Visibility.  (line  33)
  10282 * SPC:                                   Log Buffer.          (line  41)
  10283 * SPC <1>:                               Commands Available in Diffs.
  10284                                                               (line  53)
  10285 * SPC <2>:                               Blaming.             (line  94)
  10286 * SPC <3>:                               Editing Rebase Sequences.
  10287                                                               (line  19)
  10288 * t:                                     Editing Rebase Sequences.
  10289                                                               (line  97)
  10290 * t <1>:                                 Tagging.             (line   9)
  10291 * T:                                     Notes.               (line   9)
  10292 * T a:                                   Notes.               (line  47)
  10293 * T c:                                   Notes.               (line  43)
  10294 * t k:                                   Tagging.             (line  37)
  10295 * T m:                                   Notes.               (line  35)
  10296 * t p:                                   Tagging.             (line  43)
  10297 * T p:                                   Notes.               (line  28)
  10298 * t r:                                   Tagging.             (line  18)
  10299 * T r:                                   Notes.               (line  21)
  10300 * t t:                                   Tagging.             (line  14)
  10301 * T T:                                   Notes.               (line  14)
  10302 * TAB:                                   Section Visibility.  (line  10)
  10303 * u:                                     Repository List.     (line 108)
  10304 * u <1>:                                 Staging and Unstaging.
  10305                                                               (line  42)
  10306 * U:                                     Staging and Unstaging.
  10307                                                               (line  50)
  10308 * v:                                     Applying.            (line  47)
  10309 * V:                                     Reverting.           (line   7)
  10310 * V a:                                   Reverting.           (line  35)
  10311 * V s:                                   Reverting.           (line  32)
  10312 * V V:                                   Reverting.           (line  15)
  10313 * V v:                                   Reverting.           (line  20)
  10314 * V V <1>:                               Reverting.           (line  29)
  10315 * W:                                     Plain Patches.       (line   7)
  10316 * w:                                     Maildir Patches.     (line   9)
  10317 * w a:                                   Plain Patches.       (line  20)
  10318 * w a <1>:                               Maildir Patches.     (line  23)
  10319 * w a <2>:                               Maildir Patches.     (line  38)
  10320 * W c:                                   Plain Patches.       (line  12)
  10321 * w m:                                   Maildir Patches.     (line  20)
  10322 * W s:                                   Plain Patches.       (line  26)
  10323 * w s:                                   Maildir Patches.     (line  34)
  10324 * w w:                                   Maildir Patches.     (line  14)
  10325 * w w <1>:                               Maildir Patches.     (line  31)
  10326 * x:                                     Editing Rebase Sequences.
  10327                                                               (line  62)
  10328 * x <1>:                                 Resetting.           (line   9)
  10329 * X f:                                   Resetting.           (line  44)
  10330 * X h:                                   Resetting.           (line  24)
  10331 * X i:                                   Resetting.           (line  33)
  10332 * X k:                                   Resetting.           (line  28)
  10333 * X m:                                   Resetting.           (line  15)
  10334 * X s:                                   Resetting.           (line  19)
  10335 * X w:                                   Resetting.           (line  39)
  10336 * X w <1>:                               Wip Modes.           (line  64)
  10337 * Y:                                     Cherries.            (line  18)
  10338 * y:                                     References Buffer.   (line   7)
  10339 * y <1>:                                 Editing Rebase Sequences.
  10340                                                               (line  74)
  10341 * y c:                                   References Buffer.   (line  25)
  10342 * y o:                                   References Buffer.   (line  30)
  10343 * y r:                                   References Buffer.   (line  34)
  10344 * y y:                                   References Buffer.   (line  21)
  10345 * z:                                     Stashing.            (line   9)
  10346 * Z:                                     Worktree.            (line   9)
  10347 * z a:                                   Stashing.            (line  52)
  10348 * z b:                                   Stashing.            (line 105)
  10349 * z B:                                   Stashing.            (line 110)
  10350 * Z b:                                   Worktree.            (line  13)
  10351 * Z c:                                   Worktree.            (line  16)
  10352 * z f:                                   Stashing.            (line 115)
  10353 * Z g:                                   Worktree.            (line  26)
  10354 * z i:                                   Stashing.            (line  20)
  10355 * z I:                                   Stashing.            (line  42)
  10356 * z k:                                   Stashing.            (line  98)
  10357 * Z k:                                   Worktree.            (line  22)
  10358 * z l:                                   Stashing.            (line 121)
  10359 * Z m:                                   Worktree.            (line  19)
  10360 * z p:                                   Stashing.            (line  74)
  10361 * z v:                                   Stashing.            (line 102)
  10362 * z w:                                   Stashing.            (line  24)
  10363 * z W:                                   Stashing.            (line  46)
  10364 * z x:                                   Stashing.            (line  30)
  10365 * z z:                                   Stashing.            (line  14)
  10366 * z Z:                                   Stashing.            (line  36)
  10367 
  10368 
  10369 File: magit.info,  Node: Function and Command Index,  Next: Variable Index,  Prev: Keystroke Index,  Up: Top
  10370 
  10371 Appendix D Function and Command Index
  10372 *************************************
  10373 
  10374 
  10375 * Menu:
  10376 
  10377 * bug-reference-mode:                    Commit Mode and Hooks.
  10378                                                               (line  48)
  10379 * forward-line:                          Editing Rebase Sequences.
  10380                                                               (line  34)
  10381 * git-commit-ack:                        Commit Pseudo Headers.
  10382                                                               (line  16)
  10383 * git-commit-cc:                         Commit Pseudo Headers.
  10384                                                               (line  28)
  10385 * git-commit-check-style-conventions:    Commit Message Conventions.
  10386                                                               (line  33)
  10387 * git-commit-insert-pseudo-header:       Commit Pseudo Headers.
  10388                                                               (line  13)
  10389 * git-commit-next-message:               Editing Commit Messages.
  10390                                                               (line  41)
  10391 * git-commit-prev-message:               Editing Commit Messages.
  10392                                                               (line  36)
  10393 * git-commit-propertize-diff:            Commit Mode and Hooks.
  10394                                                               (line  40)
  10395 * git-commit-reported:                   Commit Pseudo Headers.
  10396                                                               (line  31)
  10397 * git-commit-review:                     Commit Pseudo Headers.
  10398                                                               (line  19)
  10399 * git-commit-save-message:               Editing Commit Messages.
  10400                                                               (line  33)
  10401 * git-commit-save-message <1>:           Commit Mode and Hooks.
  10402                                                               (line  26)
  10403 * git-commit-setup-changelog-support:    Commit Mode and Hooks.
  10404                                                               (line  29)
  10405 * git-commit-signoff:                    Commit Pseudo Headers.
  10406                                                               (line  22)
  10407 * git-commit-suggested:                  Commit Pseudo Headers.
  10408                                                               (line  35)
  10409 * git-commit-test:                       Commit Pseudo Headers.
  10410                                                               (line  25)
  10411 * git-commit-turn-on-auto-fill:          Commit Mode and Hooks.
  10412                                                               (line  33)
  10413 * git-commit-turn-on-flyspell:           Commit Mode and Hooks.
  10414                                                               (line  36)
  10415 * git-rebase-backward-line:              Editing Rebase Sequences.
  10416                                                               (line  31)
  10417 * git-rebase-break:                      Editing Rebase Sequences.
  10418                                                               (line  70)
  10419 * git-rebase-edit:                       Editing Rebase Sequences.
  10420                                                               (line  46)
  10421 * git-rebase-exec:                       Editing Rebase Sequences.
  10422                                                               (line  62)
  10423 * git-rebase-fixup:                      Editing Rebase Sequences.
  10424                                                               (line  52)
  10425 * git-rebase-insert:                     Editing Rebase Sequences.
  10426                                                               (line  74)
  10427 * git-rebase-kill-line:                  Editing Rebase Sequences.
  10428                                                               (line  56)
  10429 * git-rebase-label:                      Editing Rebase Sequences.
  10430                                                               (line  94)
  10431 * git-rebase-merge:                      Editing Rebase Sequences.
  10432                                                               (line 102)
  10433 * git-rebase-merge-toggle-editmsg:       Editing Rebase Sequences.
  10434                                                               (line 108)
  10435 * git-rebase-move-line-down:             Editing Rebase Sequences.
  10436                                                               (line  40)
  10437 * git-rebase-move-line-up:               Editing Rebase Sequences.
  10438                                                               (line  37)
  10439 * git-rebase-pick:                       Editing Rebase Sequences.
  10440                                                               (line  59)
  10441 * git-rebase-reset:                      Editing Rebase Sequences.
  10442                                                               (line  97)
  10443 * git-rebase-reword:                     Editing Rebase Sequences.
  10444                                                               (line  43)
  10445 * git-rebase-show-commit:                Editing Rebase Sequences.
  10446                                                               (line  15)
  10447 * git-rebase-show-or-scroll-down:        Editing Rebase Sequences.
  10448                                                               (line  25)
  10449 * git-rebase-show-or-scroll-up:          Editing Rebase Sequences.
  10450                                                               (line  19)
  10451 * git-rebase-squash:                     Editing Rebase Sequences.
  10452                                                               (line  49)
  10453 * git-rebase-undo:                       Editing Rebase Sequences.
  10454                                                               (line  77)
  10455 * ido-enter-magit-status:                Status Buffer.       (line  96)
  10456 * magit-add-section-hook:                Section Hooks.       (line  20)
  10457 * magit-after-save-refresh-status:       Automatic Refreshing of Magit Buffers.
  10458                                                               (line  55)
  10459 * magit-am:                              Maildir Patches.     (line   9)
  10460 * magit-am-abort:                        Maildir Patches.     (line  38)
  10461 * magit-am-apply-maildir:                Maildir Patches.     (line  20)
  10462 * magit-am-apply-patches:                Maildir Patches.     (line  14)
  10463 * magit-am-continue:                     Maildir Patches.     (line  31)
  10464 * magit-am-skip:                         Maildir Patches.     (line  34)
  10465 * magit-apply:                           Applying.            (line  34)
  10466 * magit-bisect:                          Bisecting.           (line   9)
  10467 * magit-bisect-bad:                      Bisecting.           (line  32)
  10468 * magit-bisect-good:                     Bisecting.           (line  36)
  10469 * magit-bisect-mark:                     Bisecting.           (line  40)
  10470 * magit-bisect-reset:                    Bisecting.           (line  51)
  10471 * magit-bisect-run:                      Bisecting.           (line  26)
  10472 * magit-bisect-skip:                     Bisecting.           (line  46)
  10473 * magit-bisect-start:                    Bisecting.           (line  16)
  10474 * magit-blame:                           Blaming.             (line  28)
  10475 * magit-blame <1>:                       Blaming.             (line  34)
  10476 * magit-blame <2>:                       Blaming.             (line 115)
  10477 * magit-blame <3>:                       Commands for Buffers Visiting Files.
  10478                                                               (line  52)
  10479 * magit-blame <4>:                       Commands for Buffers Visiting Files.
  10480                                                               (line 137)
  10481 * magit-blame-addition:                  Blaming.             (line  28)
  10482 * magit-blame-addition <1>:              Blaming.             (line  45)
  10483 * magit-blame-additions:                 Commands for Buffers Visiting Files.
  10484                                                               (line  52)
  10485 * magit-blame-copy-hash:                 Blaming.             (line 134)
  10486 * magit-blame-cycle-style:               Blaming.             (line 141)
  10487 * magit-blame-echo:                      Blaming.             (line  28)
  10488 * magit-blame-echo <1>:                  Blaming.             (line  76)
  10489 * magit-blame-echo <2>:                  Commands for Buffers Visiting Files.
  10490                                                               (line  52)
  10491 * magit-blame-next-chunk:                Blaming.             (line 118)
  10492 * magit-blame-next-chunk-same-commit:    Blaming.             (line 121)
  10493 * magit-blame-previous-chunk:            Blaming.             (line 124)
  10494 * magit-blame-previous-chunk-same-commit: Blaming.            (line 127)
  10495 * magit-blame-quit:                      Blaming.             (line  28)
  10496 * magit-blame-quit <1>:                  Blaming.             (line  87)
  10497 * magit-blame-quit <2>:                  Blaming.             (line 130)
  10498 * magit-blame-quit <3>:                  Commands for Buffers Visiting Files.
  10499                                                               (line  52)
  10500 * magit-blame-removal:                   Blaming.             (line  28)
  10501 * magit-blame-removal <1>:               Blaming.             (line  60)
  10502 * magit-blame-removal <2>:               Commands for Buffers Visiting Files.
  10503                                                               (line  52)
  10504 * magit-blame-reverse:                   Blaming.             (line  28)
  10505 * magit-blame-reverse <1>:               Blaming.             (line  68)
  10506 * magit-blame-reverse <2>:               Commands for Buffers Visiting Files.
  10507                                                               (line  52)
  10508 * magit-blob-next:                       Commands for Buffers Visiting Files.
  10509                                                               (line  52)
  10510 * magit-blob-next <1>:                   Commands for Buffers Visiting Files.
  10511                                                               (line 153)
  10512 * magit-blob-next <2>:                   Minor Mode for Buffers Visiting Blobs.
  10513                                                               (line  16)
  10514 * magit-blob-previous:                   Commands for Buffers Visiting Files.
  10515                                                               (line  52)
  10516 * magit-blob-previous <1>:               Commands for Buffers Visiting Files.
  10517                                                               (line 149)
  10518 * magit-blob-previous <2>:               Minor Mode for Buffers Visiting Blobs.
  10519                                                               (line  13)
  10520 * magit-blob-visit-file:                 Commands for Buffers Visiting Files.
  10521                                                               (line  52)
  10522 * magit-blob-visit-file <1>:             Commands for Buffers Visiting Files.
  10523                                                               (line 160)
  10524 * magit-branch:                          Branch Commands.     (line  13)
  10525 * magit-branch-and-checkout:             Branch Commands.     (line  63)
  10526 * magit-branch-checkout:                 Branch Commands.     (line  69)
  10527 * magit-branch-configure:                Branch Commands.     (line  31)
  10528 * magit-branch-create:                   Branch Commands.     (line  54)
  10529 * magit-branch-delete:                   Branch Commands.     (line 138)
  10530 * magit-branch-or-checkout:              Branch Commands.     (line 257)
  10531 * magit-branch-orphan:                   Branch Commands.     (line 253)
  10532 * magit-branch-rename:                   Branch Commands.     (line 149)
  10533 * magit-branch-reset:                    Branch Commands.     (line 123)
  10534 * magit-branch-shelve:                   Auxiliary Branch Commands.
  10535                                                               (line   9)
  10536 * magit-branch-spinoff:                  Branch Commands.     (line  91)
  10537 * magit-branch-spinout:                  Branch Commands.     (line 118)
  10538 * magit-branch-unshelve:                 Auxiliary Branch Commands.
  10539                                                               (line  19)
  10540 * magit-builtin-completing-read:         Support for Completion Frameworks.
  10541                                                               (line  41)
  10542 * magit-bundle:                          Bundle.              (line   8)
  10543 * magit-call-git:                        Calling Git for Effect.
  10544                                                               (line  28)
  10545 * magit-call-process:                    Calling Git for Effect.
  10546                                                               (line  31)
  10547 * magit-cancel-section:                  Creating Sections.   (line  69)
  10548 * magit-checkout:                        Branch Commands.     (line  47)
  10549 * magit-cherry:                          Cherries.            (line  18)
  10550 * magit-cherry-apply:                    Cherry Picking.      (line  23)
  10551 * magit-cherry-copy:                     Cherry Picking.      (line  17)
  10552 * magit-cherry-donate:                   Cherry Picking.      (line  51)
  10553 * magit-cherry-harvest:                  Cherry Picking.      (line  40)
  10554 * magit-cherry-pick:                     Cherry Picking.      (line   9)
  10555 * magit-cherry-spinoff:                  Cherry Picking.      (line  72)
  10556 * magit-cherry-spinout:                  Cherry Picking.      (line  62)
  10557 * magit-clone:                           Cloning Repository.  (line  20)
  10558 * magit-clone-bare:                      Cloning Repository.  (line  44)
  10559 * magit-clone-mirror:                    Cloning Repository.  (line  48)
  10560 * magit-clone-regular:                   Cloning Repository.  (line  28)
  10561 * magit-clone-shallow:                   Cloning Repository.  (line  32)
  10562 * magit-clone-shallow-exclude:           Cloning Repository.  (line  61)
  10563 * magit-clone-shallow-since:             Cloning Repository.  (line  55)
  10564 * magit-clone-sparse:                    Cloning Repository.  (line  38)
  10565 * magit-commit:                          Initiating a Commit. (line   9)
  10566 * magit-commit <1>:                      Commands for Buffers Visiting Files.
  10567                                                               (line  52)
  10568 * magit-commit <2>:                      Commands for Buffers Visiting Files.
  10569                                                               (line 176)
  10570 * magit-commit-amend:                    Initiating a Commit. (line  18)
  10571 * magit-commit-augment:                  Initiating a Commit. (line  59)
  10572 * magit-commit-create:                   Initiating a Commit. (line  14)
  10573 * magit-commit-extend:                   Initiating a Commit. (line  21)
  10574 * magit-commit-fixup:                    Initiating a Commit. (line  39)
  10575 * magit-commit-instant-fixup:            Initiating a Commit. (line  46)
  10576 * magit-commit-instant-squash:           Initiating a Commit. (line  56)
  10577 * magit-commit-reword:                   Initiating a Commit. (line  30)
  10578 * magit-commit-squash:                   Initiating a Commit. (line  49)
  10579 * magit-completing-read:                 Support for Completion Frameworks.
  10580                                                               (line  57)
  10581 * magit-copy-buffer-revision:            Common Commands.     (line  39)
  10582 * magit-copy-section-value:              Common Commands.     (line  22)
  10583 * magit-current-section:                 Section Selection.   (line   6)
  10584 * magit-cycle-margin-style:              Log Margin.          (line  63)
  10585 * magit-debug-git-executable:            Git Executable.      (line  55)
  10586 * magit-debug-git-executable <1>:        Debugging Tools.     (line  57)
  10587 * magit-define-section-jumper:           Creating Sections.   (line  74)
  10588 * magit-describe-section:                Section Types and Values.
  10589                                                               (line  14)
  10590 * magit-describe-section-briefly:        Section Types and Values.
  10591                                                               (line  17)
  10592 * magit-describe-section-briefly <1>:    Matching Sections.   (line   7)
  10593 * magit-diff:                            Diffing.             (line  22)
  10594 * magit-diff <1>:                        Commands for Buffers Visiting Files.
  10595                                                               (line  52)
  10596 * magit-diff <2>:                        Commands for Buffers Visiting Files.
  10597                                                               (line  91)
  10598 * magit-diff-buffer-file:                Commands for Buffers Visiting Files.
  10599                                                               (line  52)
  10600 * magit-diff-buffer-file <1>:            Commands for Buffers Visiting Files.
  10601                                                               (line 101)
  10602 * magit-diff-default-context:            Refreshing Diffs.    (line  68)
  10603 * magit-diff-dwim:                       Diffing.             (line  27)
  10604 * magit-diff-edit-hunk-commit:           Commands Available in Diffs.
  10605                                                               (line  24)
  10606 * magit-diff-flip-revs:                  Refreshing Diffs.    (line  45)
  10607 * magit-diff-less-context:               Refreshing Diffs.    (line  62)
  10608 * magit-diff-more-context:               Refreshing Diffs.    (line  65)
  10609 * magit-diff-paths:                      Diffing.             (line  56)
  10610 * magit-diff-range:                      Diffing.             (line  30)
  10611 * magit-diff-refresh:                    Refreshing Diffs.    (line  16)
  10612 * magit-diff-refresh <1>:                Refreshing Diffs.    (line  21)
  10613 * magit-diff-save-default-arguments:     Refreshing Diffs.    (line  31)
  10614 * magit-diff-scope:                      Matching Sections.   (line 110)
  10615 * magit-diff-set-default-arguments:      Refreshing Diffs.    (line  25)
  10616 * magit-diff-show-or-scroll-down:        Log Buffer.          (line  50)
  10617 * magit-diff-show-or-scroll-down <1>:    Blaming.             (line 103)
  10618 * magit-diff-show-or-scroll-up:          Log Buffer.          (line  41)
  10619 * magit-diff-show-or-scroll-up <1>:      Blaming.             (line  94)
  10620 * magit-diff-staged:                     Diffing.             (line  48)
  10621 * magit-diff-switch-range-type:          Refreshing Diffs.    (line  41)
  10622 * magit-diff-toggle-file-filter:         Refreshing Diffs.    (line  49)
  10623 * magit-diff-toggle-refine-hunk:         Refreshing Diffs.    (line  38)
  10624 * magit-diff-trace-definition:           Commands Available in Diffs.
  10625                                                               (line  15)
  10626 * magit-diff-type:                       Matching Sections.   (line  88)
  10627 * magit-diff-unstaged:                   Diffing.             (line  53)
  10628 * magit-diff-visit-file:                 Visiting Files and Blobs from a Diff.
  10629                                                               (line   9)
  10630 * magit-diff-visit-file-other-frame:     Visiting Files and Blobs from a Diff.
  10631                                                               (line  71)
  10632 * magit-diff-visit-file-other-window:    Visiting Files and Blobs from a Diff.
  10633                                                               (line  70)
  10634 * magit-diff-visit-file-worktree:        Visiting Files and Blobs from a Diff.
  10635                                                               (line  50)
  10636 * magit-diff-visit-worktree-file-other-frame: Visiting Files and Blobs from a Diff.
  10637                                                               (line  73)
  10638 * magit-diff-visit-worktree-file-other-window: Visiting Files and Blobs from a Diff.
  10639                                                               (line  72)
  10640 * magit-diff-while-committing:           Refreshing Diffs.    (line  75)
  10641 * magit-diff-while-committing <1>:       Editing Commit Messages.
  10642                                                               (line  54)
  10643 * magit-diff-working-tree:               Diffing.             (line  43)
  10644 * magit-disable-section-inserter:        Per-Repository Configuration.
  10645                                                               (line  31)
  10646 * magit-discard:                         Applying.            (line  40)
  10647 * magit-dispatch:                        Transient Commands.  (line  20)
  10648 * magit-display-buffer:                  Switching Buffers.   (line   6)
  10649 * magit-display-buffer-fullcolumn-most-v1: Switching Buffers. (line  68)
  10650 * magit-display-buffer-fullframe-status-topleft-v1: Switching Buffers.
  10651                                                               (line  59)
  10652 * magit-display-buffer-fullframe-status-v1: Switching Buffers.
  10653                                                               (line  54)
  10654 * magit-display-buffer-same-window-except-diff-v1: Switching Buffers.
  10655                                                               (line  49)
  10656 * magit-display-buffer-traditional:      Switching Buffers.   (line  42)
  10657 * magit-display-repository-buffer:       Common Commands.     (line   9)
  10658 * magit-display-repository-buffer <1>:   Commands for Buffers Visiting Files.
  10659                                                               (line  52)
  10660 * magit-display-repository-buffer <2>:   Commands for Buffers Visiting Files.
  10661                                                               (line 172)
  10662 * magit-ediff:                           Ediffing.            (line  21)
  10663 * magit-ediff-compare:                   Ediffing.            (line  25)
  10664 * magit-ediff-dwim:                      Ediffing.            (line  10)
  10665 * magit-ediff-resolve-all:               Ediffing.            (line  48)
  10666 * magit-ediff-resolve-rest:              Ediffing.            (line  33)
  10667 * magit-ediff-show-commit:               Ediffing.            (line 100)
  10668 * magit-ediff-show-staged:               Ediffing.            (line  94)
  10669 * magit-ediff-show-stash:                Ediffing.            (line 103)
  10670 * magit-ediff-show-unstaged:             Ediffing.            (line  91)
  10671 * magit-ediff-show-working-tree:         Ediffing.            (line  97)
  10672 * magit-ediff-stage:                     Ediffing.            (line  87)
  10673 * magit-edit-line-commit:                Commands for Buffers Visiting Files.
  10674                                                               (line  52)
  10675 * magit-edit-line-commit <1>:            Commands for Buffers Visiting Files.
  10676                                                               (line 182)
  10677 * magit-emacs-Q-command:                 Debugging Tools.     (line  16)
  10678 * magit-fetch:                           Fetching.            (line  10)
  10679 * magit-fetch-all:                       Fetching.            (line  45)
  10680 * magit-fetch-branch:                    Fetching.            (line  37)
  10681 * magit-fetch-from-pushremote:           Fetching.            (line  15)
  10682 * magit-fetch-from-upstream:             Fetching.            (line  22)
  10683 * magit-fetch-modules:                   Fetching.            (line  48)
  10684 * magit-fetch-modules <1>:               Submodule Transient. (line  51)
  10685 * magit-fetch-other:                     Fetching.            (line  34)
  10686 * magit-fetch-refspec:                   Fetching.            (line  41)
  10687 * magit-file-checkout:                   Resetting.           (line  44)
  10688 * magit-file-checkout <1>:               Commands for Buffers Visiting Files.
  10689                                                               (line  52)
  10690 * magit-file-checkout <2>:               Commands for Buffers Visiting Files.
  10691                                                               (line  86)
  10692 * magit-file-delete:                     Commands for Buffers Visiting Files.
  10693                                                               (line  52)
  10694 * magit-file-delete <1>:                 Commands for Buffers Visiting Files.
  10695                                                               (line  82)
  10696 * magit-file-dispatch:                   Commands for Buffers Visiting Files.
  10697                                                               (line  52)
  10698 * magit-file-dispatch <1>:               Commands for Buffers Visiting Files.
  10699                                                               (line  58)
  10700 * magit-file-rename:                     Commands for Buffers Visiting Files.
  10701                                                               (line  52)
  10702 * magit-file-rename <1>:                 Commands for Buffers Visiting Files.
  10703                                                               (line  78)
  10704 * magit-file-untrack:                    Commands for Buffers Visiting Files.
  10705                                                               (line  52)
  10706 * magit-file-untrack <1>:                Commands for Buffers Visiting Files.
  10707                                                               (line  74)
  10708 * magit-find-file:                       General-Purpose Visit Commands.
  10709                                                               (line   9)
  10710 * magit-find-file <1>:                   Commands for Buffers Visiting Files.
  10711                                                               (line  52)
  10712 * magit-find-file <2>:                   Commands for Buffers Visiting Files.
  10713                                                               (line 156)
  10714 * magit-find-file-other-frame:           General-Purpose Visit Commands.
  10715                                                               (line  19)
  10716 * magit-find-file-other-window:          General-Purpose Visit Commands.
  10717                                                               (line  14)
  10718 * magit-generate-buffer-name-default-function: Naming Buffers.
  10719                                                               (line  16)
  10720 * magit-get-section:                     Matching Sections.   (line  14)
  10721 * magit-git:                             Calling Git for Effect.
  10722                                                               (line  46)
  10723 * magit-git-command:                     Running Git Manually.
  10724                                                               (line  25)
  10725 * magit-git-command-topdir:              Running Git Manually.
  10726                                                               (line  17)
  10727 * magit-git-exit-code:                   Getting a Value from Git.
  10728                                                               (line  10)
  10729 * magit-git-failure:                     Getting a Value from Git.
  10730                                                               (line  17)
  10731 * magit-git-false:                       Getting a Value from Git.
  10732                                                               (line  25)
  10733 * magit-git-insert:                      Getting a Value from Git.
  10734                                                               (line  29)
  10735 * magit-git-items:                       Getting a Value from Git.
  10736                                                               (line  41)
  10737 * magit-git-lines:                       Getting a Value from Git.
  10738                                                               (line  37)
  10739 * magit-git-mergetool:                   Running Git Manually.
  10740                                                               (line  62)
  10741 * magit-git-mergetool <1>:               Ediffing.            (line  79)
  10742 * magit-git-str:                         Getting a Value from Git.
  10743                                                               (line  75)
  10744 * magit-git-string:                      Getting a Value from Git.
  10745                                                               (line  32)
  10746 * magit-git-success:                     Getting a Value from Git.
  10747                                                               (line  13)
  10748 * magit-git-true:                        Getting a Value from Git.
  10749                                                               (line  21)
  10750 * magit-git-wash:                        Calling Git for Effect.
  10751                                                               (line  50)
  10752 * magit-go-backward:                     Log Buffer.          (line  20)
  10753 * magit-go-backward <1>:                 Refreshing Diffs.    (line  84)
  10754 * magit-go-forward:                      Log Buffer.          (line  23)
  10755 * magit-go-forward <1>:                  Refreshing Diffs.    (line  87)
  10756 * magit-hunk-set-window-start:           Section Movement.    (line  45)
  10757 * magit-ido-completing-read:             Support for Completion Frameworks.
  10758                                                               (line  46)
  10759 * magit-init:                            Creating Repository. (line   7)
  10760 * magit-insert-am-sequence:              Status Sections.     (line  25)
  10761 * magit-insert-assumed-unchanged-files:  Status Sections.     (line  98)
  10762 * magit-insert-bisect-log:               Status Sections.     (line  39)
  10763 * magit-insert-bisect-output:            Status Sections.     (line  33)
  10764 * magit-insert-bisect-rest:              Status Sections.     (line  36)
  10765 * magit-insert-diff-filter-header:       Status Header Sections.
  10766                                                               (line  35)
  10767 * magit-insert-error-header:             Status Header Sections.
  10768                                                               (line  26)
  10769 * magit-insert-head-branch-header:       Status Header Sections.
  10770                                                               (line  38)
  10771 * magit-insert-heading:                  Creating Sections.   (line  41)
  10772 * magit-insert-ignored-files:            Status Sections.     (line  83)
  10773 * magit-insert-local-branches:           References Sections. (line  16)
  10774 * magit-insert-merge-log:                Status Sections.     (line  17)
  10775 * magit-insert-modules:                  Status Module Sections.
  10776                                                               (line  12)
  10777 * magit-insert-modules-overview:         Status Module Sections.
  10778                                                               (line  30)
  10779 * magit-insert-modules-unpulled-from-pushremote: Status Module Sections.
  10780                                                               (line  45)
  10781 * magit-insert-modules-unpulled-from-upstream: Status Module Sections.
  10782                                                               (line  40)
  10783 * magit-insert-modules-unpushed-to-pushremote: Status Module Sections.
  10784                                                               (line  55)
  10785 * magit-insert-modules-unpushed-to-upstream: Status Module Sections.
  10786                                                               (line  50)
  10787 * magit-insert-push-branch-header:       Status Header Sections.
  10788                                                               (line  45)
  10789 * magit-insert-rebase-sequence:          Status Sections.     (line  21)
  10790 * magit-insert-recent-commits:           Status Sections.     (line 110)
  10791 * magit-insert-remote-branches:          References Sections. (line  19)
  10792 * magit-insert-remote-header:            Status Header Sections.
  10793                                                               (line  58)
  10794 * magit-insert-repo-header:              Status Header Sections.
  10795                                                               (line  55)
  10796 * magit-insert-section:                  Creating Sections.   (line   6)
  10797 * magit-insert-sequencer-sequence:       Status Sections.     (line  29)
  10798 * magit-insert-skip-worktree-files:      Status Sections.     (line  92)
  10799 * magit-insert-staged-changes:           Status Sections.     (line  53)
  10800 * magit-insert-stashes:                  Status Sections.     (line  56)
  10801 * magit-insert-status-headers:           Status Header Sections.
  10802                                                               (line  12)
  10803 * magit-insert-tags:                     References Sections. (line  22)
  10804 * magit-insert-tags-header:              Status Header Sections.
  10805                                                               (line  49)
  10806 * magit-insert-tracked-files:            Status Sections.     (line  80)
  10807 * magit-insert-unpulled-cherries:        Status Sections.     (line 119)
  10808 * magit-insert-unpulled-from-pushremote: Status Sections.     (line  66)
  10809 * magit-insert-unpulled-from-upstream:   Status Sections.     (line  62)
  10810 * magit-insert-unpulled-or-recent-commits: Status Sections.   (line 104)
  10811 * magit-insert-unpushed-cherries:        Status Sections.     (line 125)
  10812 * magit-insert-unpushed-to-pushremote:   Status Sections.     (line  74)
  10813 * magit-insert-unpushed-to-upstream:     Status Sections.     (line  70)
  10814 * magit-insert-unstaged-changes:         Status Sections.     (line  50)
  10815 * magit-insert-untracked-files:          Status Sections.     (line  42)
  10816 * magit-insert-upstream-branch-header:   Status Header Sections.
  10817                                                               (line  41)
  10818 * magit-insert-user-header:              Status Header Sections.
  10819                                                               (line  65)
  10820 * magit-jump-to-diffstat-or-diff:        Commands Available in Diffs.
  10821                                                               (line  43)
  10822 * magit-kill-this-buffer:                Minor Mode for Buffers Visiting Blobs.
  10823                                                               (line  19)
  10824 * magit-list-repositories:               Repository List.     (line   6)
  10825 * magit-list-submodules:                 Listing Submodules.  (line  13)
  10826 * magit-list-submodules <1>:             Submodule Transient. (line  48)
  10827 * magit-log:                             Logging.             (line  28)
  10828 * magit-log <1>:                         Commands for Buffers Visiting Files.
  10829                                                               (line  52)
  10830 * magit-log <2>:                         Commands for Buffers Visiting Files.
  10831                                                               (line 109)
  10832 * magit-log-all:                         Logging.             (line  59)
  10833 * magit-log-all-branches:                Logging.             (line  56)
  10834 * magit-log-branches:                    Logging.             (line  53)
  10835 * magit-log-buffer-file:                 Commands for Buffers Visiting Files.
  10836                                                               (line  52)
  10837 * magit-log-buffer-file <1>:             Commands for Buffers Visiting Files.
  10838                                                               (line 119)
  10839 * magit-log-bury-buffer:                 Log Buffer.          (line  14)
  10840 * magit-log-current:                     Logging.             (line  33)
  10841 * magit-log-double-commit-limit:         Log Buffer.          (line  64)
  10842 * magit-log-half-commit-limit:           Log Buffer.          (line  67)
  10843 * magit-log-head:                        Logging.             (line  38)
  10844 * magit-log-maybe-show-more-commits:     Section Movement.    (line  58)
  10845 * magit-log-maybe-update-blob-buffer:    Section Movement.    (line  72)
  10846 * magit-log-maybe-update-revision-buffer: Section Movement.   (line  65)
  10847 * magit-log-merged:                      Commands for Buffers Visiting Files.
  10848                                                               (line  52)
  10849 * magit-log-merged <1>:                  Commands for Buffers Visiting Files.
  10850                                                               (line 132)
  10851 * magit-log-move-to-parent:              Log Buffer.          (line  26)
  10852 * magit-log-move-to-revision:            Log Buffer.          (line  31)
  10853 * magit-log-other:                       Logging.             (line  47)
  10854 * magit-log-refresh:                     Refreshing Logs.     (line  12)
  10855 * magit-log-refresh <1>:                 Refreshing Logs.     (line  17)
  10856 * magit-log-refresh <2>:                 Log Buffer.          (line   7)
  10857 * magit-log-related:                     Logging.             (line  41)
  10858 * magit-log-save-default-arguments:      Refreshing Logs.     (line  27)
  10859 * magit-log-select-pick:                 Select from Log.     (line  21)
  10860 * magit-log-select-quit:                 Select from Log.     (line  26)
  10861 * magit-log-set-default-arguments:       Refreshing Logs.     (line  21)
  10862 * magit-log-toggle-commit-limit:         Log Buffer.          (line  59)
  10863 * magit-log-trace-definition:            Commands for Buffers Visiting Files.
  10864                                                               (line  52)
  10865 * magit-log-trace-definition <1>:        Commands for Buffers Visiting Files.
  10866                                                               (line 129)
  10867 * magit-margin-settings:                 Log Margin.          (line  52)
  10868 * magit-maybe-set-dedicated:             Switching Buffers.   (line  89)
  10869 * magit-merge:                           Merging.             (line  10)
  10870 * magit-merge <1>:                       Merging.             (line  86)
  10871 * magit-merge-abort:                     Merging.             (line  91)
  10872 * magit-merge-absorb:                    Merging.             (line  42)
  10873 * magit-merge-editmsg:                   Merging.             (line  30)
  10874 * magit-merge-into:                      Merging.             (line  54)
  10875 * magit-merge-nocommit:                  Merging.             (line  36)
  10876 * magit-merge-plain:                     Merging.             (line  18)
  10877 * magit-merge-preview:                   Merging.             (line  75)
  10878 * magit-merge-squash:                    Merging.             (line  67)
  10879 * magit-mode-bury-buffer:                Quitting Windows.    (line   7)
  10880 * magit-mode-display-buffer:             Refreshing Buffers.  (line  32)
  10881 * magit-mode-quit-window:                Quitting Windows.    (line  34)
  10882 * magit-mode-setup:                      Refreshing Buffers.  (line  17)
  10883 * magit-notes:                           Notes.               (line   9)
  10884 * magit-notes-edit:                      Notes.               (line  14)
  10885 * magit-notes-merge:                     Notes.               (line  35)
  10886 * magit-notes-merge-abort:               Notes.               (line  47)
  10887 * magit-notes-merge-commit:              Notes.               (line  43)
  10888 * magit-notes-prune:                     Notes.               (line  28)
  10889 * magit-notes-remove:                    Notes.               (line  21)
  10890 * magit-patch:                           Plain Patches.       (line   7)
  10891 * magit-patch-apply:                     Plain Patches.       (line  20)
  10892 * magit-patch-apply <1>:                 Maildir Patches.     (line  23)
  10893 * magit-patch-create:                    Plain Patches.       (line  12)
  10894 * magit-patch-save:                      Plain Patches.       (line  26)
  10895 * magit-pop-revision-stack:              Using the Revision Stack.
  10896                                                               (line   7)
  10897 * magit-process:                         Viewing Git Output.  (line  17)
  10898 * magit-process-file:                    Getting a Value from Git.
  10899                                                               (line  57)
  10900 * magit-process-git:                     Getting a Value from Git.
  10901                                                               (line  50)
  10902 * magit-process-kill:                    Viewing Git Output.  (line  24)
  10903 * magit-pull:                            Pulling.             (line  10)
  10904 * magit-pull-branch:                     Pulling.             (line  28)
  10905 * magit-pull-from-pushremote:            Pulling.             (line  14)
  10906 * magit-pull-from-upstream:              Pulling.             (line  21)
  10907 * magit-push:                            Pushing.             (line  10)
  10908 * magit-push-current:                    Pushing.             (line  29)
  10909 * magit-push-current-to-pushremote:      Pushing.             (line  15)
  10910 * magit-push-current-to-upstream:        Pushing.             (line  22)
  10911 * magit-push-implicitly:                 Pushing.             (line  74)
  10912 * magit-push-matching:                   Pushing.             (line  45)
  10913 * magit-push-other:                      Pushing.             (line  33)
  10914 * magit-push-refspecs:                   Pushing.             (line  37)
  10915 * magit-push-tag:                        Pushing.             (line  59)
  10916 * magit-push-tags:                       Pushing.             (line  52)
  10917 * magit-push-to-remote:                  Pushing.             (line  91)
  10918 * magit-rebase:                          Rebasing.            (line  10)
  10919 * magit-rebase-abort:                    Rebasing.            (line 111)
  10920 * magit-rebase-autosquash:               Rebasing.            (line  79)
  10921 * magit-rebase-branch:                   Rebasing.            (line  42)
  10922 * magit-rebase-continue:                 Rebasing.            (line  97)
  10923 * magit-rebase-edit:                     Rebasing.            (line 107)
  10924 * magit-rebase-edit-commit:              Rebasing.            (line  83)
  10925 * magit-rebase-interactive:              Rebasing.            (line  76)
  10926 * magit-rebase-onto-pushremote:          Rebasing.            (line  28)
  10927 * magit-rebase-onto-upstream:            Rebasing.            (line  35)
  10928 * magit-rebase-remove-commit:            Rebasing.            (line  91)
  10929 * magit-rebase-reword-commit:            Rebasing.            (line  87)
  10930 * magit-rebase-skip:                     Rebasing.            (line 103)
  10931 * magit-rebase-subset:                   Rebasing.            (line  47)
  10932 * magit-reflog-current:                  Reflog.              (line  12)
  10933 * magit-reflog-head:                     Reflog.              (line  18)
  10934 * magit-reflog-other:                    Reflog.              (line  15)
  10935 * magit-refresh:                         Automatic Refreshing of Magit Buffers.
  10936                                                               (line  26)
  10937 * magit-refresh-all:                     Automatic Refreshing of Magit Buffers.
  10938                                                               (line  34)
  10939 * magit-refs-set-show-commit-count:      References Buffer.   (line  34)
  10940 * magit-region-sections:                 Section Selection.   (line   9)
  10941 * magit-region-values:                   Section Selection.   (line  35)
  10942 * magit-remote:                          Remote Commands.     (line  14)
  10943 * magit-remote-add:                      Remote Commands.     (line  48)
  10944 * magit-remote-configure:                Remote Commands.     (line  32)
  10945 * magit-remote-prune:                    Remote Commands.     (line  63)
  10946 * magit-remote-prune-refspecs:           Remote Commands.     (line  67)
  10947 * magit-remote-remove:                   Remote Commands.     (line  60)
  10948 * magit-remote-rename:                   Remote Commands.     (line  52)
  10949 * magit-remote-set-url:                  Remote Commands.     (line  56)
  10950 * magit-repolist-column-branch:          Repository List.     (line  51)
  10951 * magit-repolist-column-branches:        Repository List.     (line  58)
  10952 * magit-repolist-column-flag:            Repository List.     (line  64)
  10953 * magit-repolist-column-flags:           Repository List.     (line  76)
  10954 * magit-repolist-column-ident:           Repository List.     (line  40)
  10955 * magit-repolist-column-path:            Repository List.     (line  44)
  10956 * magit-repolist-column-stashes:         Repository List.     (line  61)
  10957 * magit-repolist-column-unpulled-from-pushremote: Repository List.
  10958                                                               (line  87)
  10959 * magit-repolist-column-unpulled-from-upstream: Repository List.
  10960                                                               (line  83)
  10961 * magit-repolist-column-unpushed-to-pushremote: Repository List.
  10962                                                               (line  95)
  10963 * magit-repolist-column-unpushed-to-upstream: Repository List.
  10964                                                               (line  91)
  10965 * magit-repolist-column-upstream:        Repository List.     (line  54)
  10966 * magit-repolist-column-version:         Repository List.     (line  47)
  10967 * magit-repolist-fetch:                  Repository List.     (line 111)
  10968 * magit-repolist-find-file-other-frame:  Repository List.     (line 115)
  10969 * magit-repolist-mark:                   Repository List.     (line 105)
  10970 * magit-repolist-status:                 Repository List.     (line 102)
  10971 * magit-repolist-unmark:                 Repository List.     (line 108)
  10972 * magit-reset-hard:                      Resetting.           (line  24)
  10973 * magit-reset-index:                     Staging and Unstaging.
  10974                                                               (line  78)
  10975 * magit-reset-index <1>:                 Resetting.           (line  33)
  10976 * magit-reset-keep:                      Resetting.           (line  28)
  10977 * magit-reset-mixed:                     Resetting.           (line  15)
  10978 * magit-reset-quickly:                   Resetting.           (line   9)
  10979 * magit-reset-soft:                      Resetting.           (line  19)
  10980 * magit-reset-worktree:                  Resetting.           (line  39)
  10981 * magit-reset-worktree <1>:              Wip Modes.           (line  64)
  10982 * magit-restore-window-configuration:    Quitting Windows.    (line  24)
  10983 * magit-reverse:                         Applying.            (line  47)
  10984 * magit-reverse-in-index:                Staging and Unstaging.
  10985                                                               (line  58)
  10986 * magit-revert:                          Reverting.           (line   7)
  10987 * magit-revert-and-commit:               Reverting.           (line  15)
  10988 * magit-revert-no-commit:                Reverting.           (line  20)
  10989 * magit-run:                             Running Git Manually.
  10990                                                               (line  13)
  10991 * magit-run-git:                         Calling Git for Effect.
  10992                                                               (line  34)
  10993 * magit-run-git-async:                   Calling Git for Effect.
  10994                                                               (line  59)
  10995 * magit-run-git-gui:                     Running Git Manually.
  10996                                                               (line  59)
  10997 * magit-run-git-with-editor:             Calling Git for Effect.
  10998                                                               (line  71)
  10999 * magit-run-git-with-input:              Calling Git for Effect.
  11000                                                               (line  37)
  11001 * magit-run-gitk:                        Running Git Manually.
  11002                                                               (line  50)
  11003 * magit-run-gitk-all:                    Running Git Manually.
  11004                                                               (line  53)
  11005 * magit-run-gitk-branches:               Running Git Manually.
  11006                                                               (line  56)
  11007 * magit-save-window-configuration:       Switching Buffers.   (line  80)
  11008 * magit-section-backward:                Section Movement.    (line  11)
  11009 * magit-section-backward-siblings:       Section Movement.    (line  19)
  11010 * magit-section-case:                    Matching Sections.   (line  66)
  11011 * magit-section-cycle:                   Section Visibility.  (line  14)
  11012 * magit-section-cycle-diffs:             Section Visibility.  (line  29)
  11013 * magit-section-cycle-global:            Section Visibility.  (line  33)
  11014 * magit-section-forward:                 Section Movement.    (line  16)
  11015 * magit-section-forward-siblings:        Section Movement.    (line  24)
  11016 * magit-section-hide:                    Section Visibility.  (line  55)
  11017 * magit-section-hide-children:           Section Visibility.  (line  67)
  11018 * magit-section-ident:                   Matching Sections.   (line  10)
  11019 * magit-section-match:                   Matching Sections.   (line  18)
  11020 * magit-section-set-window-start:        Section Movement.    (line  52)
  11021 * magit-section-show:                    Section Visibility.  (line  52)
  11022 * magit-section-show-children:           Section Visibility.  (line  62)
  11023 * magit-section-show-headings:           Section Visibility.  (line  58)
  11024 * magit-section-show-level-1:            Section Visibility.  (line  39)
  11025 * magit-section-show-level-1-all:        Section Visibility.  (line  45)
  11026 * magit-section-show-level-2:            Section Visibility.  (line  39)
  11027 * magit-section-show-level-2-all:        Section Visibility.  (line  45)
  11028 * magit-section-show-level-3:            Section Visibility.  (line  39)
  11029 * magit-section-show-level-3-all:        Section Visibility.  (line  45)
  11030 * magit-section-show-level-4:            Section Visibility.  (line  39)
  11031 * magit-section-show-level-4-all:        Section Visibility.  (line  45)
  11032 * magit-section-toggle:                  Section Visibility.  (line  10)
  11033 * magit-section-toggle-children:         Section Visibility.  (line  70)
  11034 * magit-section-up:                      Section Movement.    (line  28)
  11035 * magit-section-value-if:                Matching Sections.   (line  57)
  11036 * magit-sequence-abort:                  Cherry Picking.      (line  91)
  11037 * magit-sequence-abort <1>:              Reverting.           (line  35)
  11038 * magit-sequence-continue:               Cherry Picking.      (line  85)
  11039 * magit-sequence-continue <1>:           Reverting.           (line  29)
  11040 * magit-sequence-skip:                   Cherry Picking.      (line  88)
  11041 * magit-sequence-skip <1>:               Reverting.           (line  32)
  11042 * magit-shell-command:                   Running Git Manually.
  11043                                                               (line  38)
  11044 * magit-shell-command-topdir:            Running Git Manually.
  11045                                                               (line  34)
  11046 * magit-show-commit:                     Diffing.             (line  63)
  11047 * magit-show-commit <1>:                 Blaming.             (line  91)
  11048 * magit-show-refs:                       References Buffer.   (line   7)
  11049 * magit-show-refs-current:               References Buffer.   (line  25)
  11050 * magit-show-refs-head:                  References Buffer.   (line  21)
  11051 * magit-show-refs-other:                 References Buffer.   (line  30)
  11052 * magit-snapshot-both:                   Stashing.            (line  36)
  11053 * magit-snapshot-index:                  Stashing.            (line  42)
  11054 * magit-snapshot-worktree:               Stashing.            (line  46)
  11055 * magit-sparse-checkout:                 Sparse checkouts.    (line  17)
  11056 * magit-sparse-checkout-add:             Sparse checkouts.    (line  39)
  11057 * magit-sparse-checkout-disable:         Sparse checkouts.    (line  50)
  11058 * magit-sparse-checkout-enable:          Sparse checkouts.    (line  21)
  11059 * magit-sparse-checkout-reapply:         Sparse checkouts.    (line  44)
  11060 * magit-sparse-checkout-set:             Sparse checkouts.    (line  33)
  11061 * magit-stage:                           Staging and Unstaging.
  11062                                                               (line  29)
  11063 * magit-stage-buffer-file:               Commands for Buffers Visiting Files.
  11064                                                               (line  52)
  11065 * magit-stage-buffer-file <1>:           Commands for Buffers Visiting Files.
  11066                                                               (line  63)
  11067 * magit-stage-file:                      Staging from File-Visiting Buffers.
  11068                                                               (line  11)
  11069 * magit-stage-file <1>:                  Commands for Buffers Visiting Files.
  11070                                                               (line  52)
  11071 * magit-stage-file <2>:                  Commands for Buffers Visiting Files.
  11072                                                               (line  63)
  11073 * magit-stage-modified:                  Staging and Unstaging.
  11074                                                               (line  36)
  11075 * magit-start-git:                       Calling Git for Effect.
  11076                                                               (line  82)
  11077 * magit-start-process:                   Calling Git for Effect.
  11078                                                               (line 100)
  11079 * magit-stash:                           Stashing.            (line   9)
  11080 * magit-stash-apply:                     Stashing.            (line  52)
  11081 * magit-stash-both:                      Stashing.            (line  14)
  11082 * magit-stash-branch:                    Stashing.            (line 105)
  11083 * magit-stash-branch-here:               Stashing.            (line 110)
  11084 * magit-stash-clear:                     Stashing.            (line 118)
  11085 * magit-stash-drop:                      Stashing.            (line  98)
  11086 * magit-stash-format-patch:              Stashing.            (line 115)
  11087 * magit-stash-index:                     Stashing.            (line  20)
  11088 * magit-stash-keep-index:                Stashing.            (line  30)
  11089 * magit-stash-list:                      Stashing.            (line 121)
  11090 * magit-stash-pop:                       Stashing.            (line  74)
  11091 * magit-stash-show:                      Diffing.             (line  67)
  11092 * magit-stash-show <1>:                  Stashing.            (line 102)
  11093 * magit-stash-worktree:                  Stashing.            (line  24)
  11094 * magit-stashes-maybe-update-stash-buffer: Section Movement.  (line  92)
  11095 * magit-status:                          Status Buffer.       (line  23)
  11096 * magit-status-here:                     Commands for Buffers Visiting Files.
  11097                                                               (line  52)
  11098 * magit-status-here <1>:                 Commands for Buffers Visiting Files.
  11099                                                               (line 166)
  11100 * magit-status-maybe-update-blob-buffer: Section Movement.    (line  87)
  11101 * magit-status-maybe-update-revision-buffer: Section Movement.
  11102                                                               (line  77)
  11103 * magit-status-maybe-update-stash-buffer: Section Movement.   (line  82)
  11104 * magit-status-quick:                    Status Buffer.       (line  70)
  11105 * magit-submodule:                       Submodule Transient. (line   7)
  11106 * magit-submodule-add:                   Submodule Transient. (line  20)
  11107 * magit-submodule-populate:              Submodule Transient. (line  32)
  11108 * magit-submodule-register:              Submodule Transient. (line  26)
  11109 * magit-submodule-synchronize:           Submodule Transient. (line  40)
  11110 * magit-submodule-unpopulate:            Submodule Transient. (line  45)
  11111 * magit-submodule-update:                Submodule Transient. (line  36)
  11112 * magit-subtree:                         Subtree.             (line   9)
  11113 * magit-subtree-add:                     Subtree.             (line  24)
  11114 * magit-subtree-add-commit:              Subtree.             (line  28)
  11115 * magit-subtree-export:                  Subtree.             (line  37)
  11116 * magit-subtree-import:                  Subtree.             (line  13)
  11117 * magit-subtree-merge:                   Subtree.             (line  31)
  11118 * magit-subtree-pull:                    Subtree.             (line  34)
  11119 * magit-subtree-push:                    Subtree.             (line  48)
  11120 * magit-subtree-split:                   Subtree.             (line  52)
  11121 * magit-switch-to-repository-buffer:     Common Commands.     (line   6)
  11122 * magit-switch-to-repository-buffer-other-frame: Common Commands.
  11123                                                               (line   8)
  11124 * magit-switch-to-repository-buffer-other-window: Common Commands.
  11125                                                               (line   7)
  11126 * magit-tag:                             Tagging.             (line   9)
  11127 * magit-tag-create:                      Tagging.             (line  14)
  11128 * magit-tag-delete:                      Tagging.             (line  37)
  11129 * magit-tag-prune:                       Tagging.             (line  43)
  11130 * magit-tag-release:                     Tagging.             (line  18)
  11131 * magit-toggle-buffer-lock:              Modes and Buffers.   (line  18)
  11132 * magit-toggle-git-debug:                Debugging Tools.     (line  29)
  11133 * magit-toggle-margin:                   Refreshing Logs.     (line  34)
  11134 * magit-toggle-margin <1>:               Log Margin.          (line  60)
  11135 * magit-toggle-margin-details:           Log Margin.          (line  66)
  11136 * magit-toggle-verbose-refresh:          Debugging Tools.     (line  52)
  11137 * magit-unstage:                         Staging and Unstaging.
  11138                                                               (line  42)
  11139 * magit-unstage-all:                     Staging and Unstaging.
  11140                                                               (line  50)
  11141 * magit-unstage-buffer-file:             Commands for Buffers Visiting Files.
  11142                                                               (line  52)
  11143 * magit-unstage-buffer-file <1>:         Commands for Buffers Visiting Files.
  11144                                                               (line  69)
  11145 * magit-unstage-file:                    Staging from File-Visiting Buffers.
  11146                                                               (line  18)
  11147 * magit-unstage-file <1>:                Commands for Buffers Visiting Files.
  11148                                                               (line  52)
  11149 * magit-unstage-file <2>:                Commands for Buffers Visiting Files.
  11150                                                               (line  69)
  11151 * magit-version:                         Git Executable.      (line  59)
  11152 * magit-version <1>:                     Debugging Tools.     (line  11)
  11153 * magit-visit-ref:                       References Buffer.   (line 159)
  11154 * magit-wip-commit:                      Wip Modes.           (line  85)
  11155 * magit-wip-log:                         Wip Modes.           (line  47)
  11156 * magit-wip-log-current:                 Wip Modes.           (line  55)
  11157 * magit-worktree:                        Worktree.            (line   9)
  11158 * magit-worktree-branch:                 Worktree.            (line  16)
  11159 * magit-worktree-checkout:               Worktree.            (line  13)
  11160 * magit-worktree-delete:                 Worktree.            (line  22)
  11161 * magit-worktree-move:                   Worktree.            (line  19)
  11162 * magit-worktree-status:                 Worktree.            (line  26)
  11163 * scroll-down:                           Commands Available in Diffs.
  11164                                                               (line  56)
  11165 * scroll-up:                             Commands Available in Diffs.
  11166                                                               (line  53)
  11167 * with-editor-cancel:                    Editing Commit Messages.
  11168                                                               (line  22)
  11169 * with-editor-cancel <1>:                Editing Rebase Sequences.
  11170                                                               (line  11)
  11171 * with-editor-debug:                     Debugging Tools.     (line  64)
  11172 * with-editor-finish:                    Editing Commit Messages.
  11173                                                               (line  18)
  11174 * with-editor-finish <1>:                Editing Rebase Sequences.
  11175                                                               (line   7)
  11176 * with-editor-usage-message:             Commit Mode and Hooks.
  11177                                                               (line  51)
  11178 
  11179 
  11180 File: magit.info,  Node: Variable Index,  Prev: Function and Command Index,  Up: Top
  11181 
  11182 Appendix E Variable Index
  11183 *************************
  11184 
  11185 
  11186 * Menu:
  11187 
  11188 * auto-revert-buffer-list-filter:        Automatic Reverting of File-Visiting Buffers.
  11189                                                               (line  73)
  11190 * auto-revert-interval:                  Automatic Reverting of File-Visiting Buffers.
  11191                                                               (line  69)
  11192 * auto-revert-mode:                      Automatic Reverting of File-Visiting Buffers.
  11193                                                               (line  57)
  11194 * auto-revert-stop-on-user-input:        Automatic Reverting of File-Visiting Buffers.
  11195                                                               (line  65)
  11196 * auto-revert-use-notify:                Automatic Reverting of File-Visiting Buffers.
  11197                                                               (line  46)
  11198 * auto-revert-verbose:                   Automatic Reverting of File-Visiting Buffers.
  11199                                                               (line  94)
  11200 * branch.autoSetupMerge:                 Branch Git Variables.
  11201                                                               (line  71)
  11202 * branch.autoSetupRebase:                Branch Git Variables.
  11203                                                               (line  85)
  11204 * branch.NAME.description:               Branch Git Variables.
  11205                                                               (line  42)
  11206 * branch.NAME.merge:                     Branch Git Variables.
  11207                                                               (line  10)
  11208 * branch.NAME.pushRemote:                Branch Git Variables.
  11209                                                               (line  29)
  11210 * branch.NAME.rebase:                    Branch Git Variables.
  11211                                                               (line  20)
  11212 * branch.NAME.remote:                    Branch Git Variables.
  11213                                                               (line  15)
  11214 * core.notesRef:                         Notes.               (line  53)
  11215 * git-commit-finish-query-functions:     Commit Message Conventions.
  11216                                                               (line  18)
  11217 * git-commit-known-pseudo-headers:       Commit Pseudo Headers.
  11218                                                               (line   9)
  11219 * git-commit-major-mode:                 Commit Mode and Hooks.
  11220                                                               (line  12)
  11221 * git-commit-post-finish-hook:           Commit Mode and Hooks.
  11222                                                               (line  54)
  11223 * git-commit-setup-hook:                 Commit Mode and Hooks.
  11224                                                               (line  21)
  11225 * git-commit-style-convention-checks:    Commit Message Conventions.
  11226                                                               (line  38)
  11227 * git-commit-summary-max-length:         Commit Message Conventions.
  11228                                                               (line  13)
  11229 * git-rebase-auto-advance:               Editing Rebase Sequences.
  11230                                                               (line  80)
  11231 * git-rebase-confirm-cancel:             Editing Rebase Sequences.
  11232                                                               (line  86)
  11233 * git-rebase-show-instructions:          Editing Rebase Sequences.
  11234                                                               (line  83)
  11235 * global-auto-revert-mode:               Automatic Reverting of File-Visiting Buffers.
  11236                                                               (line  21)
  11237 * magit-auto-revert-immediately:         Automatic Reverting of File-Visiting Buffers.
  11238                                                               (line  30)
  11239 * magit-auto-revert-mode:                Automatic Reverting of File-Visiting Buffers.
  11240                                                               (line  17)
  11241 * magit-auto-revert-tracked-only:        Automatic Reverting of File-Visiting Buffers.
  11242                                                               (line  51)
  11243 * magit-bisect-show-graph:               Bisecting.           (line  57)
  11244 * magit-blame-disable-modes:             Blaming.             (line 165)
  11245 * magit-blame-echo-style:                Blaming.             (line 151)
  11246 * magit-blame-goto-chunk-hook:           Blaming.             (line 170)
  11247 * magit-blame-read-only:                 Blaming.             (line 161)
  11248 * magit-blame-styles:                    Blaming.             (line 147)
  11249 * magit-blame-time-format:               Blaming.             (line 157)
  11250 * magit-branch-adjust-remote-upstream-alist: Branch Commands. (line 202)
  11251 * magit-branch-direct-configure:         Branch Commands.     (line  19)
  11252 * magit-branch-prefer-remote-upstream:   Branch Commands.     (line 158)
  11253 * magit-branch-read-upstream-first:      Branch Commands.     (line 153)
  11254 * magit-buffer-name-format:              Naming Buffers.      (line  25)
  11255 * magit-bury-buffer-function:            Quitting Windows.    (line  16)
  11256 * magit-cherry-margin:                   Cherries.            (line  21)
  11257 * magit-clone-always-transient:          Cloning Repository.  (line  12)
  11258 * magit-clone-default-directory:         Cloning Repository.  (line  84)
  11259 * magit-clone-name-alist:                Cloning Repository.  (line  94)
  11260 * magit-clone-set-remote-head:           Cloning Repository.  (line  66)
  11261 * magit-clone-set-remote.pushDefault:    Cloning Repository.  (line  75)
  11262 * magit-clone-url-format:                Cloning Repository.  (line 114)
  11263 * magit-commit-ask-to-stage:             Initiating a Commit. (line  65)
  11264 * magit-commit-diff-inhibit-same-window: Initiating a Commit. (line  97)
  11265 * magit-commit-extend-override-date:     Initiating a Commit. (line  72)
  11266 * magit-commit-reword-override-date:     Initiating a Commit. (line  75)
  11267 * magit-commit-show-diff:                Initiating a Commit. (line  69)
  11268 * magit-commit-squash-confirm:           Initiating a Commit. (line  78)
  11269 * magit-completing-read-function:        Support for Completion Frameworks.
  11270                                                               (line  27)
  11271 * magit-define-global-key-bindings:      Global Bindings.     (line   6)
  11272 * magit-diff-adjust-tab-width:           Diff Options.        (line  17)
  11273 * magit-diff-buffer-file-locked:         Commands for Buffers Visiting Files.
  11274                                                               (line 104)
  11275 * magit-diff-extra-stat-arguments:       Diff Options.        (line 112)
  11276 * magit-diff-hide-trailing-cr-characters: Diff Options.       (line  77)
  11277 * magit-diff-highlight-hunk-region-functions: Diff Options.   (line  80)
  11278 * magit-diff-highlight-indentation:      Diff Options.        (line  63)
  11279 * magit-diff-highlight-trailing:         Diff Options.        (line  59)
  11280 * magit-diff-paint-whitespace:           Diff Options.        (line  38)
  11281 * magit-diff-paint-whitespace-lines:     Diff Options.        (line  52)
  11282 * magit-diff-refine-hunk:                Diff Options.        (line   6)
  11283 * magit-diff-refine-ignore-whitespace:   Diff Options.        (line  13)
  11284 * magit-diff-unmarked-lines-keep-foreground: Diff Options.    (line 105)
  11285 * magit-diff-visit-previous-blob:        Visiting Files and Blobs from a Diff.
  11286                                                               (line  38)
  11287 * magit-direct-use-buffer-arguments:     Transient Arguments and Buffer Variables.
  11288                                                               (line  73)
  11289 * magit-display-buffer-function:         Switching Buffers.   (line  25)
  11290 * magit-display-buffer-noselect:         Switching Buffers.   (line  17)
  11291 * magit-dwim-selection:                  Completion and Confirmation.
  11292                                                               (line  42)
  11293 * magit-ediff-dwim-resolve-function:     Ediffing.            (line 105)
  11294 * magit-ediff-dwim-show-on-hunks:        Ediffing.            (line 111)
  11295 * magit-ediff-quit-hook:                 Ediffing.            (line 124)
  11296 * magit-ediff-show-stash-with-index:     Ediffing.            (line 118)
  11297 * magit-generate-buffer-name-function:   Naming Buffers.      (line   6)
  11298 * magit-git-debug:                       Viewing Git Output.  (line  26)
  11299 * magit-git-debug <1>:                   Getting a Value from Git.
  11300                                                               (line  68)
  11301 * magit-git-executable:                  Git Executable.      (line  26)
  11302 * magit-git-global-arguments:            Global Git Arguments.
  11303                                                               (line   6)
  11304 * magit-keep-region-overlay:             The Selection.       (line  52)
  11305 * magit-list-refs-sortby:                Additional Completion Options.
  11306                                                               (line   6)
  11307 * magit-log-auto-more:                   Log Buffer.          (line  69)
  11308 * magit-log-buffer-file-locked:          Commands for Buffers Visiting Files.
  11309                                                               (line 124)
  11310 * magit-log-margin:                      Log Margin.          (line  12)
  11311 * magit-log-margin-show-committer-date:  Log Margin.          (line  44)
  11312 * magit-log-section-commit-count:        Status Sections.     (line 114)
  11313 * magit-log-select-margin:               Select from Log.     (line  28)
  11314 * magit-log-show-color-graph-limit:      Log Buffer.          (line  78)
  11315 * magit-log-show-refname-after-summary:  Log Buffer.          (line  74)
  11316 * magit-log-show-signatures-limit:       Log Buffer.          (line  84)
  11317 * magit-log-trace-definition-function:   Commands Available in Diffs.
  11318                                                               (line  17)
  11319 * magit-module-sections-hook:            Status Module Sections.
  11320                                                               (line  19)
  11321 * magit-module-sections-nested:          Status Module Sections.
  11322                                                               (line  22)
  11323 * magit-no-confirm:                      Action Confirmation. (line  18)
  11324 * magit-pop-revision-stack-format:       Using the Revision Stack.
  11325                                                               (line  34)
  11326 * magit-post-clone-hook:                 Cloning Repository.  (line 133)
  11327 * magit-post-commit-hook:                Initiating a Commit. (line  86)
  11328 * magit-post-display-buffer-hook:        Switching Buffers.   (line  85)
  11329 * magit-pre-display-buffer-hook:         Switching Buffers.   (line  76)
  11330 * magit-prefer-remote-upstream:          Branch Git Variables.
  11331                                                               (line 108)
  11332 * magit-prefix-use-buffer-arguments:     Transient Arguments and Buffer Variables.
  11333                                                               (line  65)
  11334 * magit-process-extreme-logging:         Viewing Git Output.  (line  56)
  11335 * magit-process-raise-error:             Calling Git for Effect.
  11336                                                               (line 125)
  11337 * magit-pull-or-fetch:                   Fetching.            (line  52)
  11338 * magit-reflog-margin:                   Reflog.              (line  20)
  11339 * magit-refresh-args:                    Refreshing Buffers.  (line  52)
  11340 * magit-refresh-buffer-hook:             Automatic Refreshing of Magit Buffers.
  11341                                                               (line  41)
  11342 * magit-refresh-function:                Refreshing Buffers.  (line  47)
  11343 * magit-refresh-status-buffer:           Automatic Refreshing of Magit Buffers.
  11344                                                               (line  46)
  11345 * magit-refs-filter-alist:               References Buffer.   (line 137)
  11346 * magit-refs-focus-column-width:         References Buffer.   (line  75)
  11347 * magit-refs-margin:                     References Buffer.   (line  89)
  11348 * magit-refs-margin-for-tags:            References Buffer.   (line 112)
  11349 * magit-refs-pad-commit-counts:          References Buffer.   (line  45)
  11350 * magit-refs-primary-column-width:       References Buffer.   (line  63)
  11351 * magit-refs-sections-hook:              References Sections. (line  13)
  11352 * magit-refs-show-commit-count:          References Buffer.   (line  36)
  11353 * magit-refs-show-remote-prefix:         References Buffer.   (line  57)
  11354 * magit-remote-add-set-remote.pushDefault: Remote Commands.   (line  83)
  11355 * magit-remote-direct-configure:         Remote Commands.     (line  20)
  11356 * magit-remote-git-executable:           Git Executable.      (line  32)
  11357 * magit-repolist-columns:                Repository List.     (line  12)
  11358 * magit-repository-directories:          Status Buffer.       (line  57)
  11359 * magit-revision-filter-files-on-follow: Revision Buffer.     (line  55)
  11360 * magit-revision-insert-related-refs:    Revision Buffer.     (line   6)
  11361 * magit-revision-show-gravatars:         Revision Buffer.     (line  15)
  11362 * magit-revision-use-hash-sections:      Revision Buffer.     (line  31)
  11363 * magit-root-section:                    Matching Sections.   (line  81)
  11364 * magit-save-repository-buffers:         Automatic Saving of File-Visiting Buffers.
  11365                                                               (line  13)
  11366 * magit-section-cache-visibility:        Section Visibility.  (line  95)
  11367 * magit-section-initial-visibility-alist: Section Visibility. (line  79)
  11368 * magit-section-movement-hook:           Section Movement.    (line  41)
  11369 * magit-section-set-visibility-hook:     Section Visibility.  (line 105)
  11370 * magit-section-show-child-count:        Section Options.     (line   9)
  11371 * magit-section-visibility-indicator:    Section Visibility.  (line 122)
  11372 * magit-shell-command-verbose-prompt:    Running Git Manually.
  11373                                                               (line  43)
  11374 * magit-stashes-margin:                  Stashing.            (line 123)
  11375 * magit-status-headers-hook:             Status Header Sections.
  11376                                                               (line  17)
  11377 * magit-status-margin:                   Status Options.      (line   6)
  11378 * magit-status-sections-hook:            Status Sections.     (line  10)
  11379 * magit-submodule-list-columns:          Listing Submodules.  (line  20)
  11380 * magit-this-process:                    Calling Git for Effect.
  11381                                                               (line 121)
  11382 * magit-uniquify-buffer-names:           Naming Buffers.      (line  65)
  11383 * magit-unstage-committed:               Staging and Unstaging.
  11384                                                               (line  52)
  11385 * magit-update-other-window-delay:       Section Movement.    (line  97)
  11386 * magit-visit-ref-behavior:              References Buffer.   (line 168)
  11387 * magit-wip-after-apply-mode:            Legacy Wip Modes.    (line  18)
  11388 * magit-wip-after-apply-mode-lighter:    Legacy Wip Modes.    (line  54)
  11389 * magit-wip-after-save-local-mode-lighter: Legacy Wip Modes.  (line  51)
  11390 * magit-wip-after-save-mode:             Legacy Wip Modes.    (line  13)
  11391 * magit-wip-before-change-mode:          Legacy Wip Modes.    (line  31)
  11392 * magit-wip-before-change-mode-lighter:  Legacy Wip Modes.    (line  57)
  11393 * magit-wip-initial-backup-mode:         Legacy Wip Modes.    (line  35)
  11394 * magit-wip-initial-backup-mode-lighter: Legacy Wip Modes.    (line  60)
  11395 * magit-wip-merge-branch:                Wip Graph.           (line   6)
  11396 * magit-wip-mode:                        Wip Modes.           (line  30)
  11397 * magit-wip-mode-lighter:                Wip Modes.           (line  98)
  11398 * magit-wip-namespace:                   Wip Modes.           (line  91)
  11399 * notes.displayRef:                      Notes.               (line  57)
  11400 * pull.rebase:                           Branch Git Variables.
  11401                                                               (line  50)
  11402 * remote.NAME.fetch:                     Remote Git Variables.
  11403                                                               (line  14)
  11404 * remote.NAME.push:                      Remote Git Variables.
  11405                                                               (line  23)
  11406 * remote.NAME.pushurl:                   Remote Git Variables.
  11407                                                               (line  18)
  11408 * remote.NAME.tagOpts:                   Remote Git Variables.
  11409                                                               (line  27)
  11410 * remote.NAME.url:                       Remote Git Variables.
  11411                                                               (line  10)
  11412 * remote.pushDefault:                    Branch Git Variables.
  11413                                                               (line  62)
  11414 
  11415 
  11416 
  11417 Tag Table:
  11418 Node: Top774
  11419 Node: Introduction6566
  11420 Node: Installation11282
  11421 Node: Installing from Melpa11612
  11422 Node: Installing from the Git Repository12687
  11423 Node: Post-Installation Tasks15501
  11424 Node: Getting Started16786
  11425 Node: Interface Concepts22597
  11426 Node: Modes and Buffers22976
  11427 Node: Switching Buffers24687
  11428 Node: Naming Buffers29426
  11429 Node: Quitting Windows32501
  11430 Node: Automatic Refreshing of Magit Buffers34436
  11431 Node: Automatic Saving of File-Visiting Buffers37317
  11432 Node: Automatic Reverting of File-Visiting Buffers38501
  11433 Node: Risk of Reverting Automatically43486
  11434 Node: Sections45868
  11435 Node: Section Movement46794
  11436 Node: Section Visibility51668
  11437 Node: Section Hooks58355
  11438 Node: Section Types and Values60761
  11439 Node: Section Options62176
  11440 Node: Transient Commands62647
  11441 Node: Transient Arguments and Buffer Variables64123
  11442 Node: Completion Confirmation and the Selection71140
  11443 Node: Action Confirmation71586
  11444 Node: Completion and Confirmation80091
  11445 Node: The Selection83276
  11446 Node: The hunk-internal region86174
  11447 Node: Support for Completion Frameworks87263
  11448 Node: Additional Completion Options92148
  11449 Node: Mouse Support92746
  11450 Node: Running Git93322
  11451 Node: Viewing Git Output93567
  11452 Node: Git Process Status96271
  11453 Node: Running Git Manually97236
  11454 Node: Git Executable99926
  11455 Node: Global Git Arguments102934
  11456 Node: Inspecting103739
  11457 Node: Status Buffer104896
  11458 Node: Status Sections109907
  11459 Node: Status Header Sections115434
  11460 Node: Status Module Sections118053
  11461 Node: Status Options120550
  11462 Node: Repository List121913
  11463 Node: Logging126691
  11464 Node: Refreshing Logs129530
  11465 Node: Log Buffer130951
  11466 Node: Log Margin135774
  11467 Node: Select from Log138927
  11468 Node: Reflog141137
  11469 Node: Cherries142774
  11470 Node: Diffing144612
  11471 Node: Refreshing Diffs147646
  11472 Node: Commands Available in Diffs151335
  11473 Node: Diff Options153848
  11474 Node: Revision Buffer159311
  11475 Node: Ediffing162631
  11476 Node: References Buffer168681
  11477 Node: References Sections179275
  11478 Node: Bisecting180132
  11479 Node: Visiting Files and Blobs182443
  11480 Node: General-Purpose Visit Commands182971
  11481 Node: Visiting Files and Blobs from a Diff183924
  11482 Node: Blaming187368
  11483 Node: Manipulating194356
  11484 Node: Creating Repository194698
  11485 Node: Cloning Repository195235
  11486 Node: Staging and Unstaging201676
  11487 Node: Staging from File-Visiting Buffers205657
  11488 Node: Applying206763
  11489 Node: Committing208836
  11490 Node: Initiating a Commit209419
  11491 Node: Editing Commit Messages214609
  11492 Node: Using the Revision Stack217382
  11493 Node: Commit Pseudo Headers220427
  11494 Node: Commit Mode and Hooks221722
  11495 Node: Commit Message Conventions224580
  11496 Node: Branching226567
  11497 Node: The Two Remotes226793
  11498 Node: Branch Commands229446
  11499 Node: Branch Git Variables242296
  11500 Node: Auxiliary Branch Commands247666
  11501 Node: Merging248782
  11502 Node: Resolving Conflicts252938
  11503 Node: Rebasing258312
  11504 Node: Editing Rebase Sequences263101
  11505 Node: Information About In-Progress Rebase267317
  11506 Ref: Information About In-Progress Rebase-Footnote-1276430
  11507 Node: Cherry Picking277026
  11508 Node: Reverting281360
  11509 Node: Resetting282779
  11510 Node: Stashing284605
  11511 Node: Transferring290986
  11512 Node: Remotes291208
  11513 Node: Remote Commands291360
  11514 Node: Remote Git Variables295399
  11515 Node: Fetching296670
  11516 Node: Pulling299153
  11517 Node: Pushing300179
  11518 Node: Plain Patches304470
  11519 Node: Maildir Patches305941
  11520 Node: Miscellaneous307420
  11521 Node: Tagging307766
  11522 Node: Notes309659
  11523 Node: Submodules311994
  11524 Node: Listing Submodules312212
  11525 Node: Submodule Transient314360
  11526 Node: Subtree316805
  11527 Node: Worktree318736
  11528 Node: Sparse checkouts319812
  11529 Node: Bundle322588
  11530 Node: Common Commands322963
  11531 Node: Wip Modes325591
  11532 Node: Wip Graph330482
  11533 Node: Legacy Wip Modes332795
  11534 Node: Commands for Buffers Visiting Files335682
  11535 Node: Minor Mode for Buffers Visiting Blobs343909
  11536 Node: Customizing344707
  11537 Node: Per-Repository Configuration346303
  11538 Node: Essential Settings348557
  11539 Node: Safety348903
  11540 Node: Performance350664
  11541 Ref: Log Performance353627
  11542 Ref: Diff Performance354932
  11543 Ref: Refs Buffer Performance356273
  11544 Ref: Committing Performance356848
  11545 Node: Microsoft Windows Performance357830
  11546 Node: MacOS Performance359021
  11547 Ref: MacOS Performance-Footnote-1360044
  11548 Node: Global Bindings360126
  11549 Node: Plumbing362354
  11550 Node: Calling Git363183
  11551 Node: Getting a Value from Git364708
  11552 Node: Calling Git for Effect368436
  11553 Node: Section Plumbing374330
  11554 Node: Creating Sections374558
  11555 Node: Section Selection378454
  11556 Node: Matching Sections380250
  11557 Node: Refreshing Buffers386171
  11558 Node: Conventions389315
  11559 Node: Theming Faces389507
  11560 Node: FAQ397612
  11561 Node: FAQ - How to ...?398050
  11562 Node: How to pronounce Magit?398407
  11563 Node: How to show git's output?399210
  11564 Node: How to install the gitman info manual?399996
  11565 Node: How to show diffs for gpg-encrypted files?400966
  11566 Node: How does branching and pushing work?401562
  11567 Node: Should I disable VC?401895
  11568 Node: FAQ - Issues and Errors402498
  11569 Node: Magit is slow403443
  11570 Node: I changed several thousand files at once and now Magit is unusable403736
  11571 Node: I am having problems committing404462
  11572 Node: I am using MS Windows and cannot push with Magit404943
  11573 Node: I am using macOS and SOMETHING works in shell but not in Magit405561
  11574 Node: Expanding a file to show the diff causes it to disappear406395
  11575 Node: Point is wrong in the COMMIT_EDITMSG buffer406983
  11576 Node: The mode-line information isn't always up-to-date408031
  11577 Node: A branch and tag sharing the same name breaks SOMETHING409094
  11578 Node: My Git hooks work on the command-line but not inside Magit409981
  11579 Node: git-commit-mode isn't used when committing from the command-line410827
  11580 Node: Point ends up inside invisible text when jumping to a file-visiting buffer413098
  11581 Node: I am no longer able to save popup defaults413947
  11582 Node: Debugging Tools414928
  11583 Node: Keystroke Index418102
  11584 Node: Function and Command Index459716
  11585 Node: Variable Index517917
  11586 
  11587 End Tag Table
  11588 
  11589 
  11590 Local Variables:
  11591 coding: utf-8
  11592 End: