about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-22676
1 files changed, 0 insertions, 2676 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2 b/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
deleted file mode 100644
index ef180cef00b4..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/magit-20180913.1247/magit.info-2
+++ /dev/null
@@ -1,2676 +0,0 @@
-This is magit.info, produced by makeinfo version 6.5 from magit.texi.
-
-     Copyright (C) 2015-2018 Jonas Bernoulli <jonas@bernoul.li>
-
-     You can redistribute this document and/or modify it under the terms
-     of the GNU General Public License as published by the Free Software
-     Foundation, either version 3 of the License, or (at your option)
-     any later version.
-
-     This document is distributed in the hope that it will be useful,
-     but WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-INFO-DIR-SECTION Emacs
-START-INFO-DIR-ENTRY
-* Magit: (magit).       Using Git from Emacs with Magit.
-END-INFO-DIR-ENTRY
-
-
-File: magit.info,  Node: Microsoft Windows Performance,  Next: MacOS Performance,  Up: Performance
-
-Microsoft Windows Performance
-.............................
-
-In order to update the status buffer, ‘git’ has to be run a few dozen
-times.  That is problematic on Microsoft Windows, because that operating
-system is exceptionally slow at starting processes.  Sadly this is an
-issue that can only be fixed by Microsoft itself, and they don’t appear
-to be particularly interested in doing so.
-
-   Beside the subprocess issue, there are also other Windows-specific
-performance issues.  Some of these have workarounds.  The maintainers of
-"Git for Windows" try to improve performance on Windows.  Always use the
-latest release in order to benefit from the latest performance tweaks.
-Magit too tries to work around some Windows-specific issues.
-
-   According to some sources, setting the following Git variables can
-also help.
-
-     git config --global core.preloadindex true   # default since v2.1
-     git config --global core.fscache true        # default since v2.8
-     git config --global gc.auto 256
-
-   You should also check whether an anti-virus program is affecting
-performance.
-
-
-File: magit.info,  Node: MacOS Performance,  Prev: Microsoft Windows Performance,  Up: Performance
-
-MacOS Performance
-.................
-
-On macOS Emacs currently creates child processes using ‘fork’.  It
-appears that this also copies GUI resources.  The result is that forking
-takes about 30 times as long on Darwin than on Linux.  And because Magit
-starts many ‘git’ processes even when doing simple things, that makes
-quite a difference.
-
-   On the ‘master’ branch Emacs now uses ‘vfork’ when possible, like
-this was already done on Linux, and now child creation only takes about
-twice as long on Darwin.  See (1) for more information.
-
-   Nobody knows when the changes on the ‘master’ branch will be released
-as ‘26.1’, but it is still a long way off.  You might want to get your
-hands on this change before then.  The easiest way to get a patched
-Emacs is to install the ‘emacs-plus’ formula (2) using ‘homebrew’.  The
-change has been backported, so you get it not only when using ‘--HEAD’,
-but also when using ‘--devel’ or when installing the latest release (by
-not using a version argument).
-
-   Alternatively you can apply the backport (3) manually.
-
-   ---------- Footnotes ----------
-
-   (1) 
-<https://lists.gnu.org/archive/html/bug-gnu-emacs/2017-04/msg00201.html>
-
-   (2) <https://github.com/d12frosted/homebrew-emacs-plus>
-
-   (3) 
-<https://gist.githubusercontent.com/aaronjensen/f45894ddf431ecbff78b1bcf533d3e6b/raw/6a5cd7f57341aba673234348d8b0d2e776f86719/Emacs-25-OS-X-use-vfork.patch>
-
-
-File: magit.info,  Node: Plumbing,  Next: FAQ,  Prev: Customizing,  Up: Top
-
-10 Plumbing
-***********
-
-The following sections describe how to use several of Magit’s core
-abstractions to extend Magit itself or implement a separate extension.
-
-   A few of the low-level features used by Magit have been factored out
-into separate libraries/packages, so that they can be used by other
-packages, without having to depend on Magit.  These libraries are
-described in separate manuals, see *note (with-editor)Top:: and *note
-(magit-popup)Top::.
-
-   If you are trying to find an unused key that you can bind to a
-command provided by your own Magit extension, then checkout
-<https://github.com/magit/magit/wiki/Plugin-Dispatch-Key-Registry>.
-
-* Menu:
-
-* Calling Git::
-* Section Plumbing::
-* Refreshing Buffers::
-* Conventions::
-
-
-File: magit.info,  Node: Calling Git,  Next: Section Plumbing,  Up: Plumbing
-
-10.1 Calling Git
-================
-
-Magit provides many specialized functions for calling Git.  All of these
-functions are defined in either ‘magit-git.el’ or ‘magit-process.el’ and
-have one of the prefixes ‘magit-run-’, ‘magit-call-’, ‘magit-start-’, or
-‘magit-git-’ (which is also used for other things).
-
-   All of these functions accept an indefinite number of arguments,
-which are strings that specify command line arguments for Git (or in
-some cases an arbitrary executable).  These arguments are flattened
-before being passed on to the executable; so instead of strings they can
-also be lists of strings and arguments that are ‘nil’ are silently
-dropped.  Some of these functions also require a single mandatory
-argument before these command line arguments.
-
-   Roughly speaking, these functions run Git either to get some value or
-for side-effects.  The functions that return a value are useful to
-collect the information necessary to populate a Magit buffer, while the
-others are used to implement Magit commands.
-
-   The functions in the value-only group always run synchronously, and
-they never trigger a refresh.  The function in the side-effect group can
-be further divided into subgroups depending on whether they run Git
-synchronously or asynchronously, and depending on whether they trigger a
-refresh when the executable has finished.
-
-* Menu:
-
-* Getting a Value from Git::
-* Calling Git for Effect::
-
-
-File: magit.info,  Node: Getting a Value from Git,  Next: Calling Git for Effect,  Up: Calling Git
-
-10.1.1 Getting a Value from Git
--------------------------------
-
-These functions run Git in order to get a value, an exit status, or
-output.  Of course you could also use them to run Git commands that have
-side-effects, but that should be avoided.
-
- -- Function: magit-git-exit-code &rest args
-
-     Executes git with ARGS and returns its exit code.
-
- -- Function: magit-git-success &rest args
-
-     Executes git with ARGS and returns ‘t’ if the exit code is ‘0’,
-     ‘nil’ otherwise.
-
- -- Function: magit-git-failure &rest args
-
-     Executes git with ARGS and returns ‘t’ if the exit code is ‘1’,
-     ‘nil’ otherwise.
-
- -- Function: magit-git-true &rest args
-
-     Executes git with ARGS and returns ‘t’ if the first line printed by
-     git is the string "true", ‘nil’ otherwise.
-
- -- Function: magit-git-false &rest args
-
-     Executes git with ARGS and returns ‘t’ if the first line printed by
-     git is the string "false", ‘nil’ otherwise.
-
- -- Function: magit-git-insert &rest args
-
-     Executes git with ARGS and inserts its output at point.
-
- -- Function: magit-git-string &rest args
-
-     Executes git with ARGS and returns the first line of its output.
-     If there is no output or if it begins with a newline character,
-     then this returns ‘nil’.
-
- -- Function: magit-git-lines &rest args
-
-     Executes git with ARGS and returns its output as a list of lines.
-     Empty lines anywhere in the output are omitted.
-
- -- Function: magit-git-items &rest args
-
-     Executes git with ARGS and returns its null-separated output as a
-     list.  Empty items anywhere in the output are omitted.
-
-     If the value of option ‘magit-git-debug’ is non-nil and git exits
-     with a non-zero exit status, then warn about that in the echo area
-     and add a section containing git’s standard error in the current
-     repository’s process buffer.
-
-   If an error occurs when using one of the above functions, then that
-is usually due to a bug, i.e.  using an argument which is not actually
-supported.  Such errors are usually not reported, but when they occur we
-need to be able to debug them.
-
- -- User Option: magit-git-debug
-
-     Whether to report errors that occur when using ‘magit-git-insert’,
-     ‘magit-git-string’, ‘magit-git-lines’, or ‘magit-git-items’.  This
-     does not actually raise an error.  Instead a message is shown in
-     the echo area, and git’s standard error is insert into a new
-     section in the current repository’s process buffer.
-
- -- Function: magit-git-str &rest args
-
-     This is a variant of ‘magit-git-string’ that ignores the option
-     ‘magit-git-debug’.  It is mainly intended to be used while handling
-     errors in functions that do respect that option.  Using such a
-     function while handing an error could cause yet another error and
-     therefore lead to an infinite recursion.  You probably won’t ever
-     need to use this function.
-
-
-File: magit.info,  Node: Calling Git for Effect,  Prev: Getting a Value from Git,  Up: Calling Git
-
-10.1.2 Calling Git for Effect
------------------------------
-
-These functions are used to run git to produce some effect.  Most Magit
-commands that actually run git do so by using such a function.
-
-   Because we do not need to consume git’s output when using these
-functions, their output is instead logged into a per-repository buffer,
-which can be shown using ‘$’ from a Magit buffer or ‘M-x magit-process’
-elsewhere.
-
-   These functions can have an effect in two distinct ways.  Firstly,
-running git may change something, i.e.  create or push a new commit.
-Secondly, that change may require that Magit buffers are refreshed to
-reflect the changed state of the repository.  But refreshing isn’t
-always desirable, so only some of these functions do perform such a
-refresh after git has returned.
-
-   Sometimes it is useful to run git asynchronously.  For example, when
-the user has just initiated a push, then there is no reason to make her
-wait until that has completed.  In other cases it makes sense to wait
-for git to complete before letting the user do something else.  For
-example after staging a change it is useful to wait until after the
-refresh because that also automatically moves to the next change.
-
- -- Function: magit-call-git &rest args
-
-     Calls git synchronously with ARGS.
-
- -- Function: magit-call-process program &rest args
-
-     Calls PROGRAM synchronously with ARGS.
-
- -- Function: magit-run-git &rest args
-
-     Calls git synchronously with ARGS and then refreshes.
-
- -- Function: magit-run-git-with-input input &rest args
-
-     Calls git synchronously with ARGS and sends it INPUT on standard
-     input.
-
-     INPUT should be a buffer or the name of an existing buffer.  The
-     content of that buffer is used as the process’ standard input.
-     After the process returns a refresh is performed.
-
-     As a special case, INPUT may also be nil.  In that case the content
-     of the current buffer is used as standard input and *no* refresh is
-     performed.
-
-     This function actually runs git asynchronously.  But then it waits
-     for the process to return, so the function itself is synchronous.
-
- -- Function: magit-run-git-with-logfile file &rest args
-
-     Calls git synchronously with ARGS.  The process’ output is saved in
-     FILE.  This is rarely useful and so this function might be removed
-     in the future.
-
-     This function actually runs git asynchronously.  But then it waits
-     for the process to return, so the function itself is synchronous.
-
- -- Function: magit-git &rest args
-
-     Calls git synchronously with ARGS for side-effects only.  This
-     function does not refresh the buffer.
-
- -- Function: magit-git-wash washer &rest args
-
-     Execute Git with ARGS, inserting washed output at point.  Actually
-     first insert the raw output at point.  If there is no output call
-     ‘magit-cancel-section’.  Otherwise temporarily narrow the buffer to
-     the inserted text, move to its beginning, and then call function
-     WASHER with ARGS as its sole argument.
-
-   And now for the asynchronous variants.
-
- -- Function: magit-run-git-async &rest args
-
-     Start Git, prepare for refresh, and return the process object.
-     ARGS is flattened and then used as arguments to Git.
-
-     Display the command line arguments in the echo area.
-
-     After Git returns some buffers are refreshed: the buffer that was
-     current when this function was called (if it is a Magit buffer and
-     still alive), as well as the respective Magit status buffer.
-     Unmodified buffers visiting files that are tracked in the current
-     repository are reverted if ‘magit-revert-buffers’ is non-nil.
-
- -- Function: magit-run-git-with-editor &rest args
-
-     Export GIT_EDITOR and start Git.  Also prepare for refresh and
-     return the process object.  ARGS is flattened and then used as
-     arguments to Git.
-
-     Display the command line arguments in the echo area.
-
-     After Git returns some buffers are refreshed: the buffer that was
-     current when this function was called (if it is a Magit buffer and
-     still alive), as well as the respective Magit status buffer.
-
- -- Function: magit-start-git &rest args
-
-     Start Git, prepare for refresh, and return the process object.
-
-     If INPUT is non-nil, it has to be a buffer or the name of an
-     existing buffer.  The buffer content becomes the processes standard
-     input.
-
-     Option ‘magit-git-executable’ specifies the Git executable and
-     option ‘magit-git-global-arguments’ specifies constant arguments.
-     The remaining arguments ARGS specify arguments to Git.  They are
-     flattened before use.
-
-     After Git returns, some buffers are refreshed: the buffer that was
-     current when this function was called (if it is a Magit buffer and
-     still alive), as well as the respective Magit status buffer.
-     Unmodified buffers visiting files that are tracked in the current
-     repository are reverted if ‘magit-revert-buffers’ is non-nil.
-
- -- Function: magit-start-process &rest args
-
-     Start PROGRAM, prepare for refresh, and return the process object.
-
-     If optional argument INPUT is non-nil, it has to be a buffer or the
-     name of an existing buffer.  The buffer content becomes the
-     processes standard input.
-
-     The process is started using ‘start-file-process’ and then setup to
-     use the sentinel ‘magit-process-sentinel’ and the filter
-     ‘magit-process-filter’.  Information required by these functions is
-     stored in the process object.  When this function returns the
-     process has not started to run yet so it is possible to override
-     the sentinel and filter.
-
-     After the process returns, ‘magit-process-sentinel’ refreshes the
-     buffer that was current when ‘magit-start-process’ was called (if
-     it is a Magit buffer and still alive), as well as the respective
-     Magit status buffer.  Unmodified buffers visiting files that are
-     tracked in the current repository are reverted if
-     ‘magit-revert-buffers’ is non-nil.
-
- -- Variable: magit-this-process
-
-     The child process which is about to start.  This can be used to
-     change the filter and sentinel.
-
- -- Variable: magit-process-raise-error
-
-     When this is non-nil, then ‘magit-process-sentinel’ raises an error
-     if git exits with a non-zero exit status.  For debugging purposes.
-
-
-File: magit.info,  Node: Section Plumbing,  Next: Refreshing Buffers,  Prev: Calling Git,  Up: Plumbing
-
-10.2 Section Plumbing
-=====================
-
-* Menu:
-
-* Creating Sections::
-* Section Selection::
-* Matching Sections::
-
-
-File: magit.info,  Node: Creating Sections,  Next: Section Selection,  Up: Section Plumbing
-
-10.2.1 Creating Sections
-------------------------
-
- -- Macro: magit-insert-section &rest args
-
-     Insert a section at point.
-
-     TYPE is the section type, a symbol.  Many commands that act on the
-     current section behave differently depending on that type.  Also if
-     a variable ‘magit-TYPE-section-map’ exists, then use that as the
-     text-property ‘keymap’ of all text belonging to the section (but
-     this may be overwritten in subsections).  TYPE can also have the
-     form ‘(eval FORM)’ in which case FORM is evaluated at runtime.
-
-     Optional VALUE is the value of the section, usually a string that
-     is required when acting on the section.
-
-     When optional HIDE is non-nil collapse the section body by default,
-     i.e.  when first creating the section, but not when refreshing the
-     buffer.  Otherwise, expand it by default.  This can be overwritten
-     using ‘magit-section-set-visibility-hook’.  When a section is
-     recreated during a refresh, then the visibility of predecessor is
-     inherited and HIDE is ignored (but the hook is still honored).
-
-     BODY is any number of forms that actually insert the section’s
-     heading and body.  Optional NAME, if specified, has to be a symbol,
-     which is then bound to the struct of the section being inserted.
-
-     Before BODY is evaluated the ‘start’ of the section object is set
-     to the value of ‘point’ and after BODY was evaluated its ‘end’ is
-     set to the new value of ‘point’; BODY is responsible for moving
-     ‘point’ forward.
-
-     If it turns out inside BODY that the section is empty, then
-     ‘magit-cancel-section’ can be used to abort and remove all traces
-     of the partially inserted section.  This can happen when creating a
-     section by washing Git’s output and Git didn’t actually output
-     anything this time around.
-
- -- Function: magit-insert-heading &rest args
-
-     Insert the heading for the section currently being inserted.
-
-     This function should only be used inside ‘magit-insert-section’.
-
-     When called without any arguments, then just set the ‘content’ slot
-     of the object representing the section being inserted to a marker
-     at ‘point’.  The section should only contain a single line when
-     this function is used like this.
-
-     When called with arguments ARGS, which have to be strings, then
-     insert those strings at point.  The section should not contain any
-     text before this happens and afterwards it should again only
-     contain a single line.  If the ‘face’ property is set anywhere
-     inside any of these strings, then insert all of them unchanged.
-     Otherwise use the ‘magit-section-heading’ face for all inserted
-     text.
-
-     The ‘content’ property of the section struct is the end of the
-     heading (which lasts from ‘start’ to ‘content’) and the beginning
-     of the body (which lasts from ‘content’ to ‘end’).  If the value of
-     ‘content’ is nil, then the section has no heading and its body
-     cannot be collapsed.  If a section does have a heading then its
-     height must be exactly one line, including a trailing newline
-     character.  This isn’t enforced; you are responsible for getting it
-     right.  The only exception is that this function does insert a
-     newline character if necessary.
-
- -- Function: magit-cancel-section
-
-     Cancel the section currently being inserted.  This exits the
-     innermost call to ‘magit-insert-section’ and removes all traces of
-     what has already happened inside that call.
-
- -- Function: magit-define-section-jumper sym title &optional value
-
-     Define an interactive function to go to section SYM.  TITLE is the
-     displayed title of the section.
-
-
-File: magit.info,  Node: Section Selection,  Next: Matching Sections,  Prev: Creating Sections,  Up: Section Plumbing
-
-10.2.2 Section Selection
-------------------------
-
- -- Function: magit-current-section
-
-     Return the section at point.
-
- -- Function: magit-region-sections
-
-     Return a list of the selected sections.
-
-     When the region is active and constitutes a valid section
-     selection, then return a list of all selected sections.  This is
-     the case when the region begins in the heading of a section and
-     ends in the heading of a sibling of that first section.  When the
-     selection is not valid then return nil.  Most commands that can act
-     on the selected sections, then instead just act on the current
-     section, the one point is in.
-
-     When the region looks like it would in any other buffer then the
-     selection is invalid.  When the selection is valid then the region
-     uses the ‘magit-section-highlight’.  This does not apply to diffs
-     where things get a bit more complicated, but even here if the
-     region looks like it usually does, then that’s not a valid
-     selection as far as this function is concerned.
-
- -- Function: magit-region-values &rest types
-
-     Return a list of the values of the selected sections.
-
-     Also see ‘magit-region-sections’ whose doc-string explains when a
-     region is a valid section selection.  If the region is not active
-     or is not a valid section selection, then return nil.  If optional
-     TYPES is non-nil then the selection not only has to be valid; the
-     types of all selected sections additionally have to match one of
-     TYPES, or nil is returned.
-
-
-File: magit.info,  Node: Matching Sections,  Prev: Section Selection,  Up: Section Plumbing
-
-10.2.3 Matching Sections
-------------------------
-
-‘M-x magit-describe-section-briefly’     (‘magit-describe-section-briefly’)
-
-     Show information about the section at point.  This command is
-     intended for debugging purposes.
-
- -- Function: magit-section-ident
-
-     Return an unique identifier for SECTION.  The return value has the
-     form ‘((TYPE . VALUE)...)’.
-
- -- Function: magit-get-section
-
-     Return the section identified by IDENT.  IDENT has to be a list as
-     returned by ‘magit-section-ident’.
-
- -- Function: magit-section-match condition &optional section
-
-     Return ‘t’ if SECTION matches CONDITION.  SECTION defaults to the
-     section at point.  If SECTION is not specified and there also is no
-     section at point, then return ‘nil’.
-
-     CONDITION can take the following forms:
-        • ‘(CONDITION...)’
-
-          matches if any of the CONDITIONs matches.
-
-        • ‘[TYPE...]’
-
-          matches if the first TYPE matches the type of the section, the
-          second matches that of its parent, and so on.
-
-        • ‘[* TYPE...]’
-
-          matches sections that match [TYPE...] and also recursively all
-          their child sections.
-
-        • ‘TYPE’
-
-          matches sections of TYPE regardless of the types of the parent
-          sections.
-
-     Each TYPE is a symbol.  Note that it is not necessary to specify
-     all TYPEs up to the root section as printed by
-     ‘magit-describe-type’, unless of course you want to be that
-     precise.
-
- -- Function: magit-section-when condition &rest body
-
-     If the section at point matches CONDITION evaluate BODY.
-
-     If the section matches, then evaluate BODY forms sequentially with
-     ‘it’ bound to the section and return the value of the last form.
-     If there are no BODY forms, then return the value of the section.
-     If the section does not match or if there is no section at point
-     then return nil.
-
-     See ‘magit-section-match’ for the forms CONDITION can take.
-
- -- Function: magit-section-case &rest clauses
-
-     Choose among clauses on the type of the section at point.
-
-     Each clause looks like (CONDITION BODY...).  The type of the
-     section is compared against each CONDITION; the BODY forms of the
-     first match are evaluated sequentially and the value of the last
-     form is returned.  Inside BODY the symbol ‘it’ is bound to the
-     section at point.  If no clause succeeds or if there is no section
-     at point return nil.
-
-     See ‘magit-section-match’ for the forms CONDITION can take.
-     Additionally a CONDITION of t is allowed in the final clause and
-     matches if no other CONDITION match, even if there is no section at
-     point.
-
- -- Variable: magit-root-section
-
-     The root section in the current buffer.  All other sections are
-     descendants of this section.  The value of this variable is set by
-     ‘magit-insert-section’ and you should never modify it.
-
-   For diff related sections a few additional tools exist.
-
- -- Function: magit-diff-type &optional section
-
-     Return the diff type of SECTION.
-
-     The returned type is one of the symbols ‘staged’, ‘unstaged’,
-     ‘committed’, or ‘undefined’.  This type serves a similar purpose as
-     the general type common to all sections (which is stored in the
-     ‘type’ slot of the corresponding ‘magit-section’ struct) but takes
-     additional information into account.  When the SECTION isn’t
-     related to diffs and the buffer containing it also isn’t a
-     diff-only buffer, then return nil.
-
-     Currently the type can also be one of ‘tracked’ and ‘untracked’,
-     but these values are not handled explicitly in every place they
-     should be.  A possible fix could be to just return nil here.
-
-     The section has to be a ‘diff’ or ‘hunk’ section, or a section
-     whose children are of type ‘diff’.  If optional SECTION is nil,
-     return the diff type for the current section.  In buffers whose
-     major mode is ‘magit-diff-mode’ SECTION is ignored and the type is
-     determined using other means.  In ‘magit-revision-mode’ buffers the
-     type is always ‘committed’.
-
- -- Function: magit-diff-scope &optional section strict
-
-     Return the diff scope of SECTION or the selected section(s).
-
-     A diff’s "scope" describes what part of a diff is selected, it is a
-     symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or
-     ‘list’.  Do not confuse this with the diff "type", as returned by
-     ‘magit-diff-type’.
-
-     If optional SECTION is non-nil, then return the scope of that,
-     ignoring the sections selected by the region.  Otherwise return the
-     scope of the current section, or if the region is active and
-     selects a valid group of diff related sections, the type of these
-     sections, i.e.  ‘hunks’ or ‘files’.  If SECTION (or if the current
-     section that is nil) is a ‘hunk’ section and the region starts and
-     ends inside the body of a that section, then the type is ‘region’.
-
-     If optional STRICT is non-nil then return nil if the diff type of
-     the section at point is ‘untracked’ or the section at point is not
-     actually a ‘diff’ but a ‘diffstat’ section.
-
-
-File: magit.info,  Node: Refreshing Buffers,  Next: Conventions,  Prev: Section Plumbing,  Up: Plumbing
-
-10.3 Refreshing Buffers
-=======================
-
-All commands that create a new Magit buffer or change what is being
-displayed in an existing buffer do so by calling ‘magit-mode-setup’.
-Among other things, that function sets the buffer local values of
-‘default-directory’ (to the top-level of the repository),
-‘magit-refresh-function’, and ‘magit-refresh-args’.
-
-   Buffers are refreshed by calling the function that is the local value
-of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’,
-where ‘*’ may be something like ‘diff’) with the value of
-‘magit-refresh-args’ as arguments.
-
- -- Macro: magit-mode-setup buffer switch-func mode refresh-func
-          &optional refresh-args
-
-     This function displays and selects BUFFER, turns on MODE, and
-     refreshes a first time.
-
-     This function displays and optionally selects BUFFER by calling
-     ‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as
-     arguments.  Then it sets the local value of
-     ‘magit-refresh-function’ to REFRESH-FUNC and that of
-     ‘magit-refresh-args’ to REFRESH-ARGS.  Finally it creates the
-     buffer content by calling REFRESH-FUNC with REFRESH-ARGS as
-     arguments.
-
-     All arguments are evaluated before switching to BUFFER.
-
- -- Function: magit-mode-display-buffer buffer mode &optional
-          switch-function
-
-     This function display BUFFER in some window and select it.  BUFFER
-     may be a buffer or a string, the name of a buffer.  The buffer is
-     returned.
-
-     Unless BUFFER is already displayed in the selected frame, store the
-     previous window configuration as a buffer local value, so that it
-     can later be restored by ‘magit-mode-bury-buffer’.
-
-     The buffer is displayed and selected using SWITCH-FUNCTION.  If
-     that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s
-     major mode derives from ‘magit-mode’.  Otherwise ‘switch-to-buffer’
-     is used.
-
- -- Variable: magit-refresh-function
-
-     The value of this buffer-local variable is the function used to
-     refresh the current buffer.  It is called with ‘magit-refresh-args’
-     as arguments.
-
- -- Variable: magit-refresh-args
-
-     The list of arguments used by ‘magit-refresh-function’ to refresh
-     the current buffer.  ‘magit-refresh-function’ is called with these
-     arguments.
-
-     The value is usually set using ‘magit-mode-setup’, but in some
-     cases it’s also useful to provide commands which can change the
-     value.  For example, the ‘magit-diff-refresh-popup’ can be used to
-     change any of the arguments used to display the diff, without
-     having to specify again which differences should be shown.
-     ‘magit-diff-more-context’, ‘magit-diff-less-context’, and
-     ‘magit-diff-default-context’ change just the ‘-U<N>’ argument.  In
-     both case this is done by changing the value of this variable and
-     then calling this ‘magit-refresh-function’.
-
-
-File: magit.info,  Node: Conventions,  Prev: Refreshing Buffers,  Up: Plumbing
-
-10.4 Conventions
-================
-
-Also see *note Completion and Confirmation::.
-
-* Menu:
-
-* Theming Faces::
-
-
-File: magit.info,  Node: Theming Faces,  Up: Conventions
-
-10.4.1 Theming Faces
---------------------
-
-The default theme uses blue for local branches, green for remote
-branches, and goldenrod (brownish yellow) for tags.  When creating a new
-theme, you should probably follow that example.  If your theme already
-uses other colors, then stick to that.
-
-   In older releases these reference faces used to have a background
-color and a box around them.  The basic default faces no longer do so,
-to make Magit buffers much less noisy, and you should follow that
-example at least with regards to boxes.  (Boxes were used in the past to
-work around a conflict between the highlighting overlay and text
-property backgrounds.  That’s no longer necessary because highlighting
-no longer causes other background colors to disappear.)  Alternatively
-you can keep the background color and/or box, but then have to take
-special care to adjust ‘magit-branch-current’ accordingly.  By default
-it looks mostly like ‘magit-branch-local’, but with a box (by default
-the former is the only face that uses a box, exactly so that it sticks
-out).  If the former also uses a box, then you have to make sure that it
-differs in some other way from the latter.
-
-   The most difficult faces to theme are those related to diffs,
-headings, highlighting, and the region.  There are faces that fall into
-all four groups - expect to spend some time getting this right.
-
-   The ‘region’ face in the default theme, in both the light and dark
-variants, as well as in many other themes, distributed with Emacs or by
-third-parties, is very ugly.  It is common to use a background color
-that really sticks out, which is ugly but if that were the only problem
-then it would be acceptable.  Unfortunately many themes also set the
-foreground color, which ensures that all text within the region is
-readable.  Without doing that there might be cases where some foreground
-color is too close to the region background color to still be readable.
-But it also means that text within the region loses all syntax
-highlighting.
-
-   I consider the work that went into getting the ‘region’ face right to
-be a good indicator for the general quality of a theme.  My
-recommendation for the ‘region’ face is this: use a background color
-slightly different from the background color of the ‘default’ face, and
-do not set the foreground color at all.  So for a light theme you might
-use a light (possibly tinted) gray as the background color of ‘default’
-and a somewhat darker gray for the background of ‘region’.  That should
-usually be enough to not collide with the foreground color of any other
-face.  But if some other faces also set a light gray as background
-color, then you should also make sure it doesn’t collide with those (in
-some cases it might be acceptable though).
-
-   Magit only uses the ‘region’ face when the region is "invalid" by its
-own definition.  In a Magit buffer the region is used to either select
-multiple sibling sections, so that commands which support it act on all
-of these sections instead of just the current section, or to select
-lines within a single hunk section.  In all other cases, the section is
-considered invalid and Magit won’t act on it.  But such invalid sections
-happen, either because the user has not moved point enough yet to make
-it valid or because she wants to use a non-magit command to act on the
-region, e.g.  ‘kill-region’.
-
-   So using the regular ‘region’ face for invalid sections is a feature.
-It tells the user that Magit won’t be able to act on it.  It’s
-acceptable if that face looks a bit odd and even (but less so) if it
-collides with the background colors of section headings and other things
-that have a background color.
-
-   Magit highlights the current section.  If a section has subsections,
-then all of them are highlighted.  This is done using faces that have
-"highlight" in their names.  For most sections,
-‘magit-section-highlight’ is used for both the body and the heading.
-Like the ‘region’ face, it should only set the background color to
-something similar to that of ‘default’.  The highlight background color
-must be different from both the ‘region’ background color and the
-‘default’ background color.
-
-   For diff related sections Magit uses various faces to highlight
-different parts of the selected section(s).  Note that hunk headings,
-unlike all other section headings, by default have a background color,
-because it is useful to have very visible separators between hunks.
-That face ‘magit-diff-hunk-heading’, should be different from both
-‘magit-diff-hunk-heading-highlight’ and ‘magit-section-highlight’, as
-well as from ‘magit-diff-context’ and ‘magit-diff-context-highlight’.
-By default we do that by changing the foreground color.  Changing the
-background color would lead to complications, and there are already
-enough we cannot get around.  (Also note that it is generally a good
-idea for section headings to always be bold, but only for sections that
-have subsections).
-
-   When there is a valid region selecting diff-related sibling sections,
-i.e.  multiple files or hunks, then the bodies of all these sections use
-the respective highlight faces, but additionally the headings instead
-use one of the faces ‘magit-diff-file-heading-selection’ or
-‘magit-diff-hunk-heading-selection’.  These faces have to be different
-from the regular highlight variants to provide explicit visual
-indication that the region is active.
-
-   When theming diff related faces, start by setting the option
-‘magit-diff-refine-hunk’ to ‘all’.  You might personally prefer to only
-refine the current hunk or not use hunk refinement at all, but some of
-the users of your theme want all hunks to be refined, so you have to
-cater to that.
-
-   (Also turn on ‘magit-diff-highlight-indentation’,
-‘magit-diff-highlight-trailing’, and ‘magit-diff-paint-whitespace’; and
-insert some whitespace errors into the code you use for testing.)
-
-   For e.g.  "added lines" you have to adjust three faces:
-‘magit-diff-added’, ‘magit-diff-added-highlight’, and
-‘smerge-refined-added’.  Make sure that the latter works well with both
-of the former, as well as ‘smerge-other’ and ‘diff-added’.  Then do the
-same for the removed lines, context lines, lines added by us, and lines
-added by them.  Also make sure the respective added, removed, and
-context faces use approximately the same saturation for both the
-highlighted and unhighlighted variants.  Also make sure the file and
-diff headings work nicely with context lines (e.g.  make them look
-different).  Line faces should set both the foreground and the
-background color.  For example, for added lines use two different
-greens.
-
-   It’s best if the foreground color of both the highlighted and the
-unhighlighted variants are the same, so you will need to have to find a
-color that works well on the highlight and unhighlighted background, the
-refine background, and the highlight context background.  When there is
-an hunk internal region, then the added- and removed-lines background
-color is used only within that region.  Outside the region the
-highlighted context background color is used.  This makes it easier to
-see what is being staged.  With an hunk internal region the hunk heading
-is shown using ‘magit-diff-hunk-heading-selection’, and so are the thin
-lines that are added around the lines that fall within the region.  The
-background color of that has to be distinct enough from the various
-other involved background colors.
-
-   Nobody said this would be easy.  If your theme restricts itself to a
-certain set of colors, then you should make an exception here.
-Otherwise it would be impossible to make the diffs look good in each and
-every variation.  Actually you might want to just stick to the default
-definitions for these faces.  You have been warned.  Also please note
-that if you do not get this right, this will in some cases look to users
-like bugs in Magit - so please do it right or not at all.
-
-
-File: magit.info,  Node: FAQ,  Next: Debugging Tools,  Prev: Plumbing,  Up: Top
-
-Appendix A FAQ
-**************
-
-The next two nodes lists frequently asked questions.  For a list of
-frequently *and recently* asked questions, i.e.  questions that haven’t
-made it into the manual yet, see
-<https://github.com/magit/magit/wiki/FAQ>.
-
-   Please also use the *note Debugging Tools::.
-
-* Menu:
-
-* FAQ - How to ...?::
-* FAQ - Issues and Errors::
-
-
-File: magit.info,  Node: FAQ - How to ...?,  Next: FAQ - Issues and Errors,  Up: FAQ
-
-A.1 FAQ - How to ...?
-=====================
-
-* Menu:
-
-* How to show git's output?::
-* How to install the gitman info manual?::
-* How to show diffs for gpg-encrypted files?::
-* How does branching and pushing work?::
-* Can Magit be used as ediff-version-control-package?::
-
-
-File: magit.info,  Node: How to show git's output?,  Next: How to install the gitman info manual?,  Up: FAQ - How to ...?
-
-A.1.1 How to show git’s output?
--------------------------------
-
-To show the output of recently run git commands, press ‘$’ (or, if that
-isn’t available, ‘M-x magit-process-buffer’).  This will show a buffer
-containing a section per git invocation; as always press ‘TAB’ to expand
-or collapse them.
-
-   By default, git’s output is only inserted into the process buffer if
-it is run for side-effects.  When the output is consumed in some way,
-also inserting it into the process buffer would be too expensive.  For
-debugging purposes, it’s possible to do so anyway by setting
-‘magit-git-debug’ to ‘t’.
-
-
-File: magit.info,  Node: How to install the gitman info manual?,  Next: How to show diffs for gpg-encrypted files?,  Prev: How to show git's output?,  Up: FAQ - How to ...?
-
-A.1.2 How to install the gitman info manual?
---------------------------------------------
-
-Git’s manpages can be exported as an info manual called ‘gitman’.
-Magit’s own info manual links to nodes in that manual instead of the
-actual manpages because Info doesn’t support linking to manpages.
-
-   Unfortunately some distributions do not install the ‘gitman’ manual
-by default and you will have to install a separate documentation package
-to get it.
-
-   Magit patches Info adding the ability to visit links to the ‘gitman’
-Info manual by instead viewing the respective manpage.  If you prefer
-that approach, then set the value of ‘magit-view-git-manual-method’ to
-one of the supported packages ‘man’ or ‘woman’, e.g.:
-
-     (setq magit-view-git-manual-method 'man)
-
-
-File: magit.info,  Node: How to show diffs for gpg-encrypted files?,  Next: How does branching and pushing work?,  Prev: How to install the gitman info manual?,  Up: FAQ - How to ...?
-
-A.1.3 How to show diffs for gpg-encrypted files?
-------------------------------------------------
-
-Git supports showing diffs for encrypted files, but has to be told to do
-so.  Since Magit just uses Git to get the diffs, configuring Git also
-affects the diffs displayed inside Magit.
-
-     git config --global diff.gpg.textconv "gpg --no-tty --decrypt"
-     echo "*.gpg filter=gpg diff=gpg" > .gitattributes
-
-
-File: magit.info,  Node: How does branching and pushing work?,  Next: Can Magit be used as ediff-version-control-package?,  Prev: How to show diffs for gpg-encrypted files?,  Up: FAQ - How to ...?
-
-A.1.4 How does branching and pushing work?
-------------------------------------------
-
-Please see *note Branching:: and
-<http://emacsair.me/2016/01/17/magit-2.4>
-
-
-File: magit.info,  Node: Can Magit be used as ediff-version-control-package?,  Prev: How does branching and pushing work?,  Up: FAQ - How to ...?
-
-A.1.5 Can Magit be used as ‘ediff-version-control-package’?
------------------------------------------------------------
-
-No, it cannot.  For that to work the functions ‘ediff-magit-internal’
-and ‘ediff-magit-merge-internal’ would have to be implemented, and they
-are not.  These two functions are only used by the three commands
-‘ediff-revision’, ‘ediff-merge-revisions-with-ancestor’, and
-‘ediff-merge-revisions’.
-
-   These commands only delegate the task of populating buffers with
-certain revisions to the "internal" functions.  The equally important
-task of determining which revisions are to be compared/merged is not
-delegated.  Instead this is done without any support whatsoever from the
-version control package/system - meaning that the user has to enter the
-revisions explicitly.  Instead of implementing ‘ediff-magit-internal’ we
-provide ‘magit-ediff-compare’, which handles both tasks like it is 2005.
-
-   The other commands ‘ediff-merge-revisions’ and
-‘ediff-merge-revisions-with-ancestor’ are normally not what you want
-when using a modern version control system like Git.  Instead of letting
-the user resolve only those conflicts which Git could not resolve on its
-own, they throw away all work done by Git and then expect the user to
-manually merge all conflicts, including those that had already been
-resolved.  That made sense back in the days when version control systems
-couldn’t merge (or so I have been told), but not anymore.  Once in a
-blue moon you might actually want to see all conflicts, in which case
-you *can* use these commands, which then use ‘ediff-vc-merge-internal’.
-So we don’t actually have to implement ‘ediff-magit-merge-internal’.
-Instead we provide the more useful command ‘magit-ediff-resolve’ which
-only shows yet-to-be resolved conflicts.
-
-
-File: magit.info,  Node: FAQ - Issues and Errors,  Prev: FAQ - How to ...?,  Up: FAQ
-
-A.2 FAQ - Issues and Errors
-===========================
-
-* Menu:
-
-* Magit is slow::
-* I changed several thousand files at once and now Magit is unusable::
-* I am having problems committing::
-* I am using MS Windows and cannot push with Magit::
-* I am using OS X and SOMETHING works in shell, but not in Magit: I am using OS X and SOMETHING works in shell but not in Magit.
-* Diffs contain control sequences::
-* Expanding a file to show the diff causes it to disappear::
-* Point is wrong in the COMMIT_EDITMSG buffer::
-* The mode-line information isn't always up-to-date::
-* A branch and tag sharing the same name breaks SOMETHING::
-* My Git hooks work on the command-line but not inside Magit::
-* git-commit-mode isn't used when committing from the command-line::
-* Point ends up inside invisible text when jumping to a file-visiting buffer::
-
-
-File: magit.info,  Node: Magit is slow,  Next: I changed several thousand files at once and now Magit is unusable,  Up: FAQ - Issues and Errors
-
-A.2.1 Magit is slow
--------------------
-
-See *note Performance::.
-
-
-File: magit.info,  Node: I changed several thousand files at once and now Magit is unusable,  Next: I am having problems committing,  Prev: Magit is slow,  Up: FAQ - Issues and Errors
-
-A.2.2 I changed several thousand files at once and now Magit is unusable
-------------------------------------------------------------------------
-
-Magit is *currently* not expected to work under such conditions.  It
-sure would be nice if it did, and v2.5 will hopefully be a big step into
-that direction.  But it might take until v3.1 to accomplish fully
-satisfactory performance, because that requires some heavy refactoring.
-
-   But for now we recommend you use the command line to complete this
-one commit.  Also see *note Performance::.
-
-
-File: magit.info,  Node: I am having problems committing,  Next: I am using MS Windows and cannot push with Magit,  Prev: I changed several thousand files at once and now Magit is unusable,  Up: FAQ - Issues and Errors
-
-A.2.3 I am having problems committing
--------------------------------------
-
-That likely means that Magit is having problems finding an appropriate
-emacsclient executable.  See *note (with-editor)Configuring
-With-Editor:: and *note (with-editor)Debugging::.
-
-
-File: magit.info,  Node: I am using MS Windows and cannot push with Magit,  Next: I am using OS X and SOMETHING works in shell but not in Magit,  Prev: I am having problems committing,  Up: FAQ - Issues and Errors
-
-A.2.4 I am using MS Windows and cannot push with Magit
-------------------------------------------------------
-
-It’s almost certain that Magit is only incidental to this issue.  It is
-much more likely that this is a configuration issue, even if you can
-push on the command line.
-
-   Detailed setup instructions can be found at
-<https://github.com/magit/magit/wiki/Pushing-with-Magit-from-Windows>.
-
-
-File: magit.info,  Node: I am using OS X and SOMETHING works in shell but not in Magit,  Next: Diffs contain control sequences,  Prev: I am using MS Windows and cannot push with Magit,  Up: FAQ - Issues and Errors
-
-A.2.5 I am using OS X and SOMETHING works in shell, but not in Magit
---------------------------------------------------------------------
-
-This usually occurs because Emacs doesn’t have the same environment
-variables as your shell.  Try installing and configuring
-<https://github.com/purcell/exec-path-from-shell>.  By default it
-synchronizes ‘$PATH’, which helps Magit find the same ‘git’ as the one
-you are using on the shell.
-
-   If SOMETHING is "passphrase caching with gpg-agent for commit and/or
-tag signing", then you’ll also need to synchronize ‘$GPG_AGENT_INFO’.
-
-
-File: magit.info,  Node: Diffs contain control sequences,  Next: Expanding a file to show the diff causes it to disappear,  Prev: I am using OS X and SOMETHING works in shell but not in Magit,  Up: FAQ - Issues and Errors
-
-A.2.6 Diffs contain control sequences
--------------------------------------
-
-This happens when you configure Git to always color diffs and/or all of
-its output.  The valid values for relevant Git variables ‘color.ui’ and
-‘color.diff’ are ‘false’, ‘true’ and ‘always’, and the default is
-‘true’.  You should leave it that way because then you get colorful
-output in terminals by default but when git’s output is consumed by
-something else, then no color control sequences are used.
-
-   If you actually use some other tool that requires setting ‘color.ui’
-and/or ‘color.diff’ to ‘always’ (which is highly unlikely), then you can
-override these settings just for Magit by using:
-
-     (setq magit-git-global-arguments
-           (nconc magit-git-global-arguments
-                  '("-c" "color.ui=false"
-                    "-c" "color.diff=false")))
-
-
-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: Diffs contain control sequences,  Up: FAQ - Issues and Errors
-
-A.2.7 Expanding a file to show the diff causes it to disappear
---------------------------------------------------------------
-
-This is probably caused by a change of a ‘diff.*’ Git variable.  You
-probably set that variable for a reason, and should therefore only undo
-that setting in Magit by customizing ‘magit-git-global-arguments’.
-
-
-File: magit.info,  Node: Point is wrong in the COMMIT_EDITMSG buffer,  Next: The mode-line information isn't always up-to-date,  Prev: Expanding a file to show the diff causes it to disappear,  Up: FAQ - Issues and Errors
-
-A.2.8 Point is wrong in the ‘COMMIT_EDITMSG’ buffer
----------------------------------------------------
-
-Neither Magit nor ‘git-commit‘ fiddle with point in the buffer used to
-write commit messages, so something else must be doing it.
-
-   You have probably globally enabled a mode which does restore point in
-file-visiting buffers.  It might be a bit surprising, but when you write
-a commit message, then you are actually editing a file.
-
-   So you have to figure out which package is doing.  ‘saveplace’,
-‘pointback’, and ‘session’ are likely candidates.  These snippets might
-help:
-
-     (setq session-name-disable-regexp "\\(?:\\`'\\.git/[A-Z_]+\\'\\)")
-
-     (with-eval-after-load 'pointback
-       (lambda ()
-         (when (or git-commit-mode git-rebase-mode)
-           (pointback-mode -1))))
-
-
-File: magit.info,  Node: The mode-line information isn't always up-to-date,  Next: A branch and tag sharing the same name breaks SOMETHING,  Prev: Point is wrong in the COMMIT_EDITMSG buffer,  Up: FAQ - Issues and Errors
-
-A.2.9 The mode-line information isn’t always up-to-date
--------------------------------------------------------
-
-Magit is not responsible for the version control information that is
-being displayed in the mode-line and looks something like ‘Git-master’.
-The built-in "Version Control" package, also known as "VC", updates that
-information, and can be told to do so more often:
-
-     (setq auto-revert-check-vc-info t)
-
-   But doing so isn’t good for performance.  For more (overly
-optimistic) information see *note (emacs)VC Mode Line::.
-
-   If you don’t really care about seeing that information in the
-mode-line, but just don’t want to see _incorrect_ information, then
-consider disabling VC when using Git:
-
-     (setq vc-handled-backends (delq 'Git vc-handled-backends))
-
-   Or to disable it completely:
-
-     (setq vc-handled-backends nil)
-
-
-File: magit.info,  Node: A branch and tag sharing the same name breaks SOMETHING,  Next: My Git hooks work on the command-line but not inside Magit,  Prev: The mode-line information isn't always up-to-date,  Up: FAQ - Issues and Errors
-
-A.2.10 A branch and tag sharing the same name breaks SOMETHING
---------------------------------------------------------------
-
-Or more generally, ambiguous refnames break SOMETHING.
-
-   Magit assumes that refs are named non-ambiguously across the
-"refs/heads/", "refs/tags/", and "refs/remotes/" namespaces (i.e., all
-the names remain unique when those prefixes are stripped).  We consider
-ambiguous refnames unsupported and recommend that you use a
-non-ambiguous naming scheme.  However, if you do work with a repository
-that has ambiguous refnames, please report any issues you encounter so
-that we can investigate whether there is a simple fix.
-
-
-File: magit.info,  Node: My Git hooks work on the command-line but not inside Magit,  Next: git-commit-mode isn't used when committing from the command-line,  Prev: A branch and tag sharing the same name breaks SOMETHING,  Up: FAQ - Issues and Errors
-
-A.2.11 My Git hooks work on the command-line but not inside Magit
------------------------------------------------------------------
-
-When Magit calls ‘git’ it adds a few global arguments including
-‘--literal-pathspecs’ and the ‘git’ process started by Magit then passes
-that setting on to other ‘git’ process it starts itself.  It does so by
-setting the environment variable ‘GIT_LITERAL_PATHSPECS’, not by calling
-subprocesses with the ‘--literal-pathspecs’.  You can therefore override
-this setting in hook scripts using ‘unset GIT_LITERAL_PATHSPECS’.
-
-
-File: magit.info,  Node: git-commit-mode isn't used when committing from the command-line,  Next: Point ends up inside invisible text when jumping to a file-visiting buffer,  Prev: My Git hooks work on the command-line but not inside Magit,  Up: FAQ - Issues and Errors
-
-A.2.12 ‘git-commit-mode’ isn’t used when committing from the command-line
--------------------------------------------------------------------------
-
-The reason for this is that ‘git-commit.el’ has not been loaded yet
-and/or that the server has not been started yet.  These things have
-always already been taken care of when you commit from Magit because in
-order to do so, Magit has to be loaded and doing that involves loading
-‘git-commit’ and starting the server.
-
-   If you want to commit from the command-line, then you have to take
-care of these things yourself.  Your ‘init.el’ file should contain:
-
-     (require 'git-commit)
-     (server-mode)
-
-   Instead of ‘(require ’git-commit)‘ you may also use:
-
-     (load "/path/to/magit-autoloads.el")
-
-   You might want to do that because loading ‘git-commit’ causes large
-parts of Magit to be loaded.
-
-   There are also some variations of ‘(server-mode)’ that you might want
-to try.  Personally I use:
-
-     (use-package server
-       :config (or (server-running-p) (server-mode)))
-
-   Now you can use:
-
-     $ emacs&
-     $ EDITOR=emacsclient git commit
-
-   However you cannot use:
-
-     $ killall emacs
-     $ EDITOR="emacsclient --alternate-editor emacs" git commit
-
-   This will actually end up using ‘emacs’, not ‘emacsclient’.  If you
-do this, then can still edit the commit message but ‘git-commit-mode’
-won’t be used and you have to exit ‘emacs’ to finish the process.
-
-   Tautology ahead.  If you want to be able to use ‘emacsclient’ to
-connect to a running ‘emacs’ instance, even though no ‘emacs’ instance
-is running, then you cannot use ‘emacsclient’ directly.
-
-   Instead you have to create a script that does something like this:
-
-   Try to use ‘emacsclient’ (without using ‘--alternate-editor’).  If
-that succeeds, do nothing else.  Otherwise start ‘emacs &’ (and
-‘init.el’ must call ‘server-start’) and try to use ‘emacsclient’ again.
-
-
-File: magit.info,  Node: Point ends up inside invisible text when jumping to a file-visiting buffer,  Prev: git-commit-mode isn't used when committing from the command-line,  Up: FAQ - Issues and Errors
-
-A.2.13 Point ends up inside invisible text when jumping to a file-visiting buffer
----------------------------------------------------------------------------------
-
-This can happen when you type ‘RET’ on a hunk to visit the respective
-file at the respective position.  One solution to this problem is to use
-‘global-reveal-mode’.  It makes sure that text around point is always
-visible.  If that is too drastic for your taste, then you may instead
-use ‘magit-diff-visit-file-hook’ to reveal the text, possibly using
-‘reveal-post-command’ or for Org buffers ‘org-reveal’.
-
-
-File: magit.info,  Node: Debugging Tools,  Next: Keystroke Index,  Prev: FAQ,  Up: Top
-
-B Debugging Tools
-*****************
-
-Magit and its dependencies provide a few debugging tools, and we
-appreciate it very much if you use those tools before reporting an
-issue.  Please include all relevant output when reporting an issue.
-
-‘M-x magit-version’     (‘magit-version’)
-
-     This command shows the currently used versions of Magit, Git, and
-     Emacs in the echo area.  Non-interactively this just returns the
-     Magit version.
-
-‘M-x magit-emacs-Q-command’     (‘magit-emacs-Q-command’)
-
-     This command shows a debugging shell command in the echo area and
-     adds it to the kill ring.  Paste that command into a shell and run
-     it.
-
-     This shell command starts ‘emacs’ with only ‘magit’ and its
-     dependencies loaded.  Neither your configuration nor other
-     installed packages are loaded.  This makes it easier to determine
-     whether some issue lays with Magit or something else.
-
-     If you run Magit from its Git repository, then you should be able
-     to use ‘make emacs-Q’ instead of the output of this command.
-
-‘M-x magit-debug-git-executable’     (‘magit-debug-git-executable’)
-
-     This command displays a buffer containing information about the
-     available and used ‘git’ executable(s), and can be useful when
-     investigating ‘exec-path’ issues.
-
-     Also see *note Git Executable::.
-
-‘M-x with-editor-debug’     (‘with-editor-debug’)
-
-     This command displays a buffer containing information about the
-     available and used ‘~emacsclient’ executable(s), and can be useful
-     when investigating why Magit (or rather ‘with-editor’) cannot find
-     an appropriate ‘emacsclient’ executable.
-
-     Also see *note (with-editor)Debugging::.
-
-   Please also see the *note FAQ::.
-
-
-File: magit.info,  Node: Keystroke Index,  Next: Command Index,  Prev: Debugging Tools,  Up: Top
-
-Appendix C Keystroke Index
-**************************
-
-
-* Menu:
-
-* !:                                     Running Git Manually.
-                                                              (line  12)
-* ! !:                                   Running Git Manually.
-                                                              (line  16)
-* ! a:                                   Running Git Manually.
-                                                              (line  57)
-* ! b:                                   Running Git Manually.
-                                                              (line  61)
-* ! g:                                   Running Git Manually.
-                                                              (line  65)
-* ! k:                                   Running Git Manually.
-                                                              (line  53)
-* ! p:                                   Running Git Manually.
-                                                              (line  24)
-* ! s:                                   Running Git Manually.
-                                                              (line  34)
-* ! S:                                   Running Git Manually.
-                                                              (line  39)
-* $:                                     Viewing Git Output.  (line  16)
-* %:                                     Worktree.            (line   8)
-* % b:                                   Worktree.            (line  13)
-* % c:                                   Worktree.            (line  17)
-* % g:                                   Worktree.            (line  33)
-* % k:                                   Worktree.            (line  28)
-* % p:                                   Worktree.            (line  21)
-* +:                                     Log Buffer.          (line  59)
-* + <1>:                                 Refreshing Diffs.    (line  68)
-* -:                                     Log Buffer.          (line  63)
-* - <1>:                                 Refreshing Diffs.    (line  64)
-* 0:                                     Refreshing Diffs.    (line  72)
-* 1:                                     Section Visibility.  (line  26)
-* 2:                                     Section Visibility.  (line  27)
-* 3:                                     Section Visibility.  (line  28)
-* 4:                                     Section Visibility.  (line  29)
-* =:                                     Log Buffer.          (line  53)
-* ^:                                     Section Movement.    (line  31)
-* a:                                     Applying.            (line  33)
-* A:                                     Cherry Picking.      (line   8)
-* A A:                                   Cherry Picking.      (line  16)
-* A a:                                   Cherry Picking.      (line  23)
-* A A <1>:                               Cherry Picking.      (line  89)
-* A a <1>:                               Cherry Picking.      (line  97)
-* A d:                                   Cherry Picking.      (line  53)
-* A h:                                   Cherry Picking.      (line  41)
-* A n:                                   Cherry Picking.      (line  64)
-* A s:                                   Cherry Picking.      (line  75)
-* A s <1>:                               Cherry Picking.      (line  93)
-* B:                                     Bisecting.           (line   8)
-* b:                                     Blaming.             (line  86)
-* b <1>:                                 The Branch Popup.    (line  12)
-* B B:                                   Bisecting.           (line  16)
-* B b:                                   Bisecting.           (line  31)
-* b b:                                   The Branch Popup.    (line  37)
-* b C:                                   The Branch Popup.    (line  29)
-* b c:                                   The Branch Popup.    (line  55)
-* B g:                                   Bisecting.           (line  36)
-* B k:                                   Bisecting.           (line  41)
-* b k:                                   The Branch Popup.    (line 240)
-* b l:                                   The Branch Popup.    (line  62)
-* b n:                                   The Branch Popup.    (line  45)
-* B r:                                   Bisecting.           (line  47)
-* b r:                                   The Branch Popup.    (line 246)
-* B s:                                   Bisecting.           (line  24)
-* b s:                                   The Branch Popup.    (line  85)
-* b x:                                   The Branch Popup.    (line 224)
-* b Y:                                   The Branch Popup.    (line 113)
-* b y:                                   The Branch Popup.    (line 218)
-* c:                                     Blaming.             (line 120)
-* c <1>:                                 Initiating a Commit. (line   8)
-* c <2>:                                 Editing Rebase Sequences.
-                                                              (line  72)
-* c a:                                   Initiating a Commit. (line  18)
-* c A:                                   Initiating a Commit. (line  66)
-* c c:                                   Initiating a Commit. (line  13)
-* c e:                                   Initiating a Commit. (line  22)
-* c f:                                   Initiating a Commit. (line  42)
-* c F:                                   Initiating a Commit. (line  50)
-* c s:                                   Initiating a Commit. (line  54)
-* c S:                                   Initiating a Commit. (line  62)
-* c w:                                   Initiating a Commit. (line  32)
-* C-<return>:                            Diff Buffer.         (line  48)
-* C-<tab>:                               Section Visibility.  (line  13)
-* C-c C-a:                               Editing Commit Messages.
-                                                              (line 128)
-* C-c C-b:                               Log Buffer.          (line  19)
-* C-c C-b <1>:                           Refreshing Diffs.    (line  90)
-* C-c C-c:                               Popup Buffers and Prefix Commands.
-                                                              (line  20)
-* C-c C-c <1>:                           Select from Log.     (line  20)
-* C-c C-c <2>:                           Editing Commit Messages.
-                                                              (line  19)
-* C-c C-c <3>:                           Editing Rebase Sequences.
-                                                              (line   6)
-* C-c C-d:                               Refreshing Diffs.    (line  80)
-* C-c C-d <1>:                           Editing Commit Messages.
-                                                              (line  57)
-* C-c C-e:                               Diff Buffer.         (line  74)
-* C-c C-f:                               Log Buffer.          (line  23)
-* C-c C-f <1>:                           Refreshing Diffs.    (line  94)
-* C-c C-i:                               Editing Commit Messages.
-                                                              (line 153)
-* C-c C-k:                               Select from Log.     (line  26)
-* C-c C-k <1>:                           Editing Commit Messages.
-                                                              (line  24)
-* C-c C-k <2>:                           Editing Rebase Sequences.
-                                                              (line  11)
-* C-c C-n:                               Log Buffer.          (line  27)
-* C-c C-o:                               Editing Commit Messages.
-                                                              (line 144)
-* C-c C-p:                               Editing Commit Messages.
-                                                              (line 148)
-* C-c C-r:                               Editing Commit Messages.
-                                                              (line 132)
-* C-c C-s:                               Editing Commit Messages.
-                                                              (line 136)
-* C-c C-t:                               Diff Buffer.         (line  70)
-* C-c C-t <1>:                           Editing Commit Messages.
-                                                              (line 140)
-* C-c C-w:                               Editing Commit Messages.
-                                                              (line  63)
-* C-c M-g:                               Minor Mode for Buffers Visiting Files.
-                                                              (line  19)
-* C-c M-g B:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  80)
-* C-c M-g b:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  86)
-* C-c M-g c:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  33)
-* C-c M-g D:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  39)
-* C-c M-g d:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  47)
-* C-c M-g e:                             Minor Mode for Buffers Visiting Files.
-                                                              (line 102)
-* C-c M-g f:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  96)
-* C-c M-g L:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  57)
-* C-c M-g l:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  64)
-* C-c M-g p:                             Minor Mode for Buffers Visiting Files.
-                                                              (line 112)
-* C-c M-g r:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  91)
-* C-c M-g s:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  24)
-* C-c M-g t:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  71)
-* C-c M-g u:                             Minor Mode for Buffers Visiting Files.
-                                                              (line  28)
-* C-c M-s:                               Editing Commit Messages.
-                                                              (line  35)
-* C-w:                                   Common Commands.     (line  21)
-* C-x g:                                 Status Buffer.       (line  22)
-* C-x u:                                 Editing Rebase Sequences.
-                                                              (line  89)
-* d:                                     Diffing.             (line  20)
-* D:                                     Refreshing Diffs.    (line  11)
-* d c:                                   Diffing.             (line  67)
-* d d:                                   Diffing.             (line  25)
-* D f:                                   Refreshing Diffs.    (line  45)
-* D F:                                   Refreshing Diffs.    (line  50)
-* D g:                                   Refreshing Diffs.    (line  16)
-* d p:                                   Diffing.             (line  59)
-* d r:                                   Diffing.             (line  29)
-* D r:                                   Refreshing Diffs.    (line  40)
-* d s:                                   Diffing.             (line  49)
-* D s:                                   Refreshing Diffs.    (line  21)
-* d t:                                   Diffing.             (line  72)
-* D t:                                   Refreshing Diffs.    (line  36)
-* d u:                                   Diffing.             (line  55)
-* d w:                                   Diffing.             (line  43)
-* D w:                                   Refreshing Diffs.    (line  28)
-* DEL:                                   Log Buffer.          (line  43)
-* DEL <1>:                               Diff Buffer.         (line 103)
-* DEL <2>:                               Blaming.             (line  73)
-* DEL <3>:                               Editing Rebase Sequences.
-                                                              (line  28)
-* e:                                     Ediffing.            (line   9)
-* E:                                     Ediffing.            (line  21)
-* e <1>:                                 Editing Rebase Sequences.
-                                                              (line  55)
-* E c:                                   Ediffing.            (line  65)
-* E i:                                   Ediffing.            (line  57)
-* E m:                                   Ediffing.            (line  35)
-* E r:                                   Ediffing.            (line  26)
-* E s:                                   Ediffing.            (line  48)
-* E u:                                   Ediffing.            (line  53)
-* E w:                                   Ediffing.            (line  61)
-* E z:                                   Ediffing.            (line  69)
-* f:                                     Editing Rebase Sequences.
-                                                              (line  63)
-* f <1>:                                 Fetching.            (line  11)
-* F:                                     Pulling.             (line  11)
-* f a:                                   Fetching.            (line  38)
-* f e:                                   Fetching.            (line  24)
-* F e:                                   Pulling.             (line  24)
-* f m:                                   Fetching.            (line  42)
-* f o:                                   Fetching.            (line  28)
-* f p:                                   Fetching.            (line  16)
-* F p:                                   Pulling.             (line  16)
-* f r:                                   Fetching.            (line  33)
-* f u:                                   Fetching.            (line  20)
-* F u:                                   Pulling.             (line  20)
-* g:                                     Automatic Refreshing of Magit Buffers.
-                                                              (line  22)
-* G:                                     Automatic Refreshing of Magit Buffers.
-                                                              (line  31)
-* j:                                     Diff Buffer.         (line  93)
-* k:                                     Viewing Git Output.  (line  24)
-* k <1>:                                 Applying.            (line  40)
-* k <2>:                                 Editing Rebase Sequences.
-                                                              (line  68)
-* k <3>:                                 Stashing.            (line  95)
-* l:                                     Logging.             (line  28)
-* L:                                     Refreshing Logs.     (line  11)
-* L <1>:                                 Log Buffer.          (line   6)
-* L <2>:                                 Log Margin.          (line  47)
-* l a:                                   Logging.             (line  58)
-* l b:                                   Logging.             (line  54)
-* L d:                                   Log Margin.          (line  64)
-* L g:                                   Refreshing Logs.     (line  16)
-* l h:                                   Logging.             (line  46)
-* l H:                                   Reflog.              (line  19)
-* l l:                                   Logging.             (line  33)
-* l L:                                   Logging.             (line  50)
-* L L:                                   Log Margin.          (line  56)
-* L l:                                   Log Margin.          (line  60)
-* l o:                                   Logging.             (line  39)
-* l O:                                   Reflog.              (line  15)
-* l r:                                   Reflog.              (line  11)
-* L s:                                   Refreshing Logs.     (line  21)
-* L t:                                   Refreshing Logs.     (line  36)
-* L w:                                   Refreshing Logs.     (line  28)
-* m:                                     Merging.             (line   9)
-* M:                                     The Remote Popup.    (line  13)
-* m a:                                   Merging.             (line  44)
-* m a <1>:                               Merging.             (line  94)
-* M a:                                   The Remote Popup.    (line  35)
-* M C:                                   The Remote Popup.    (line  26)
-* m e:                                   Merging.             (line  30)
-* m i:                                   Merging.             (line  57)
-* M k:                                   The Remote Popup.    (line  50)
-* m m:                                   Merging.             (line  17)
-* m m <1>:                               Merging.             (line  88)
-* m n:                                   Merging.             (line  37)
-* m p:                                   Merging.             (line  80)
-* M p:                                   The Remote Popup.    (line  54)
-* M P:                                   The Remote Popup.    (line  59)
-* M r:                                   The Remote Popup.    (line  40)
-* m s:                                   Merging.             (line  71)
-* M u:                                   The Remote Popup.    (line  45)
-* M-1:                                   Section Visibility.  (line  33)
-* M-2:                                   Section Visibility.  (line  34)
-* M-3:                                   Section Visibility.  (line  35)
-* M-4:                                   Section Visibility.  (line  36)
-* M-<tab>:                               Section Visibility.  (line  17)
-* M-n:                                   Section Movement.    (line  26)
-* M-n <1>:                               Editing Commit Messages.
-                                                              (line  45)
-* M-n <2>:                               Editing Rebase Sequences.
-                                                              (line  47)
-* M-p:                                   Section Movement.    (line  20)
-* M-p <1>:                               Editing Commit Messages.
-                                                              (line  39)
-* M-p <2>:                               Editing Rebase Sequences.
-                                                              (line  43)
-* M-w:                                   Blaming.             (line 112)
-* M-w <1>:                               Common Commands.     (line  10)
-* M-x magit-clone:                       Repository Setup.    (line  16)
-* M-x magit-debug-git-executable:        Git Executable.      (line  45)
-* M-x magit-debug-git-executable <1>:    Debugging Tools.     (line  30)
-* M-x magit-describe-section-briefly:    Section Types and Values.
-                                                              (line  13)
-* M-x magit-describe-section-briefly <1>: Matching Sections.  (line   6)
-* M-x magit-emacs-Q-command:             Debugging Tools.     (line  16)
-* M-x magit-find-file:                   Visiting Blobs.      (line   6)
-* M-x magit-find-file-other-window:      Visiting Blobs.      (line  11)
-* M-x magit-init:                        Repository Setup.    (line   6)
-* M-x magit-reset-index:                 Staging and Unstaging.
-                                                              (line  87)
-* M-x magit-reverse-in-index:            Staging and Unstaging.
-                                                              (line  62)
-* M-x magit-stage-file:                  Staging from File-Visiting Buffers.
-                                                              (line  10)
-* M-x magit-toggle-buffer-lock:          Modes and Buffers.   (line  17)
-* M-x magit-unstage-file:                Staging from File-Visiting Buffers.
-                                                              (line  18)
-* M-x magit-version:                     Git Executable.      (line  17)
-* M-x magit-version <1>:                 Debugging Tools.     (line  10)
-* M-x magit-wip-commit:                  Wip Modes.           (line 174)
-* M-x with-editor-debug:                 Debugging Tools.     (line  38)
-* n:                                     Section Movement.    (line  16)
-* n <1>:                                 Blaming.             (line  91)
-* N:                                     Blaming.             (line  95)
-* n <2>:                                 Editing Rebase Sequences.
-                                                              (line  39)
-* n <3>:                                 Minor Mode for Buffers Visiting Blobs.
-                                                              (line  16)
-* o:                                     Submodule Popup.     (line   6)
-* O:                                     Subtree.             (line   8)
-* o a:                                   Submodule Popup.     (line  19)
-* O a:                                   Subtree.             (line  20)
-* O c:                                   Subtree.             (line  24)
-* o d:                                   Submodule Popup.     (line  49)
-* o f:                                   Submodule Popup.     (line  57)
-* O f:                                   Subtree.             (line  32)
-* o l:                                   Submodule Popup.     (line  53)
-* O m:                                   Subtree.             (line  28)
-* o p:                                   Submodule Popup.     (line  33)
-* O p:                                   Subtree.             (line  36)
-* o r:                                   Submodule Popup.     (line  26)
-* o s:                                   Submodule Popup.     (line  43)
-* O s:                                   Subtree.             (line  41)
-* o u:                                   Submodule Popup.     (line  38)
-* p:                                     Section Movement.    (line  10)
-* p <1>:                                 Blaming.             (line  99)
-* P:                                     Blaming.             (line 103)
-* p <2>:                                 Editing Rebase Sequences.
-                                                              (line  35)
-* P <1>:                                 Pushing.             (line  11)
-* p <3>:                                 Minor Mode for Buffers Visiting Blobs.
-                                                              (line  12)
-* P e:                                   Pushing.             (line  35)
-* P m:                                   Pushing.             (line  53)
-* P o:                                   Pushing.             (line  39)
-* P p:                                   Pushing.             (line  16)
-* P r:                                   Pushing.             (line  44)
-* P t:                                   Pushing.             (line  59)
-* P T:                                   Pushing.             (line  65)
-* P u:                                   Pushing.             (line  26)
-* q:                                     Quitting Windows.    (line   6)
-* q <1>:                                 Log Buffer.          (line  12)
-* q <2>:                                 Blaming.             (line 107)
-* q <3>:                                 Minor Mode for Buffers Visiting Blobs.
-                                                              (line  20)
-* r:                                     Rebasing.            (line   9)
-* r <1>:                                 Editing Rebase Sequences.
-                                                              (line  51)
-* r a:                                   Rebasing.            (line 107)
-* r e:                                   Rebasing.            (line  33)
-* r e <1>:                               Rebasing.            (line 103)
-* r f:                                   Rebasing.            (line  73)
-* r i:                                   Rebasing.            (line  69)
-* r k:                                   Rebasing.            (line  85)
-* r m:                                   Rebasing.            (line  77)
-* r p:                                   Rebasing.            (line  24)
-* r r:                                   Rebasing.            (line  92)
-* r s:                                   Rebasing.            (line  39)
-* r s <1>:                               Rebasing.            (line  99)
-* r u:                                   Rebasing.            (line  29)
-* r w:                                   Rebasing.            (line  81)
-* RET:                                   Diff Buffer.         (line   8)
-* RET <1>:                               References Buffer.   (line 166)
-* RET <2>:                               Blaming.             (line  59)
-* RET <3>:                               Editing Rebase Sequences.
-                                                              (line  16)
-* s:                                     Staging and Unstaging.
-                                                              (line  28)
-* S:                                     Staging and Unstaging.
-                                                              (line  36)
-* s <1>:                                 Editing Rebase Sequences.
-                                                              (line  59)
-* S-<tab>:                               Section Visibility.  (line  22)
-* SPC:                                   Log Buffer.          (line  33)
-* SPC <1>:                               Diff Buffer.         (line  99)
-* SPC <2>:                               Blaming.             (line  63)
-* SPC <3>:                               Editing Rebase Sequences.
-                                                              (line  21)
-* t:                                     Tagging.             (line   8)
-* T:                                     Notes.               (line   8)
-* T a:                                   Notes.               (line  51)
-* T c:                                   Notes.               (line  46)
-* t k:                                   Tagging.             (line  18)
-* T m:                                   Notes.               (line  37)
-* t p:                                   Tagging.             (line  24)
-* T p:                                   Notes.               (line  29)
-* T r:                                   Notes.               (line  21)
-* t t:                                   Tagging.             (line  13)
-* T T:                                   Notes.               (line  13)
-* TAB:                                   Section Visibility.  (line   9)
-* u:                                     Staging and Unstaging.
-                                                              (line  43)
-* U:                                     Staging and Unstaging.
-                                                              (line  52)
-* v:                                     Applying.            (line  44)
-* V:                                     Reverting.           (line   6)
-* V A:                                   Reverting.           (line  30)
-* V a:                                   Reverting.           (line  38)
-* V s:                                   Reverting.           (line  34)
-* V V:                                   Reverting.           (line  14)
-* V v:                                   Reverting.           (line  20)
-* W:                                     Creating and Sending Patches.
-                                                              (line   6)
-* w:                                     Applying Patches.    (line   8)
-* w a:                                   Applying Patches.    (line  34)
-* w a <1>:                               Applying Patches.    (line  42)
-* w a a:                                 Applying Patches.    (line  47)
-* w m:                                   Applying Patches.    (line  19)
-* W p:                                   Creating and Sending Patches.
-                                                              (line  11)
-* W r:                                   Creating and Sending Patches.
-                                                              (line  17)
-* w s:                                   Applying Patches.    (line  30)
-* w w:                                   Applying Patches.    (line  13)
-* w w <1>:                               Applying Patches.    (line  26)
-* x:                                     Editing Rebase Sequences.
-                                                              (line  76)
-* x <1>:                                 Resetting.           (line   8)
-* X f:                                   Resetting.           (line  43)
-* X h:                                   Resetting.           (line  25)
-* X i:                                   Resetting.           (line  30)
-* X m:                                   Resetting.           (line  14)
-* X s:                                   Resetting.           (line  19)
-* X w:                                   Resetting.           (line  37)
-* X w <1>:                               Wip Modes.           (line 101)
-* Y:                                     Cherries.            (line  17)
-* y:                                     References Buffer.   (line   6)
-* y <1>:                                 Editing Rebase Sequences.
-                                                              (line  85)
-* y c:                                   References Buffer.   (line  19)
-* y o:                                   References Buffer.   (line  24)
-* y y:                                   References Buffer.   (line  14)
-* z:                                     Stashing.            (line   8)
-* z a:                                   Stashing.            (line  58)
-* z b:                                   Stashing.            (line  80)
-* z B:                                   Stashing.            (line  85)
-* z f:                                   Stashing.            (line  91)
-* z i:                                   Stashing.            (line  20)
-* z I:                                   Stashing.            (line  46)
-* z k:                                   Stashing.            (line  71)
-* z l:                                   Stashing.            (line  99)
-* z p:                                   Stashing.            (line  64)
-* z v:                                   Stashing.            (line  76)
-* z w:                                   Stashing.            (line  25)
-* z W:                                   Stashing.            (line  51)
-* z x:                                   Stashing.            (line  32)
-* z z:                                   Stashing.            (line  13)
-* z Z:                                   Stashing.            (line  39)
-
-
-File: magit.info,  Node: Command Index,  Next: Function Index,  Prev: Keystroke Index,  Up: Top
-
-Appendix D Command Index
-************************
-
-
-* Menu:
-
-* auto-revert-mode:                      Automatic Reverting of File-Visiting Buffers.
-                                                              (line  62)
-* forward-line:                          Editing Rebase Sequences.
-                                                              (line  39)
-* git-commit-ack:                        Editing Commit Messages.
-                                                              (line 128)
-* git-commit-cc:                         Editing Commit Messages.
-                                                              (line 144)
-* git-commit-next-message:               Editing Commit Messages.
-                                                              (line  45)
-* git-commit-prev-message:               Editing Commit Messages.
-                                                              (line  39)
-* git-commit-reported:                   Editing Commit Messages.
-                                                              (line 148)
-* git-commit-review:                     Editing Commit Messages.
-                                                              (line 132)
-* git-commit-save-message:               Editing Commit Messages.
-                                                              (line  35)
-* git-commit-signoff:                    Editing Commit Messages.
-                                                              (line 136)
-* git-commit-suggested:                  Editing Commit Messages.
-                                                              (line 153)
-* git-commit-test:                       Editing Commit Messages.
-                                                              (line 140)
-* git-rebase-backward-line:              Editing Rebase Sequences.
-                                                              (line  35)
-* git-rebase-edit:                       Editing Rebase Sequences.
-                                                              (line  55)
-* git-rebase-exec:                       Editing Rebase Sequences.
-                                                              (line  76)
-* git-rebase-fixup:                      Editing Rebase Sequences.
-                                                              (line  63)
-* git-rebase-insert:                     Editing Rebase Sequences.
-                                                              (line  85)
-* git-rebase-kill-line:                  Editing Rebase Sequences.
-                                                              (line  68)
-* git-rebase-move-line-down:             Editing Rebase Sequences.
-                                                              (line  47)
-* git-rebase-move-line-up:               Editing Rebase Sequences.
-                                                              (line  43)
-* git-rebase-pick:                       Editing Rebase Sequences.
-                                                              (line  72)
-* git-rebase-reword:                     Editing Rebase Sequences.
-                                                              (line  51)
-* git-rebase-show-commit:                Editing Rebase Sequences.
-                                                              (line  16)
-* git-rebase-show-or-scroll-down:        Editing Rebase Sequences.
-                                                              (line  28)
-* git-rebase-show-or-scroll-up:          Editing Rebase Sequences.
-                                                              (line  21)
-* git-rebase-squash:                     Editing Rebase Sequences.
-                                                              (line  59)
-* git-rebase-undo:                       Editing Rebase Sequences.
-                                                              (line  89)
-* ido-enter-magit-status:                Status Buffer.       (line  47)
-* magit-am-abort:                        Applying Patches.    (line  34)
-* magit-am-apply-maildir:                Applying Patches.    (line  19)
-* magit-am-apply-patches:                Applying Patches.    (line  13)
-* magit-am-continue:                     Applying Patches.    (line  26)
-* magit-am-popup:                        Applying Patches.    (line   8)
-* magit-am-skip:                         Applying Patches.    (line  30)
-* magit-apply:                           Applying.            (line  33)
-* magit-bisect-bad:                      Bisecting.           (line  31)
-* magit-bisect-good:                     Bisecting.           (line  36)
-* magit-bisect-popup:                    Bisecting.           (line   8)
-* magit-bisect-reset:                    Bisecting.           (line  47)
-* magit-bisect-run:                      Bisecting.           (line  24)
-* magit-bisect-skip:                     Bisecting.           (line  41)
-* magit-bisect-start:                    Bisecting.           (line  16)
-* magit-blame:                           Blaming.             (line  17)
-* magit-blame <1>:                       Minor Mode for Buffers Visiting Files.
-                                                              (line  86)
-* magit-blame-copy-hash:                 Blaming.             (line 112)
-* magit-blame-cycle-style:               Blaming.             (line 120)
-* magit-blame-echo:                      Blaming.             (line  32)
-* magit-blame-next-chunk:                Blaming.             (line  91)
-* magit-blame-next-chunk-same-commit:    Blaming.             (line  95)
-* magit-blame-popup:                     Blaming.             (line  86)
-* magit-blame-popup <1>:                 Minor Mode for Buffers Visiting Files.
-                                                              (line  80)
-* magit-blame-previous-chunk:            Blaming.             (line  99)
-* magit-blame-previous-chunk-same-commit: Blaming.            (line 103)
-* magit-blame-quit:                      Blaming.             (line 107)
-* magit-blame-removal:                   Blaming.             (line  38)
-* magit-blame-removal <1>:               Minor Mode for Buffers Visiting Files.
-                                                              (line  91)
-* magit-blame-reverse:                   Blaming.             (line  46)
-* magit-blame-reverse <1>:               Minor Mode for Buffers Visiting Files.
-                                                              (line  96)
-* magit-blob-next:                       Minor Mode for Buffers Visiting Blobs.
-                                                              (line  16)
-* magit-blob-previous:                   Minor Mode for Buffers Visiting Files.
-                                                              (line 112)
-* magit-blob-previous <1>:               Minor Mode for Buffers Visiting Blobs.
-                                                              (line  12)
-* magit-branch:                          The Branch Popup.    (line  45)
-* magit-branch-and-checkout:             The Branch Popup.    (line  55)
-* magit-branch-checkout:                 The Branch Popup.    (line  62)
-* magit-branch-config-popup:             The Branch Popup.    (line  29)
-* magit-branch-config-popup <1>:         The Branch Config Popup.
-                                                              (line   6)
-* magit-branch-delete:                   The Branch Popup.    (line 240)
-* magit-branch-or-checkout:              The Branch Popup.    (line 350)
-* magit-branch-orphan:                   The Branch Popup.    (line 345)
-* magit-branch-popup:                    The Branch Popup.    (line  12)
-* magit-branch-pull-request:             The Branch Popup.    (line 113)
-* magit-branch-rename:                   The Branch Popup.    (line 246)
-* magit-branch-reset:                    The Branch Popup.    (line 224)
-* magit-branch-shelve:                   Auxillary Branch Commands.
-                                                              (line   8)
-* magit-branch-spinoff:                  The Branch Popup.    (line  85)
-* magit-branch-unshelve:                 Auxillary Branch Commands.
-                                                              (line  19)
-* magit-checkout:                        The Branch Popup.    (line  37)
-* magit-checkout-pull-request:           The Branch Popup.    (line 218)
-* magit-cherry:                          Cherries.            (line  17)
-* magit-cherry-apply:                    Cherry Picking.      (line  23)
-* magit-cherry-donate:                   Cherry Picking.      (line  53)
-* magit-cherry-harvest:                  Cherry Picking.      (line  41)
-* magit-cherry-pick:                     Cherry Picking.      (line  16)
-* magit-cherry-pick-popup:               Cherry Picking.      (line   8)
-* magit-cherry-spinoff:                  Cherry Picking.      (line  75)
-* magit-cherry-spinout:                  Cherry Picking.      (line  64)
-* magit-clone:                           Repository Setup.    (line  16)
-* magit-commit:                          Initiating a Commit. (line  13)
-* magit-commit-amend:                    Initiating a Commit. (line  18)
-* magit-commit-augment:                  Initiating a Commit. (line  66)
-* magit-commit-extend:                   Initiating a Commit. (line  22)
-* magit-commit-fixup:                    Initiating a Commit. (line  42)
-* magit-commit-instant-fixup:            Initiating a Commit. (line  50)
-* magit-commit-instant-squash:           Initiating a Commit. (line  62)
-* magit-commit-popup:                    Initiating a Commit. (line   8)
-* magit-commit-popup <1>:                Minor Mode for Buffers Visiting Files.
-                                                              (line  33)
-* magit-commit-reword:                   Initiating a Commit. (line  32)
-* magit-commit-squash:                   Initiating a Commit. (line  54)
-* magit-copy-buffer-revision:            Common Commands.     (line  21)
-* magit-copy-section-value:              Common Commands.     (line  10)
-* magit-cycle-margin-style:              Log Margin.          (line  60)
-* magit-debug-git-executable:            Git Executable.      (line  45)
-* magit-debug-git-executable <1>:        Debugging Tools.     (line  30)
-* magit-describe-section-briefly:        Section Types and Values.
-                                                              (line  13)
-* magit-describe-section-briefly <1>:    Matching Sections.   (line   6)
-* magit-diff:                            Diffing.             (line  29)
-* magit-diff-buffer-file:                Minor Mode for Buffers Visiting Files.
-                                                              (line  47)
-* magit-diff-buffer-file-popup:          Minor Mode for Buffers Visiting Files.
-                                                              (line  39)
-* magit-diff-default-context:            Refreshing Diffs.    (line  72)
-* magit-diff-dwim:                       Diffing.             (line  25)
-* magit-diff-edit-hunk-commit:           Diff Buffer.         (line  74)
-* magit-diff-flip-revs:                  Refreshing Diffs.    (line  45)
-* magit-diff-less-context:               Refreshing Diffs.    (line  64)
-* magit-diff-more-context:               Refreshing Diffs.    (line  68)
-* magit-diff-paths:                      Diffing.             (line  59)
-* magit-diff-popup:                      Diffing.             (line  20)
-* magit-diff-refresh:                    Refreshing Diffs.    (line  16)
-* magit-diff-refresh-popup:              Refreshing Diffs.    (line  11)
-* magit-diff-save-default-arguments:     Refreshing Diffs.    (line  28)
-* magit-diff-set-default-arguments:      Refreshing Diffs.    (line  21)
-* magit-diff-show-or-scroll-down:        Log Buffer.          (line  43)
-* magit-diff-show-or-scroll-down <1>:    Blaming.             (line  73)
-* magit-diff-show-or-scroll-up:          Log Buffer.          (line  33)
-* magit-diff-show-or-scroll-up <1>:      Blaming.             (line  63)
-* magit-diff-staged:                     Diffing.             (line  49)
-* magit-diff-switch-range-type:          Refreshing Diffs.    (line  40)
-* magit-diff-toggle-file-filter:         Refreshing Diffs.    (line  50)
-* magit-diff-toggle-refine-hunk:         Refreshing Diffs.    (line  36)
-* magit-diff-trace-definition:           Diff Buffer.         (line  70)
-* magit-diff-unstaged:                   Diffing.             (line  55)
-* magit-diff-visit-file:                 Diff Buffer.         (line   8)
-* magit-diff-visit-file-other-window:    Diff Buffer.         (line  65)
-* magit-diff-visit-file-worktree:        Diff Buffer.         (line  48)
-* magit-diff-while-committing:           Refreshing Diffs.    (line  80)
-* magit-diff-while-committing <1>:       Editing Commit Messages.
-                                                              (line  57)
-* magit-diff-working-tree:               Diffing.             (line  43)
-* magit-discard:                         Applying.            (line  40)
-* magit-dispatch-popup:                  Popup Buffers and Prefix Commands.
-                                                              (line  20)
-* magit-ediff-compare:                   Ediffing.            (line  26)
-* magit-ediff-dwim:                      Ediffing.            (line   9)
-* magit-ediff-popup:                     Ediffing.            (line  21)
-* magit-ediff-resolve:                   Ediffing.            (line  35)
-* magit-ediff-show-commit:               Ediffing.            (line  65)
-* magit-ediff-show-staged:               Ediffing.            (line  57)
-* magit-ediff-show-stash:                Ediffing.            (line  69)
-* magit-ediff-show-unstaged:             Ediffing.            (line  53)
-* magit-ediff-show-working-tree:         Ediffing.            (line  61)
-* magit-ediff-stage:                     Ediffing.            (line  48)
-* magit-edit-line-commit:                Minor Mode for Buffers Visiting Files.
-                                                              (line 102)
-* magit-emacs-Q-command:                 Debugging Tools.     (line  16)
-* magit-fetch:                           Fetching.            (line  24)
-* magit-fetch-all:                       Fetching.            (line  38)
-* magit-fetch-branch:                    Fetching.            (line  28)
-* magit-fetch-from-pushremote:           Fetching.            (line  16)
-* magit-fetch-from-upstream:             Fetching.            (line  20)
-* magit-fetch-modules:                   Submodule Popup.     (line  57)
-* magit-fetch-popup:                     Fetching.            (line  11)
-* magit-fetch-refspec:                   Fetching.            (line  33)
-* magit-file-checkout:                   Resetting.           (line  43)
-* magit-file-checkout <1>:               Minor Mode for Buffers Visiting Files.
-                                                              (line 131)
-* magit-file-delete:                     Minor Mode for Buffers Visiting Files.
-                                                              (line 123)
-* magit-file-popup:                      Minor Mode for Buffers Visiting Files.
-                                                              (line  19)
-* magit-file-rename:                     Minor Mode for Buffers Visiting Files.
-                                                              (line 119)
-* magit-file-untrack:                    Minor Mode for Buffers Visiting Files.
-                                                              (line 127)
-* magit-find-file:                       Visiting Blobs.      (line   6)
-* magit-find-file-other-window:          Visiting Blobs.      (line  11)
-* magit-format-patch:                    Creating and Sending Patches.
-                                                              (line  11)
-* magit-git-command:                     Running Git Manually.
-                                                              (line  24)
-* magit-git-command-topdir:              Running Git Manually.
-                                                              (line  16)
-* magit-go-backward:                     Log Buffer.          (line  19)
-* magit-go-backward <1>:                 Refreshing Diffs.    (line  90)
-* magit-go-forward:                      Log Buffer.          (line  23)
-* magit-go-forward <1>:                  Refreshing Diffs.    (line  94)
-* magit-init:                            Repository Setup.    (line   6)
-* magit-jump-to-diffstat-or-diff:        Diff Buffer.         (line  93)
-* magit-kill-this-buffer:                Minor Mode for Buffers Visiting Blobs.
-                                                              (line  20)
-* magit-list-repositories:               Repository List.     (line   6)
-* magit-list-submodules:                 Listing Submodules.  (line  13)
-* magit-list-submodules <1>:             Submodule Popup.     (line  53)
-* magit-log:                             Logging.             (line  39)
-* magit-log-all:                         Logging.             (line  58)
-* magit-log-all-branches:                Logging.             (line  54)
-* magit-log-branches:                    Logging.             (line  50)
-* magit-log-buffer-file:                 Minor Mode for Buffers Visiting Files.
-                                                              (line  64)
-* magit-log-buffer-file-popup:           Minor Mode for Buffers Visiting Files.
-                                                              (line  57)
-* magit-log-bury-buffer:                 Log Buffer.          (line  12)
-* magit-log-current:                     Logging.             (line  33)
-* magit-log-double-commit-limit:         Log Buffer.          (line  59)
-* magit-log-half-commit-limit:           Log Buffer.          (line  63)
-* magit-log-head:                        Logging.             (line  46)
-* magit-log-move-to-parent:              Log Buffer.          (line  27)
-* magit-log-popup:                       Logging.             (line  28)
-* magit-log-refresh:                     Refreshing Logs.     (line  16)
-* magit-log-refresh-popup:               Refreshing Logs.     (line  11)
-* magit-log-refresh-popup <1>:           Log Buffer.          (line   6)
-* magit-log-save-default-arguments:      Refreshing Logs.     (line  28)
-* magit-log-select-pick:                 Select from Log.     (line  20)
-* magit-log-select-quit:                 Select from Log.     (line  26)
-* magit-log-set-default-arguments:       Refreshing Logs.     (line  21)
-* magit-log-toggle-commit-limit:         Log Buffer.          (line  53)
-* magit-log-trace-definition:            Minor Mode for Buffers Visiting Files.
-                                                              (line  71)
-* magit-margin-popup:                    Log Margin.          (line  47)
-* magit-merge:                           Merging.             (line  17)
-* magit-merge <1>:                       Merging.             (line  88)
-* magit-merge-abort:                     Merging.             (line  94)
-* magit-merge-absorb:                    Merging.             (line  44)
-* magit-merge-editmsg:                   Merging.             (line  30)
-* magit-merge-into:                      Merging.             (line  57)
-* magit-merge-nocommit:                  Merging.             (line  37)
-* magit-merge-popup:                     Merging.             (line   9)
-* magit-merge-preview:                   Merging.             (line  80)
-* magit-merge-squash:                    Merging.             (line  71)
-* magit-mode-bury-buffer:                Quitting Windows.    (line   6)
-* magit-notes-edit:                      Notes.               (line  13)
-* magit-notes-merge:                     Notes.               (line  37)
-* magit-notes-merge-abort:               Notes.               (line  51)
-* magit-notes-merge-commit:              Notes.               (line  46)
-* magit-notes-popup:                     Notes.               (line   8)
-* magit-notes-prune:                     Notes.               (line  29)
-* magit-notes-remove:                    Notes.               (line  21)
-* magit-patch-apply:                     Applying Patches.    (line  47)
-* magit-patch-apply-popup:               Applying Patches.    (line  42)
-* magit-patch-popup:                     Creating and Sending Patches.
-                                                              (line   6)
-* magit-pop-revision-stack:              Editing Commit Messages.
-                                                              (line  63)
-* magit-process:                         Viewing Git Output.  (line  16)
-* magit-process-kill:                    Viewing Git Output.  (line  24)
-* magit-pull:                            Pulling.             (line  24)
-* magit-pull-from-pushremote:            Pulling.             (line  16)
-* magit-pull-from-upstream:              Pulling.             (line  20)
-* magit-pull-popup:                      Pulling.             (line  11)
-* magit-push:                            Pushing.             (line  39)
-* magit-push-current:                    Pushing.             (line  35)
-* magit-push-current-to-pushremote:      Pushing.             (line  16)
-* magit-push-current-to-upstream:        Pushing.             (line  26)
-* magit-push-implicitly args:            Pushing.             (line  73)
-* magit-push-matching:                   Pushing.             (line  53)
-* magit-push-popup:                      Pushing.             (line  11)
-* magit-push-refspecs:                   Pushing.             (line  44)
-* magit-push-tag:                        Pushing.             (line  65)
-* magit-push-tags:                       Pushing.             (line  59)
-* magit-push-to-remote remote args:      Pushing.             (line  84)
-* magit-rebase:                          Rebasing.            (line  33)
-* magit-rebase-abort:                    Rebasing.            (line 107)
-* magit-rebase-autosquash:               Rebasing.            (line  73)
-* magit-rebase-continue:                 Rebasing.            (line  92)
-* magit-rebase-edit:                     Rebasing.            (line 103)
-* magit-rebase-edit-commit:              Rebasing.            (line  77)
-* magit-rebase-interactive:              Rebasing.            (line  69)
-* magit-rebase-onto-pushremote:          Rebasing.            (line  24)
-* magit-rebase-onto-upstream:            Rebasing.            (line  29)
-* magit-rebase-popup:                    Rebasing.            (line   9)
-* magit-rebase-remove-commit:            Rebasing.            (line  85)
-* magit-rebase-reword-commit:            Rebasing.            (line  81)
-* magit-rebase-skip:                     Rebasing.            (line  99)
-* magit-rebase-subset:                   Rebasing.            (line  39)
-* magit-reflog-current:                  Reflog.              (line  11)
-* magit-reflog-head:                     Reflog.              (line  19)
-* magit-reflog-other:                    Reflog.              (line  15)
-* magit-refresh:                         Automatic Refreshing of Magit Buffers.
-                                                              (line  22)
-* magit-refresh-all:                     Automatic Refreshing of Magit Buffers.
-                                                              (line  31)
-* magit-remote-add:                      The Remote Popup.    (line  35)
-* magit-remote-config-popup:             The Remote Popup.    (line  26)
-* magit-remote-config-popup <1>:         The Remote Config Popup.
-                                                              (line   6)
-* magit-remote-popup:                    The Remote Popup.    (line  13)
-* magit-remote-prune:                    The Remote Popup.    (line  54)
-* magit-remote-prune-refspecs:           The Remote Popup.    (line  59)
-* magit-remote-remove:                   The Remote Popup.    (line  50)
-* magit-remote-rename:                   The Remote Popup.    (line  40)
-* magit-remote-set-url:                  The Remote Popup.    (line  45)
-* magit-request-pull:                    Creating and Sending Patches.
-                                                              (line  17)
-* magit-reset:                           Resetting.           (line   8)
-* magit-reset-hard:                      Resetting.           (line  25)
-* magit-reset-head:                      Resetting.           (line  14)
-* magit-reset-index:                     Staging and Unstaging.
-                                                              (line  87)
-* magit-reset-index <1>:                 Resetting.           (line  30)
-* magit-reset-soft:                      Resetting.           (line  19)
-* magit-reset-worktree:                  Resetting.           (line  37)
-* magit-reset-worktree <1>:              Wip Modes.           (line 101)
-* magit-reverse:                         Applying.            (line  44)
-* magit-reverse-in-index:                Staging and Unstaging.
-                                                              (line  62)
-* magit-revert:                          Reverting.           (line  14)
-* magit-revert-no-commit:                Reverting.           (line  20)
-* magit-revert-popup:                    Reverting.           (line   6)
-* magit-run-git-gui:                     Running Git Manually.
-                                                              (line  65)
-* magit-run-gitk:                        Running Git Manually.
-                                                              (line  53)
-* magit-run-gitk-all:                    Running Git Manually.
-                                                              (line  57)
-* magit-run-gitk-branches:               Running Git Manually.
-                                                              (line  61)
-* magit-run-popup:                       Running Git Manually.
-                                                              (line  12)
-* magit-section-backward:                Section Movement.    (line  10)
-* magit-section-backward-siblings:       Section Movement.    (line  20)
-* magit-section-cycle:                   Section Visibility.  (line  13)
-* magit-section-cycle-diffs:             Section Visibility.  (line  17)
-* magit-section-cycle-global:            Section Visibility.  (line  22)
-* magit-section-forward:                 Section Movement.    (line  16)
-* magit-section-forward-siblings:        Section Movement.    (line  26)
-* magit-section-hide:                    Section Visibility.  (line  49)
-* magit-section-hide-children:           Section Visibility.  (line  64)
-* magit-section-show:                    Section Visibility.  (line  45)
-* magit-section-show-children:           Section Visibility.  (line  58)
-* magit-section-show-headings:           Section Visibility.  (line  53)
-* magit-section-show-level-1:            Section Visibility.  (line  26)
-* magit-section-show-level-1-all:        Section Visibility.  (line  33)
-* magit-section-show-level-2:            Section Visibility.  (line  27)
-* magit-section-show-level-2-all:        Section Visibility.  (line  34)
-* magit-section-show-level-3:            Section Visibility.  (line  28)
-* magit-section-show-level-3-all:        Section Visibility.  (line  35)
-* magit-section-show-level-4:            Section Visibility.  (line  29)
-* magit-section-show-level-4-all:        Section Visibility.  (line  36)
-* magit-section-toggle:                  Section Visibility.  (line   9)
-* magit-section-toggle-children:         Section Visibility.  (line  68)
-* magit-section-up:                      Section Movement.    (line  31)
-* magit-sequence-abort:                  Cherry Picking.      (line  97)
-* magit-sequence-abort <1>:              Reverting.           (line  38)
-* magit-sequence-continue:               Cherry Picking.      (line  89)
-* magit-sequence-continue <1>:           Reverting.           (line  30)
-* magit-sequence-skip:                   Cherry Picking.      (line  93)
-* magit-sequence-skip <1>:               Reverting.           (line  34)
-* magit-shell-command:                   Running Git Manually.
-                                                              (line  39)
-* magit-shell-command-topdir:            Running Git Manually.
-                                                              (line  34)
-* magit-show-commit:                     Diffing.             (line  67)
-* magit-show-commit <1>:                 Blaming.             (line  59)
-* magit-show-refs:                       References Buffer.   (line  24)
-* magit-show-refs-current:               References Buffer.   (line  19)
-* magit-show-refs-head:                  References Buffer.   (line  14)
-* magit-show-refs-popup:                 References Buffer.   (line   6)
-* magit-snapshot:                        Stashing.            (line  39)
-* magit-snapshot-index:                  Stashing.            (line  46)
-* magit-snapshot-worktree:               Stashing.            (line  51)
-* magit-stage:                           Staging and Unstaging.
-                                                              (line  28)
-* magit-stage-file:                      Staging from File-Visiting Buffers.
-                                                              (line  10)
-* magit-stage-file <1>:                  Minor Mode for Buffers Visiting Files.
-                                                              (line  24)
-* magit-stage-modified:                  Staging and Unstaging.
-                                                              (line  36)
-* magit-stash:                           Stashing.            (line  13)
-* magit-stash-apply:                     Stashing.            (line  58)
-* magit-stash-branch:                    Stashing.            (line  80)
-* magit-stash-branch-here:               Stashing.            (line  85)
-* magit-stash-clear:                     Stashing.            (line  95)
-* magit-stash-drop:                      Stashing.            (line  71)
-* magit-stash-format-patch:              Stashing.            (line  91)
-* magit-stash-index:                     Stashing.            (line  20)
-* magit-stash-keep-index:                Stashing.            (line  32)
-* magit-stash-list:                      Stashing.            (line  99)
-* magit-stash-pop:                       Stashing.            (line  64)
-* magit-stash-popup:                     Stashing.            (line   8)
-* magit-stash-show:                      Diffing.             (line  72)
-* magit-stash-show <1>:                  Stashing.            (line  76)
-* magit-stash-worktree:                  Stashing.            (line  25)
-* magit-status:                          Status Buffer.       (line  22)
-* magit-submodule-add:                   Submodule Popup.     (line  19)
-* magit-submodule-fetch:                 Fetching.            (line  42)
-* magit-submodule-populate:              Submodule Popup.     (line  33)
-* magit-submodule-popup:                 Submodule Popup.     (line   6)
-* magit-submodule-register:              Submodule Popup.     (line  26)
-* magit-submodule-synchronize:           Submodule Popup.     (line  43)
-* magit-submodule-unpopulate:            Submodule Popup.     (line  49)
-* magit-submodule-update:                Submodule Popup.     (line  38)
-* magit-subtree-add:                     Subtree.             (line  20)
-* magit-subtree-add-commit:              Subtree.             (line  24)
-* magit-subtree-merge:                   Subtree.             (line  28)
-* magit-subtree-pull:                    Subtree.             (line  32)
-* magit-subtree-push:                    Subtree.             (line  36)
-* magit-subtree-split:                   Subtree.             (line  41)
-* magit-tag:                             Tagging.             (line  13)
-* magit-tag-delete:                      Tagging.             (line  18)
-* magit-tag-popup:                       Tagging.             (line   8)
-* magit-tag-prune:                       Tagging.             (line  24)
-* magit-tag-release:                     Tagging.             (line  28)
-* magit-toggle-buffer-lock:              Modes and Buffers.   (line  17)
-* magit-toggle-margin:                   Refreshing Logs.     (line  36)
-* magit-toggle-margin <1>:               Log Margin.          (line  56)
-* magit-toggle-margin-details:           Log Margin.          (line  64)
-* magit-tree-popup:                      Subtree.             (line   8)
-* magit-unstage:                         Staging and Unstaging.
-                                                              (line  43)
-* magit-unstage-all:                     Staging and Unstaging.
-                                                              (line  52)
-* magit-unstage-file:                    Staging from File-Visiting Buffers.
-                                                              (line  18)
-* magit-unstage-file <1>:                Minor Mode for Buffers Visiting Files.
-                                                              (line  28)
-* magit-version:                         Git Executable.      (line  17)
-* magit-version <1>:                     Debugging Tools.     (line  10)
-* magit-visit-ref:                       References Buffer.   (line 166)
-* magit-wip-commit:                      Wip Modes.           (line 174)
-* magit-wip-log:                         Wip Modes.           (line  85)
-* magit-wip-log-current:                 Wip Modes.           (line  93)
-* magit-worktree-branch:                 Worktree.            (line  17)
-* magit-worktree-checkout:               Worktree.            (line  13)
-* magit-worktree-checkout-pull-request:  Worktree.            (line  21)
-* magit-worktree-delete:                 Worktree.            (line  28)
-* magit-worktree-popup:                  Worktree.            (line   8)
-* magit-worktree-status:                 Worktree.            (line  33)
-* scroll-down:                           Diff Buffer.         (line 103)
-* scroll-up:                             Diff Buffer.         (line  99)
-* with-editor-cancel:                    Editing Commit Messages.
-                                                              (line  24)
-* with-editor-cancel <1>:                Editing Rebase Sequences.
-                                                              (line  11)
-* with-editor-debug:                     Debugging Tools.     (line  38)
-* with-editor-finish:                    Editing Commit Messages.
-                                                              (line  19)
-* with-editor-finish <1>:                Editing Rebase Sequences.
-                                                              (line   6)
-
-
-File: magit.info,  Node: Function Index,  Next: Variable Index,  Prev: Command Index,  Up: Top
-
-Appendix E Function Index
-*************************
-
-
-* Menu:
-
-* auto-revert-mode:                      Automatic Reverting of File-Visiting Buffers.
-                                                              (line  62)
-* git-commit-check-style-conventions:    Editing Commit Messages.
-                                                              (line 247)
-* git-commit-propertize-diff:            Editing Commit Messages.
-                                                              (line 206)
-* git-commit-save-message:               Editing Commit Messages.
-                                                              (line 187)
-* git-commit-setup-changelog-support:    Editing Commit Messages.
-                                                              (line 191)
-* git-commit-turn-on-auto-fill:          Editing Commit Messages.
-                                                              (line 196)
-* git-commit-turn-on-flyspell:           Editing Commit Messages.
-                                                              (line 201)
-* ido-enter-magit-status:                Status Buffer.       (line  47)
-* magit-add-section-hook:                Section Hooks.       (line  20)
-* magit-after-save-refresh-status:       Automatic Refreshing of Magit Buffers.
-                                                              (line  56)
-* magit-blame:                           Blaming.             (line  17)
-* magit-blame-echo:                      Blaming.             (line  32)
-* magit-blame-removal:                   Blaming.             (line  38)
-* magit-blame-reverse:                   Blaming.             (line  46)
-* magit-branch-config-popup:             The Branch Config Popup.
-                                                              (line   6)
-* magit-branch-or-checkout:              The Branch Popup.    (line 350)
-* magit-branch-orphan:                   The Branch Popup.    (line 345)
-* magit-branch-shelve:                   Auxillary Branch Commands.
-                                                              (line   8)
-* magit-branch-unshelve:                 Auxillary Branch Commands.
-                                                              (line  19)
-* magit-builtin-completing-read:         Support for Completion Frameworks.
-                                                              (line  42)
-* magit-call-git:                        Calling Git for Effect.
-                                                              (line  28)
-* magit-call-process:                    Calling Git for Effect.
-                                                              (line  32)
-* magit-cancel-section:                  Creating Sections.   (line  71)
-* magit-completing-read:                 Support for Completion Frameworks.
-                                                              (line  60)
-* magit-current-section:                 Section Selection.   (line   6)
-* magit-define-section-jumper:           Creating Sections.   (line  77)
-* magit-diff-scope:                      Matching Sections.   (line 111)
-* magit-diff-type:                       Matching Sections.   (line  88)
-* magit-diff-visit-file-other-window:    Diff Buffer.         (line  65)
-* magit-display-buffer:                  Switching Buffers.   (line   6)
-* magit-display-buffer-fullcolumn-most-v1: Switching Buffers. (line  72)
-* magit-display-buffer-fullframe-status-topleft-v1: Switching Buffers.
-                                                              (line  62)
-* magit-display-buffer-fullframe-status-v1: Switching Buffers.
-                                                              (line  56)
-* magit-display-buffer-same-window-except-diff-v1: Switching Buffers.
-                                                              (line  50)
-* magit-display-buffer-traditional:      Switching Buffers.   (line  42)
-* magit-file-checkout:                   Minor Mode for Buffers Visiting Files.
-                                                              (line 131)
-* magit-file-delete:                     Minor Mode for Buffers Visiting Files.
-                                                              (line 123)
-* magit-file-rename:                     Minor Mode for Buffers Visiting Files.
-                                                              (line 119)
-* magit-file-untrack:                    Minor Mode for Buffers Visiting Files.
-                                                              (line 127)
-* magit-generate-buffer-name-default-function: Naming Buffers.
-                                                              (line  17)
-* magit-get-section:                     Matching Sections.   (line  16)
-* magit-git:                             Calling Git for Effect.
-                                                              (line  65)
-* magit-git-exit-code:                   Getting a Value from Git.
-                                                              (line  10)
-* magit-git-failure:                     Getting a Value from Git.
-                                                              (line  19)
-* magit-git-false:                       Getting a Value from Git.
-                                                              (line  29)
-* magit-git-insert:                      Getting a Value from Git.
-                                                              (line  34)
-* magit-git-items:                       Getting a Value from Git.
-                                                              (line  49)
-* magit-git-lines:                       Getting a Value from Git.
-                                                              (line  44)
-* magit-git-str:                         Getting a Value from Git.
-                                                              (line  72)
-* magit-git-string:                      Getting a Value from Git.
-                                                              (line  38)
-* magit-git-success:                     Getting a Value from Git.
-                                                              (line  14)
-* magit-git-true:                        Getting a Value from Git.
-                                                              (line  24)
-* magit-git-wash:                        Calling Git for Effect.
-                                                              (line  70)
-* magit-hunk-set-window-start:           Section Movement.    (line  43)
-* magit-ido-completing-read:             Support for Completion Frameworks.
-                                                              (line  48)
-* magit-insert-am-sequence:              Status Sections.     (line  28)
-* magit-insert-bisect-log:               Status Sections.     (line  46)
-* magit-insert-bisect-output:            Status Sections.     (line  38)
-* magit-insert-bisect-rest:              Status Sections.     (line  42)
-* magit-insert-diff-filter-header:       Status Header Sections.
-                                                              (line  38)
-* magit-insert-error-header:             Status Header Sections.
-                                                              (line  28)
-* magit-insert-head-branch-header:       Status Header Sections.
-                                                              (line  42)
-* magit-insert-heading:                  Creating Sections.   (line  42)
-* magit-insert-ignored-files:            Status Sections.     (line 100)
-* magit-insert-local-branches:           References Sections. (line  17)
-* magit-insert-merge-log:                Status Sections.     (line  18)
-* magit-insert-modules:                  Status Module Sections.
-                                                              (line  12)
-* magit-insert-modules-overview:         Status Module Sections.
-                                                              (line  33)
-* magit-insert-modules-unpulled-from-pushremote: Status Module Sections.
-                                                              (line  50)
-* magit-insert-modules-unpulled-from-upstream: Status Module Sections.
-                                                              (line  44)
-* magit-insert-modules-unpushed-to-pushremote: Status Module Sections.
-                                                              (line  62)
-* magit-insert-modules-unpushed-to-upstream: Status Module Sections.
-                                                              (line  56)
-* magit-insert-push-branch-header:       Status Header Sections.
-                                                              (line  51)
-* magit-insert-rebase-sequence:          Status Sections.     (line  23)
-* magit-insert-recent-commits:           Status Sections.     (line 115)
-* magit-insert-remote-branches:          References Sections. (line  21)
-* magit-insert-remote-header:            Status Header Sections.
-                                                              (line  67)
-* magit-insert-repo-header:              Status Header Sections.
-                                                              (line  63)
-* magit-insert-section:                  Creating Sections.   (line   6)
-* magit-insert-sequencer-sequence:       Status Sections.     (line  33)
-* magit-insert-staged-changes:           Status Sections.     (line  63)
-* magit-insert-stashes:                  Status Sections.     (line  67)
-* magit-insert-status-headers:           Status Header Sections.
-                                                              (line  12)
-* magit-insert-submodules:               Listing Submodules.  (line  35)
-* magit-insert-tags:                     References Sections. (line  25)
-* magit-insert-tags-header:              Status Header Sections.
-                                                              (line  56)
-* magit-insert-tracked-files:            Status Sections.     (line  96)
-* magit-insert-unpulled-cherries:        Status Sections.     (line 126)
-* magit-insert-unpulled-from-pushremote: Status Sections.     (line  79)
-* magit-insert-unpulled-from-upstream:   Status Sections.     (line  74)
-* magit-insert-unpulled-or-recent-commits: Status Sections.   (line 108)
-* magit-insert-unpushed-cherries:        Status Sections.     (line 133)
-* magit-insert-unpushed-to-pushremote:   Status Sections.     (line  89)
-* magit-insert-unpushed-to-upstream:     Status Sections.     (line  84)
-* magit-insert-unstaged-changes:         Status Sections.     (line  59)
-* magit-insert-untracked-files:          Status Sections.     (line  50)
-* magit-insert-upstream-branch-header:   Status Header Sections.
-                                                              (line  46)
-* magit-insert-user-header:              Status Header Sections.
-                                                              (line  75)
-* magit-list-repositories:               Repository List.     (line   6)
-* magit-list-submodules:                 Listing Submodules.  (line  13)
-* magit-log-maybe-show-more-commits:     Section Movement.    (line  57)
-* magit-log-maybe-update-blob-buffer:    Section Movement.    (line  71)
-* magit-log-maybe-update-revision-buffer: Section Movement.   (line  64)
-* magit-maybe-set-dedicated:             Switching Buffers.   (line  97)
-* magit-mode-display-buffer:             Refreshing Buffers.  (line  33)
-* magit-mode-quit-window:                Quitting Windows.    (line  31)
-* magit-mode-setup:                      Refreshing Buffers.  (line  17)
-* magit-push-implicitly:                 Pushing.             (line  73)
-* magit-push-to-remote:                  Pushing.             (line  84)
-* magit-region-sections:                 Section Selection.   (line  10)
-* magit-region-values:                   Section Selection.   (line  29)
-* magit-remote-config-popup:             The Remote Config Popup.
-                                                              (line   6)
-* magit-repolist-column-ident:           Repository List.     (line  30)
-* magit-repolist-column-path:            Repository List.     (line  35)
-* magit-repolist-column-unpulled-from-pushremote: Repository List.
-                                                              (line  49)
-* magit-repolist-column-unpulled-from-upstream: Repository List.
-                                                              (line  44)
-* magit-repolist-column-unpushed-to-pushremote: Repository List.
-                                                              (line  59)
-* magit-repolist-column-unpushed-to-upstream: Repository List.
-                                                              (line  54)
-* magit-repolist-column-version:         Repository List.     (line  39)
-* magit-restore-window-configuration:    Quitting Windows.    (line  20)
-* magit-revert-buffers:                  Editing Commit Messages.
-                                                              (line 178)
-* magit-run-git:                         Calling Git for Effect.
-                                                              (line  36)
-* magit-run-git-async:                   Calling Git for Effect.
-                                                              (line  80)
-* magit-run-git-with-editor:             Calling Git for Effect.
-                                                              (line  93)
-* magit-run-git-with-input:              Calling Git for Effect.
-                                                              (line  40)
-* magit-run-git-with-logfile:            Calling Git for Effect.
-                                                              (line  56)
-* magit-save-window-configuration:       Switching Buffers.   (line  86)
-* magit-section-case:                    Matching Sections.   (line  64)
-* magit-section-hide:                    Section Visibility.  (line  49)
-* magit-section-hide-children:           Section Visibility.  (line  64)
-* magit-section-ident:                   Matching Sections.   (line  11)
-* magit-section-match:                   Matching Sections.   (line  21)
-* magit-section-set-window-start:        Section Movement.    (line  50)
-* magit-section-show:                    Section Visibility.  (line  45)
-* magit-section-show-children:           Section Visibility.  (line  58)
-* magit-section-show-headings:           Section Visibility.  (line  53)
-* magit-section-toggle-children:         Section Visibility.  (line  68)
-* magit-section-when:                    Matching Sections.   (line  52)
-* magit-start-git:                       Calling Git for Effect.
-                                                              (line 105)
-* magit-start-process:                   Calling Git for Effect.
-                                                              (line 124)
-* magit-status-maybe-update-blob-buffer: Section Movement.    (line  83)
-* magit-status-maybe-update-revision-buffer: Section Movement.
-                                                              (line  77)
-* magit-tag-release:                     Tagging.             (line  28)
-* magit-wip-commit-initial-backup:       Wip Modes.           (line 145)
-* magit-wip-log:                         Wip Modes.           (line  85)
-* magit-wip-log-current:                 Wip Modes.           (line  93)
-* with-editor-usage-message:             Editing Commit Messages.
-                                                              (line 215)
-
-
-File: magit.info,  Node: Variable Index,  Prev: Function Index,  Up: Top
-
-Appendix F Variable Index
-*************************
-
-
-* Menu:
-
-* auto-revert-buffer-list-filter:        Automatic Reverting of File-Visiting Buffers.
-                                                              (line  81)
-* auto-revert-interval:                  Automatic Reverting of File-Visiting Buffers.
-                                                              (line  76)
-* auto-revert-stop-on-user-input:        Automatic Reverting of File-Visiting Buffers.
-                                                              (line  71)
-* auto-revert-use-notify:                Automatic Reverting of File-Visiting Buffers.
-                                                              (line  49)
-* auto-revert-verbose:                   Automatic Reverting of File-Visiting Buffers.
-                                                              (line 103)
-* branch.autoSetupMerge:                 The Branch Config Popup.
-                                                              (line  94)
-* branch.autoSetupRebase:                The Branch Config Popup.
-                                                              (line 111)
-* branch.NAME.description:               The Branch Config Popup.
-                                                              (line  61)
-* branch.NAME.merge:                     The Branch Config Popup.
-                                                              (line  23)
-* branch.NAME.pushRemote:                The Branch Config Popup.
-                                                              (line  47)
-* branch.NAME.rebase:                    The Branch Config Popup.
-                                                              (line  35)
-* branch.NAME.remote:                    The Branch Config Popup.
-                                                              (line  29)
-* core.notesRef:                         Notes.               (line  59)
-* git-commit-fill-column:                Editing Commit Messages.
-                                                              (line 228)
-* git-commit-finish-query-functions:     Editing Commit Messages.
-                                                              (line 233)
-* git-commit-known-pseudo-headers:       Editing Commit Messages.
-                                                              (line 124)
-* git-commit-major-mode:                 Editing Commit Messages.
-                                                              (line 163)
-* git-commit-setup-hook:                 Editing Commit Messages.
-                                                              (line 174)
-* git-commit-summary-max-length:         Editing Commit Messages.
-                                                              (line 222)
-* git-rebase-auto-advance:               Editing Rebase Sequences.
-                                                              (line  94)
-* git-rebase-confirm-cancel:             Editing Rebase Sequences.
-                                                              (line 102)
-* git-rebase-show-instructions:          Editing Rebase Sequences.
-                                                              (line  98)
-* global-auto-revert-mode:               Automatic Reverting of File-Visiting Buffers.
-                                                              (line  22)
-* magit-auto-revert-immediately:         Automatic Reverting of File-Visiting Buffers.
-                                                              (line  32)
-* magit-auto-revert-mode:                Automatic Reverting of File-Visiting Buffers.
-                                                              (line  17)
-* magit-auto-revert-tracked-only:        Automatic Reverting of File-Visiting Buffers.
-                                                              (line  55)
-* magit-bisect-show-graph:               Bisecting.           (line  55)
-* magit-blame-disable-modes:             Blaming.             (line 150)
-* magit-blame-echo-style:                Blaming.             (line 133)
-* magit-blame-goto-chunk-hook:           Blaming.             (line 156)
-* magit-blame-read-only:                 Blaming.             (line 145)
-* magit-blame-styles:                    Blaming.             (line 128)
-* magit-blame-time-format:               Blaming.             (line 140)
-* magit-branch-adjust-remote-upstream-alist: The Branch Popup.
-                                                              (line 303)
-* magit-branch-popup-show-variables:     The Branch Popup.    (line  21)
-* magit-branch-prefer-remote-upstream:   The Branch Popup.    (line 258)
-* magit-branch-read-upstream-first:      The Branch Popup.    (line 252)
-* magit-buffer-name-format:              Naming Buffers.      (line  27)
-* magit-bury-buffer-function:            Quitting Windows.    (line  11)
-* magit-cherry-margin:                   Cherries.            (line  22)
-* magit-clone-set-remote.pushDefault:    Repository Setup.    (line  23)
-* magit-commit-ask-to-stage:             Initiating a Commit. (line  74)
-* magit-commit-extend-override-date:     Initiating a Commit. (line  79)
-* magit-commit-reword-override-date:     Initiating a Commit. (line  83)
-* magit-commit-squash-confirm:           Initiating a Commit. (line  87)
-* magit-completing-read-function:        Support for Completion Frameworks.
-                                                              (line  27)
-* magit-diff-adjust-tab-width:           Diff Options.        (line  16)
-* magit-diff-buffer-file-locked:         Minor Mode for Buffers Visiting Files.
-                                                              (line  52)
-* magit-diff-hide-trailing-cr-characters: Diff Options.       (line  67)
-* magit-diff-highlight-hunk-region-functions: Diff Options.   (line  71)
-* magit-diff-highlight-indentation:      Diff Options.        (line  52)
-* magit-diff-highlight-trailing:         Diff Options.        (line  47)
-* magit-diff-paint-whitespace:           Diff Options.        (line  38)
-* magit-diff-refine-hunk:                Diff Options.        (line   6)
-* magit-diff-unmarked-lines-keep-foreground: Diff Options.    (line  97)
-* magit-diff-visit-previous-blob:        Diff Buffer.         (line  37)
-* magit-display-buffer-function:         Switching Buffers.   (line  23)
-* magit-display-buffer-noselect:         Switching Buffers.   (line  14)
-* magit-dwim-selection:                  Completion and Confirmation.
-                                                              (line  42)
-* magit-ediff-dwim-show-on-hunks:        Ediffing.            (line  73)
-* magit-ediff-quit-hook:                 Ediffing.            (line  88)
-* magit-ediff-show-stash-with-index:     Ediffing.            (line  81)
-* magit-file-mode:                       Minor Mode for Buffers Visiting Files.
-                                                              (line  11)
-* magit-generate-buffer-name-function:   Naming Buffers.      (line   6)
-* magit-git-debug:                       Viewing Git Output.  (line  28)
-* magit-git-debug <1>:                   Getting a Value from Git.
-                                                              (line  64)
-* magit-git-executable:                  Git Executable.      (line  39)
-* magit-git-global-arguments:            Global Git Arguments.
-                                                              (line   6)
-* magit-keep-region-overlay:             The Selection.       (line  52)
-* magit-list-refs-sortby:                Additional Completion Options.
-                                                              (line   6)
-* magit-log-auto-more:                   Log Buffer.          (line  67)
-* magit-log-buffer-file-locked:          Minor Mode for Buffers Visiting Files.
-                                                              (line  75)
-* magit-log-margin:                      Log Margin.          (line  12)
-* magit-log-section-args:                Status Options.      (line  36)
-* magit-log-section-commit-count:        Status Sections.     (line 120)
-* magit-log-select-margin:               Select from Log.     (line  30)
-* magit-log-show-refname-after-summary:  Log Buffer.          (line  73)
-* magit-module-sections-hook:            Status Module Sections.
-                                                              (line  20)
-* magit-module-sections-nested:          Status Module Sections.
-                                                              (line  24)
-* magit-no-confirm:                      Action Confirmation. (line  18)
-* magit-pop-revision-stack-format:       Editing Commit Messages.
-                                                              (line  92)
-* magit-post-display-buffer-hook:        Switching Buffers.   (line  92)
-* magit-pre-display-buffer-hook:         Switching Buffers.   (line  81)
-* magit-prefer-remote-upstream:          The Branch Config Popup.
-                                                              (line 139)
-* magit-process-raise-error:             Calling Git for Effect.
-                                                              (line 151)
-* magit-push-current-set-remote-if-missing: Pushing.          (line  96)
-* magit-reflog-margin:                   Reflog.              (line  23)
-* magit-refresh-args:                    Refreshing Buffers.  (line  55)
-* magit-refresh-buffer-hook:             Automatic Refreshing of Magit Buffers.
-                                                              (line  40)
-* magit-refresh-function:                Refreshing Buffers.  (line  49)
-* magit-refresh-status-buffer:           Automatic Refreshing of Magit Buffers.
-                                                              (line  46)
-* magit-refs-filter-alist:               References Buffer.   (line 149)
-* magit-refs-focus-column-width:         References Buffer.   (line  74)
-* magit-refs-margin:                     References Buffer.   (line  89)
-* magit-refs-margin-for-tags:            References Buffer.   (line 115)
-* magit-refs-pad-commit-counts:          References Buffer.   (line  41)
-* magit-refs-primary-column-width:       References Buffer.   (line  61)
-* magit-refs-sections-hook:              References Sections. (line  13)
-* magit-refs-show-commit-count:          References Buffer.   (line  29)
-* magit-refs-show-remote-prefix:         References Buffer.   (line  54)
-* magit-remote-add-set-remote.pushDefault: The Remote Popup.  (line  77)
-* magit-remote-popup-show-variables:     The Remote Popup.    (line  18)
-* magit-repolist-columns:                Repository List.     (line  14)
-* magit-repository-directories:          Status Buffer.       (line  30)
-* magit-repository-directories-depth:    Status Buffer.       (line  40)
-* magit-revision-insert-related-refs:    Revision Buffer.     (line   6)
-* magit-revision-show-gravatar:          Revision Buffer.     (line  10)
-* magit-revision-use-hash-sections:      Revision Buffer.     (line  26)
-* magit-root-section:                    Matching Sections.   (line  80)
-* magit-save-repository-buffers:         Automatic Saving of File-Visiting Buffers.
-                                                              (line  13)
-* magit-section-cache-visibility:        Section Visibility.  (line  95)
-* magit-section-initial-visibility-alist: Section Visibility. (line  78)
-* magit-section-movement-hook:           Section Movement.    (line  38)
-* magit-section-set-visibility-hook:     Section Visibility.  (line 106)
-* magit-section-show-child-count:        Section Options.     (line   9)
-* magit-shell-command-verbose-prompt:    Running Git Manually.
-                                                              (line  46)
-* magit-stashes-margin:                  Stashing.            (line 103)
-* magit-status-headers-hook:             Status Header Sections.
-                                                              (line  18)
-* magit-status-margin:                   Status Options.      (line  10)
-* magit-status-refresh-hook:             Status Options.      (line   6)
-* magit-status-sections-hook:            Status Sections.     (line  10)
-* magit-submodule-list-columns:          Listing Submodules.  (line  21)
-* magit-this-process:                    Calling Git for Effect.
-                                                              (line 146)
-* magit-uniquify-buffer-names:           Naming Buffers.      (line  74)
-* magit-unstage-committed:               Staging and Unstaging.
-                                                              (line  56)
-* magit-update-other-window-delay:       Section Movement.    (line  89)
-* magit-use-sticky-arguments:            Popup Buffers and Prefix Commands.
-                                                              (line  36)
-* magit-visit-ref-behavior:              References Buffer.   (line 177)
-* magit-wip-after-apply-mode:            Wip Modes.           (line 126)
-* magit-wip-after-apply-mode-lighter:    Wip Modes.           (line 186)
-* magit-wip-after-save-local-mode-lighter: Wip Modes.         (line 182)
-* magit-wip-after-save-mode:             Wip Modes.           (line 120)
-* magit-wip-before-change-mode:          Wip Modes.           (line 140)
-* magit-wip-before-change-mode-lighter:  Wip Modes.           (line 190)
-* magit-wip-merge-branch:                Wip Modes.           (line  63)
-* magit-wip-namespace:                   Wip Modes.           (line 194)
-* notes.displayRef:                      Notes.               (line  64)
-* pull.rebase:                           The Branch Config Popup.
-                                                              (line  70)
-* remote.NAME.fetch:                     The Remote Config Popup.
-                                                              (line  25)
-* remote.NAME.push:                      The Remote Config Popup.
-                                                              (line  36)
-* remote.NAME.pushurl:                   The Remote Config Popup.
-                                                              (line  30)
-* remote.NAME.tagOpts:                   The Remote Config Popup.
-                                                              (line  41)
-* remote.NAME.url:                       The Remote Config Popup.
-                                                              (line  20)
-* remote.pushDefault:                    The Branch Config Popup.
-                                                              (line  84)
-