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 &optional condition multiple
|
|
Return a list of the selected sections.
|
|
When the region is active and constitutes a valid section
|
selection, then return a list of all selected sections. This is
|
the case when the region begins in the heading of a section and
|
ends in the heading of the same section or in that of a sibling
|
section. If optional MULTIPLE is non-nil, then the region cannot
|
begin and end in the same section.
|
|
When the selection is not valid, then return nil. In this case,
|
most commands that can act on the selected sections will instead
|
act on the section at point.
|
|
When the region looks like it would in any other buffer then the
|
selection is invalid. When the selection is valid then the region
|
uses the ‘magit-section-highlight’ face. This does not apply to
|
diffs where things get a bit more complicated, but even here if the
|
region looks like it usually does, then that’s not a valid
|
selection as far as this function is concerned.
|
|
If optional CONDITION is non-nil, then the selection not only has
|
to be valid; all selected sections additionally have to match
|
CONDITION, or nil is returned. See ‘magit-section-match’ for the
|
forms CONDITION can take.
|
|
-- Function: magit-region-values &optional condition multiple
|
|
Return a list of the values of the selected sections.
|
|
Return the values that themselves would be returned by
|
‘magit-region-sections’ (which see).
|
|
|
File: magit.info, Node: Matching Sections, Prev: Section Selection, Up: Section Plumbing
|
|
10.2.3 Matching Sections
|
------------------------
|
|
‘M-x magit-describe-section-briefly’ (‘magit-describe-section-briefly’)
|
|
Show information about the section at point. This command is
|
intended for debugging purposes.
|
|
-- Function: magit-section-ident section
|
|
Return an unique identifier for SECTION. The return value has the
|
form ‘((TYPE . VALUE)...)’.
|
|
-- Function: magit-get-section ident &optional root
|
|
Return the section identified by IDENT. IDENT has to be a list as
|
returned by ‘magit-section-ident’.
|
|
-- Function: magit-section-match condition &optional section
|
|
Return ‘t’ if SECTION matches CONDITION. SECTION defaults to the
|
section at point. If SECTION is not specified and there also is no
|
section at point, then return ‘nil’.
|
|
CONDITION can take the following forms:
|
• ‘(CONDITION...)’
|
|
matches if any of the CONDITIONs matches.
|
|
• ‘[CLASS...]’
|
|
matches if the section’s class is the same as the first CLASS
|
or a subclass of that; the section’s parent class matches the
|
second CLASS; and so on.
|
|
• ‘[* CLASS...]’
|
|
matches sections that match ‘[CLASS...]’ and also recursively
|
all their child sections.
|
|
• ‘CLASS’
|
|
matches if the section’s class is the same as CLASS or a
|
subclass of that; regardless of the classes of the parent
|
sections.
|
|
Each CLASS should be a class symbol, identifying a class that
|
derives from ‘magit-section’. For backward compatibility CLASS can
|
also be a "type symbol". A section matches such a symbol if the
|
value of its ‘type’ slot is ‘eq’. If a type symbol has an entry in
|
‘magit--section-type-alist’, then a section also matches that type
|
if its class is a subclass of the class that corresponds to the
|
type as per that alist.
|
|
Note that it is not necessary to specify the complete section
|
lineage as printed by ‘magit-describe-section-briefly’, unless of
|
course you want to be that precise.
|
|
-- Function: magit-section-value-if condition &optional section
|
|
If the section at point matches CONDITION, then return its value.
|
|
If optional SECTION is non-nil then test whether that matches
|
instead. If there is no section at point and SECTION is nil, then
|
return nil. If the section does not match, then return nil.
|
|
See ‘magit-section-match’ for the forms CONDITION can take.
|
|
-- Function: magit-section-case &rest clauses
|
|
Choose among clauses on the type of the section at point.
|
|
Each clause looks like (CONDITION BODY...). The type of the
|
section is compared against each CONDITION; the BODY forms of the
|
first match are evaluated sequentially and the value of the last
|
form is returned. Inside BODY the symbol ‘it’ is bound to the
|
section at point. If no clause succeeds or if there is no section
|
at point return nil.
|
|
See ‘magit-section-match’ for the forms CONDITION can take.
|
Additionally a CONDITION of t is allowed in the final clause and
|
matches if no other CONDITION match, even if there is no section at
|
point.
|
|
-- Variable: magit-root-section
|
|
The root section in the current buffer. All other sections are
|
descendants of this section. The value of this variable is set by
|
‘magit-insert-section’ and you should never modify it.
|
|
For diff related sections a few additional tools exist.
|
|
-- Function: magit-diff-type &optional section
|
|
Return the diff type of SECTION.
|
|
The returned type is one of the symbols ‘staged’, ‘unstaged’,
|
‘committed’, or ‘undefined’. This type serves a similar purpose as
|
the general type common to all sections (which is stored in the
|
‘type’ slot of the corresponding ‘magit-section’ struct) but takes
|
additional information into account. When the SECTION isn’t
|
related to diffs and the buffer containing it also isn’t a
|
diff-only buffer, then return nil.
|
|
Currently the type can also be one of ‘tracked’ and ‘untracked’,
|
but these values are not handled explicitly in every place they
|
should be. A possible fix could be to just return nil here.
|
|
The section has to be a ‘diff’ or ‘hunk’ section, or a section
|
whose children are of type ‘diff’. If optional SECTION is nil,
|
return the diff type for the current section. In buffers whose
|
major mode is ‘magit-diff-mode’ SECTION is ignored and the type is
|
determined using other means. In ‘magit-revision-mode’ buffers the
|
type is always ‘committed’.
|
|
-- Function: magit-diff-scope &optional section strict
|
|
Return the diff scope of SECTION or the selected section(s).
|
|
A diff’s "scope" describes what part of a diff is selected, it is a
|
symbol, one of ‘region’, ‘hunk’, ‘hunks’, ‘file’, ‘files’, or
|
‘list’. Do not confuse this with the diff "type", as returned by
|
‘magit-diff-type’.
|
|
If optional SECTION is non-nil, then return the scope of that,
|
ignoring the sections selected by the region. Otherwise return the
|
scope of the current section, or if the region is active and
|
selects a valid group of diff related sections, the type of these
|
sections, i.e. ‘hunks’ or ‘files’. If SECTION (or if the current
|
section that is nil) is a ‘hunk’ section and the region starts and
|
ends inside the body of a that section, then the type is ‘region’.
|
|
If optional STRICT is non-nil then return nil if the diff type of
|
the section at point is ‘untracked’ or the section at point is not
|
actually a ‘diff’ but a ‘diffstat’ section.
|
|
|
File: magit.info, Node: Refreshing Buffers, Next: Conventions, Prev: Section Plumbing, Up: Plumbing
|
|
10.3 Refreshing Buffers
|
=======================
|
|
All commands that create a new Magit buffer or change what is being
|
displayed in an existing buffer do so by calling ‘magit-mode-setup’.
|
Among other things, that function sets the buffer local values of
|
‘default-directory’ (to the top-level of the repository),
|
‘magit-refresh-function’, and ‘magit-refresh-args’.
|
|
Buffers are refreshed by calling the function that is the local value
|
of ‘magit-refresh-function’ (a function named ‘magit-*-refresh-buffer’,
|
where ‘*’ may be something like ‘diff’) with the value of
|
‘magit-refresh-args’ as arguments.
|
|
-- Macro: magit-mode-setup buffer switch-func mode refresh-func
|
&optional refresh-args
|
|
This function displays and selects BUFFER, turns on MODE, and
|
refreshes a first time.
|
|
This function displays and optionally selects BUFFER by calling
|
‘magit-mode-display-buffer’ with BUFFER, MODE and SWITCH-FUNC as
|
arguments. Then it sets the local value of
|
‘magit-refresh-function’ to REFRESH-FUNC and that of
|
‘magit-refresh-args’ to REFRESH-ARGS. Finally it creates the
|
buffer content by calling REFRESH-FUNC with REFRESH-ARGS as
|
arguments.
|
|
All arguments are evaluated before switching to BUFFER.
|
|
-- Function: magit-mode-display-buffer buffer mode &optional
|
switch-function
|
|
This function display BUFFER in some window and select it. BUFFER
|
may be a buffer or a string, the name of a buffer. The buffer is
|
returned.
|
|
Unless BUFFER is already displayed in the selected frame, store the
|
previous window configuration as a buffer local value, so that it
|
can later be restored by ‘magit-mode-bury-buffer’.
|
|
The buffer is displayed and selected using SWITCH-FUNCTION. If
|
that is ‘nil’ then ‘pop-to-buffer’ is used if the current buffer’s
|
major mode derives from ‘magit-mode’. Otherwise ‘switch-to-buffer’
|
is used.
|
|
-- Variable: magit-refresh-function
|
|
The value of this buffer-local variable is the function used to
|
refresh the current buffer. It is called with ‘magit-refresh-args’
|
as arguments.
|
|
-- Variable: magit-refresh-args
|
|
The list of arguments used by ‘magit-refresh-function’ to refresh
|
the current buffer. ‘magit-refresh-function’ is called with these
|
arguments.
|
|
The value is usually set using ‘magit-mode-setup’, but in some
|
cases it’s also useful to provide commands 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
|
**************************
|
|
[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 80)
|
* 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 109)
|
* 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 99)
|
* 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 88)
|
* 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 105)
|
* 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 44)
|
* X h: Resetting. (line 26)
|
* X i: Resetting. (line 31)
|
* X m: Resetting. (line 15)
|
* X s: Resetting. (line 20)
|
* X w: Resetting. (line 38)
|
* X w <1>: Wip Modes. (line 66)
|
* 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
|
************************
|
|
[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-addition: Blaming. (line 17)
|
* magit-blame-addition <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-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-create: The Branch Popup. (line 45)
|
* 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: Auxiliary Branch Commands.
|
(line 8)
|
* magit-branch-spinoff: The Branch Popup. (line 85)
|
* magit-branch-unshelve: Auxiliary 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-copy: Cherry Picking. (line 16)
|
* magit-cherry-donate: Cherry Picking. (line 53)
|
* magit-cherry-harvest: Cherry Picking. (line 41)
|
* 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-amend: Initiating a Commit. (line 18)
|
* magit-commit-augment: Initiating a Commit. (line 66)
|
* magit-commit-create: Initiating a Commit. (line 13)
|
* 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-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 80)
|
* 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-range: Diffing. (line 29)
|
* 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-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-other: Fetching. (line 24)
|
* magit-fetch-popup: Fetching. (line 11)
|
* magit-fetch-refspec: Fetching. (line 33)
|
* magit-file-checkout: Resetting. (line 44)
|
* 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 99)
|
* 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-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-other: Logging. (line 39)
|
* 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 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-plain: Merging. (line 17)
|
* 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-branch: 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-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-other: Pushing. (line 39)
|
* 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-abort: Rebasing. (line 107)
|
* magit-rebase-autosquash: Rebasing. (line 73)
|
* magit-rebase-branch: Rebasing. (line 33)
|
* 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-hard: Resetting. (line 26)
|
* magit-reset-index: Staging and Unstaging.
|
(line 87)
|
* magit-reset-index <1>: Resetting. (line 31)
|
* magit-reset-mixed: Resetting. (line 15)
|
* magit-reset-quickly: Resetting. (line 8)
|
* magit-reset-soft: Resetting. (line 20)
|
* magit-reset-worktree: Resetting. (line 38)
|
* magit-reset-worktree <1>: Wip Modes. (line 66)
|
* magit-reverse: Applying. (line 44)
|
* magit-reverse-in-index: Staging and Unstaging.
|
(line 62)
|
* magit-revert-and-commit: 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-both: 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-apply: Stashing. (line 58)
|
* magit-stash-both: Stashing. (line 13)
|
* 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-create: 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 88)
|
* magit-wip-log: Wip Modes. (line 48)
|
* magit-wip-log-current: Wip Modes. (line 57)
|
* 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 109)
|
* scroll-up: Diff Buffer. (line 105)
|
* 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
|
*************************
|
|
[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-addition: 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: Auxiliary Branch Commands.
|
(line 8)
|
* magit-branch-unshelve: Auxiliary 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 118)
|
* magit-diff-type: Matching Sections. (line 95)
|
* 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 37)
|
* 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 71)
|
* magit-section-hide: Section Visibility. (line 49)
|
* magit-section-hide-children: Section Visibility. (line 64)
|
* magit-section-ident: Matching Sections. (line 11)
|
* magit-section-match: Matching Sections. (line 21)
|
* magit-section-set-window-start: Section Movement. (line 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-value-if: Matching Sections. (line 61)
|
* magit-start-git: Calling Git for Effect.
|
(line 105)
|
* magit-start-process: Calling Git for Effect.
|
(line 124)
|
* magit-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-log: Wip Modes. (line 48)
|
* magit-wip-log-current: Wip Modes. (line 57)
|
* with-editor-usage-message: Editing Commit Messages.
|
(line 215)
|
|
|
File: magit.info, Node: Variable Index, Prev: Function Index, Up: Top
|
|
Appendix F Variable Index
|
*************************
|
|
[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-log-trace-definition-function: Diff Buffer. (line 74)
|
* 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-gravatars: Revision Buffer. (line 19)
|
* magit-revision-use-hash-sections: Revision Buffer. (line 36)
|
* magit-root-section: Matching Sections. (line 87)
|
* magit-save-repository-buffers: Automatic Saving of File-Visiting Buffers.
|
(line 13)
|
* magit-section-cache-visibility: Section Visibility. (line 95)
|
* magit-section-initial-visibility-alist: Section Visibility. (line 78)
|
* magit-section-movement-hook: Section Movement. (line 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: Legacy Wip Modes. (line 19)
|
* magit-wip-after-apply-mode-lighter: Legacy Wip Modes. (line 59)
|
* magit-wip-after-save-local-mode-lighter: Legacy Wip Modes. (line 55)
|
* magit-wip-after-save-mode: Legacy Wip Modes. (line 13)
|
* magit-wip-before-change-mode: Legacy Wip Modes. (line 33)
|
* magit-wip-before-change-mode-lighter: Legacy Wip Modes. (line 63)
|
* magit-wip-initial-backup-mode: Legacy Wip Modes. (line 38)
|
* magit-wip-initial-backup-mode-lighter: Legacy Wip Modes. (line 67)
|
* magit-wip-merge-branch: Wip Graph. (line 6)
|
* magit-wip-mode: Wip Modes. (line 30)
|
* magit-wip-mode-lighter: Wip Modes. (line 104)
|
* magit-wip-namespace: Wip Modes. (line 96)
|
* notes.displayRef: Notes. (line 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)
|
