zaphar/dotfiles
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity
dotfiles/.emacs.d/elpa/magit-20171030.214/magit.info-2

1445 lines
95 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This is magit.info, produced by makeinfo version 5.2 from magit.texi.
Copyright (C) 2015-2017 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: 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 because then you get colorful output
in terminals but git’s output is consumed by something else, then no
colors are used.
If you actually use some other tool which expects that requires that
you force git to output control sequences (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: Emacs 245 hangs when loading Magit, 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: Emacs 245 hangs when loading Magit, Next: A branch and tag sharing the same name breaks SOMETHING, Prev: The mode-line information isn't always up-to-date, Up: FAQ - Issues and Errors
A.2.10 Emacs 24.5 hangs when loading Magit
------------------------------------------
This is actually triggered by loading Tramp. See
<https://debbugs.gnu.org/cgi/bugreport.cgi?bug=20015> for details. You
can work around the problem by setting
‘tramp-ssh-controlmaster-options’. Changing your DNS server (e.g. to
Google’s ‘8.8.8.8’) may also be sufficient to work around the issue.

File: magit.info, Node: A branch and tag sharing the same name breaks SOMETHING, Prev: Emacs 245 hangs when loading Magit, Up: FAQ - Issues and Errors
A.2.11 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: 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 an 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.
‘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 ‘git’ 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 11)
* +: 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 22)
* A A <1>: Cherry Picking. (line 35)
* A a <1>: Cherry Picking. (line 43)
* A s: Cherry Picking. (line 39)
* B: Bisecting. (line 8)
* b: 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 108)
* b n: The Branch Popup. (line 45)
* B r: Bisecting. (line 47)
* b r: The Branch Popup. (line 114)
* B s: Bisecting. (line 24)
* b s: The Branch Popup. (line 62)
* b x: The Branch Popup. (line 92)
* c: Initiating a Commit. (line 8)
* c <1>: 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 36)
* 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-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: 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 76)
* 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 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 82)
* C-c M-g s: Minor Mode for Buffers Visiting Files.
(line 24)
* 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 63)
* DEL <2>: Blaming. (line 69)
* 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 53)
* k: Viewing Git Output. (line 19)
* 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 57)
* M a: The Remote Popup. (line 35)
* M C: The Remote Popup. (line 26)
* m e: Merging. (line 30)
* M k: The Remote Popup. (line 50)
* m m: Merging. (line 17)
* m m <1>: Merging. (line 52)
* m n: Merging. (line 37)
* m p: Merging. (line 44)
* M r: The Remote Popup. (line 40)
* 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 100)
* M-w <1>: Common Commands. (line 10)
* M-x magit-blame: Blaming. (line 14)
* M-x magit-blame-popup: Blaming. (line 37)
* M-x magit-blame-reverse: Blaming. (line 29)
* 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 27)
* M-x magit-describe-section: Section Types and Values.
(line 13)
* M-x magit-describe-section <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 129)
* M-x with-editor-debug: Debugging Tools. (line 35)
* n: Section Movement. (line 16)
* n <1>: Blaming. (line 79)
* N: Blaming. (line 83)
* 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 11)
* O a: Subtree. (line 20)
* o b: Submodule Popup. (line 17)
* O c: Subtree. (line 24)
* o f: Submodule Popup. (line 35)
* O f: Subtree. (line 32)
* o i: Submodule Popup. (line 22)
* o i <1>: Submodule Popup. (line 39)
* O m: Subtree. (line 28)
* O p: Subtree. (line 36)
* o s: Submodule Popup. (line 31)
* O s: Subtree. (line 41)
* o u: Submodule Popup. (line 26)
* p: Section Movement. (line 10)
* p <1>: Blaming. (line 87)
* P: Blaming. (line 91)
* 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 95)
* 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 6)
* RET <1>: References Buffer. (line 117)
* RET <2>: Blaming. (line 55)
* 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 59)
* SPC <2>: Blaming. (line 59)
* SPC <3>: Editing Rebase Sequences.
(line 21)
* t: Blaming. (line 108)
* t <1>: Tagging. (line 8)
* T: Notes. (line 8)
* T a: Notes. (line 70)
* T c: Notes. (line 65)
* t k: Tagging. (line 18)
* T m: Notes. (line 56)
* t p: Tagging. (line 24)
* T p: Notes. (line 29)
* T r: Notes. (line 21)
* T s: Notes. (line 33)
* T S: Notes. (line 44)
* 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 37)
* X h: Resetting. (line 25)
* X i: Resetting. (line 30)
* X m: Resetting. (line 14)
* X s: Resetting. (line 19)
* 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: Blaming. (line 14)
* magit-blame-copy-hash: Blaming. (line 100)
* magit-blame-next-chunk: Blaming. (line 79)
* magit-blame-next-chunk-same-commit: Blaming. (line 83)
* magit-blame-popup: Blaming. (line 37)
* magit-blame-popup <1>: Minor Mode for Buffers Visiting Files.
(line 76)
* magit-blame-previous-chunk: Blaming. (line 87)
* magit-blame-previous-chunk-same-commit: Blaming. (line 91)
* magit-blame-quit: Blaming. (line 95)
* magit-blame-reverse: Blaming. (line 29)
* magit-blame-toggle-headings: Blaming. (line 108)
* magit-blob-next: Minor Mode for Buffers Visiting Blobs.
(line 16)
* magit-blob-previous: Minor Mode for Buffers Visiting Files.
(line 82)
* magit-blob-previous <1>: Minor Mode for Buffers Visiting Blobs.
(line 12)
* magit-branch: The Branch Popup. (line 45)
* magit-branch-and-checkout: The Branch Popup. (line 55)
* magit-branch-config-popup: The Branch Popup. (line 29)
* magit-branch-config-popup <1>: The Branch Config Popup.
(line 6)
* magit-branch-delete: The Branch Popup. (line 108)
* magit-branch-or-checkout: The Branch Popup. (line 218)
* magit-branch-orphan: The Branch Popup. (line 213)
* magit-branch-popup: The Branch Popup. (line 12)
* magit-branch-rename: The Branch Popup. (line 114)
* magit-branch-reset: The Branch Popup. (line 92)
* magit-branch-spinoff: The Branch Popup. (line 62)
* magit-checkout: The Branch Popup. (line 37)
* magit-cherry: Cherries. (line 17)
* magit-cherry-apply: Cherry Picking. (line 22)
* magit-cherry-pick: Cherry Picking. (line 16)
* magit-cherry-pick-popup: Cherry Picking. (line 8)
* magit-clone: Repository Setup. (line 16)
* magit-commit: Initiating a Commit. (line 13)
* magit-commit-amend: Initiating a Commit. (line 18)
* magit-commit-augment: Initiating a Commit. (line 66)
* magit-commit-extend: Initiating a Commit. (line 22)
* magit-commit-fixup: Initiating a Commit. (line 42)
* magit-commit-instant-fixup: Initiating a Commit. (line 50)
* magit-commit-instant-squash: Initiating a Commit. (line 62)
* magit-commit-popup: Initiating a Commit. (line 8)
* magit-commit-popup <1>: Minor Mode for Buffers Visiting Files.
(line 33)
* magit-commit-reword: Initiating a Commit. (line 32)
* magit-commit-squash: Initiating a Commit. (line 54)
* magit-copy-buffer-revision: Common Commands. (line 21)
* magit-copy-section-value: Common Commands. (line 10)
* magit-cycle-margin-style: Log Margin. (line 60)
* magit-debug-git-executable: Git Executable. (line 45)
* magit-debug-git-executable <1>: Debugging Tools. (line 27)
* magit-describe-section: Section Types and Values.
(line 13)
* magit-describe-section <1>: Matching Sections. (line 6)
* magit-diff: Diffing. (line 29)
* magit-diff-buffer-file: Minor Mode for Buffers Visiting Files.
(line 47)
* magit-diff-buffer-file-popup: Minor Mode for Buffers Visiting Files.
(line 39)
* magit-diff-default-context: Refreshing Diffs. (line 72)
* magit-diff-dwim: Diffing. (line 25)
* magit-diff-flip-revs: Refreshing Diffs. (line 45)
* magit-diff-less-context: Refreshing Diffs. (line 64)
* magit-diff-more-context: Refreshing Diffs. (line 68)
* magit-diff-paths: Diffing. (line 59)
* magit-diff-popup: Diffing. (line 20)
* magit-diff-refresh: Refreshing Diffs. (line 16)
* magit-diff-refresh-popup: Refreshing Diffs. (line 11)
* magit-diff-save-default-arguments: Refreshing Diffs. (line 28)
* magit-diff-set-default-arguments: Refreshing Diffs. (line 21)
* magit-diff-show-or-scroll-down: Log Buffer. (line 43)
* magit-diff-show-or-scroll-down <1>: Blaming. (line 69)
* magit-diff-show-or-scroll-up: Log Buffer. (line 33)
* magit-diff-show-or-scroll-up <1>: Blaming. (line 59)
* 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-unstaged: Diffing. (line 55)
* magit-diff-visit-file: Diff Buffer. (line 6)
* magit-diff-visit-file-worktree: Diff Buffer. (line 36)
* 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-emacs-Q-command: Debugging Tools. (line 16)
* magit-fetch: Fetching. (line 24)
* magit-fetch-all: Fetching. (line 38)
* magit-fetch-branch: Fetching. (line 28)
* magit-fetch-from-pushremote: Fetching. (line 16)
* magit-fetch-from-upstream: Fetching. (line 20)
* magit-fetch-popup: Fetching. (line 11)
* magit-fetch-refspec: Fetching. (line 33)
* magit-file-checkout: Resetting. (line 37)
* magit-file-popup: Minor Mode for Buffers Visiting Files.
(line 19)
* 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 53)
* 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 12)
* magit-log: Logging. (line 39)
* magit-log-all: Logging. (line 58)
* magit-log-all-branches: Logging. (line 54)
* magit-log-branches: Logging. (line 50)
* magit-log-buffer-file: Minor Mode for Buffers Visiting Files.
(line 64)
* magit-log-buffer-file-popup: Minor Mode for Buffers Visiting Files.
(line 57)
* magit-log-bury-buffer: Log Buffer. (line 12)
* magit-log-current: Logging. (line 33)
* magit-log-double-commit-limit: Log Buffer. (line 59)
* magit-log-half-commit-limit: Log Buffer. (line 63)
* magit-log-head: Logging. (line 46)
* magit-log-move-to-parent: Log Buffer. (line 27)
* magit-log-popup: Logging. (line 28)
* magit-log-refresh: Refreshing Logs. (line 16)
* magit-log-refresh-popup: Refreshing Logs. (line 11)
* magit-log-refresh-popup <1>: Log Buffer. (line 6)
* magit-log-save-default-arguments: Refreshing Logs. (line 28)
* magit-log-select-pick: Select from Log. (line 20)
* magit-log-select-quit: Select from Log. (line 26)
* magit-log-set-default-arguments: Refreshing Logs. (line 21)
* magit-log-toggle-commit-limit: Log Buffer. (line 53)
* magit-margin-popup: Log Margin. (line 47)
* magit-merge: Merging. (line 17)
* magit-merge <1>: Merging. (line 52)
* magit-merge-abort: Merging. (line 57)
* magit-merge-editmsg: Merging. (line 30)
* magit-merge-nocommit: Merging. (line 37)
* magit-merge-popup: Merging. (line 9)
* magit-merge-preview: Merging. (line 44)
* magit-mode-bury-buffer: Quitting Windows. (line 6)
* magit-notes-edit: Notes. (line 13)
* magit-notes-merge: Notes. (line 56)
* magit-notes-merge-abort: Notes. (line 70)
* magit-notes-merge-commit: Notes. (line 65)
* magit-notes-popup: Notes. (line 8)
* magit-notes-prune: Notes. (line 29)
* magit-notes-remove: Notes. (line 21)
* magit-notes-set-display-refs: Notes. (line 44)
* magit-notes-set-ref: Notes. (line 33)
* 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 11)
* magit-process-kill: Viewing Git Output. (line 19)
* magit-pull: Pulling. (line 24)
* magit-pull-from-pushremote: Pulling. (line 16)
* magit-pull-from-upstream: Pulling. (line 20)
* magit-pull-popup: Pulling. (line 11)
* magit-push: Pushing. (line 39)
* magit-push-current: Pushing. (line 35)
* magit-push-current-to-pushremote: Pushing. (line 16)
* magit-push-current-to-upstream: Pushing. (line 26)
* magit-push-implicitly args: Pushing. (line 73)
* magit-push-matching: Pushing. (line 53)
* magit-push-popup: Pushing. (line 11)
* magit-push-refspecs: Pushing. (line 44)
* magit-push-tag: Pushing. (line 65)
* magit-push-tags: Pushing. (line 59)
* magit-push-to-remote remote args: Pushing. (line 84)
* magit-rebase: Rebasing. (line 33)
* magit-rebase-abort: Rebasing. (line 107)
* magit-rebase-autosquash: Rebasing. (line 73)
* magit-rebase-continue: Rebasing. (line 92)
* magit-rebase-edit: Rebasing. (line 103)
* magit-rebase-edit-commit: Rebasing. (line 77)
* magit-rebase-interactive: Rebasing. (line 69)
* magit-rebase-onto-pushremote: Rebasing. (line 24)
* magit-rebase-onto-upstream: Rebasing. (line 29)
* magit-rebase-popup: Rebasing. (line 9)
* magit-rebase-remove-commit: Rebasing. (line 85)
* magit-rebase-reword-commit: Rebasing. (line 81)
* magit-rebase-skip: Rebasing. (line 99)
* magit-rebase-subset: Rebasing. (line 39)
* magit-reflog-current: Reflog. (line 11)
* magit-reflog-head: Reflog. (line 19)
* magit-reflog-other: Reflog. (line 15)
* magit-refresh: Automatic Refreshing of Magit Buffers.
(line 22)
* magit-refresh-all: Automatic Refreshing of Magit Buffers.
(line 31)
* magit-remote-add: The Remote Popup. (line 35)
* magit-remote-config-popup: The Remote Popup. (line 26)
* magit-remote-config-popup <1>: The Remote Config Popup.
(line 6)
* magit-remote-popup: The Remote Popup. (line 13)
* magit-remote-remove: The Remote Popup. (line 50)
* magit-remote-rename: The Remote Popup. (line 40)
* magit-remote-set-url: The Remote Popup. (line 45)
* magit-request-pull: Creating and Sending Patches.
(line 17)
* magit-reset: Resetting. (line 8)
* magit-reset-hard: Resetting. (line 25)
* magit-reset-head: Resetting. (line 14)
* magit-reset-index: Staging and Unstaging.
(line 87)
* magit-reset-index <1>: Resetting. (line 30)
* magit-reset-soft: Resetting. (line 19)
* magit-reverse: Applying. (line 44)
* magit-reverse-in-index: Staging and Unstaging.
(line 62)
* magit-revert: Reverting. (line 14)
* magit-revert-no-commit: Reverting. (line 20)
* magit-revert-popup: Reverting. (line 6)
* magit-run-git-gui: Running Git Manually.
(line 65)
* magit-run-gitk: Running Git Manually.
(line 53)
* magit-run-gitk-all: Running Git Manually.
(line 57)
* magit-run-gitk-branches: Running Git Manually.
(line 61)
* magit-run-popup: Running Git Manually.
(line 12)
* magit-section-backward: Section Movement. (line 10)
* magit-section-backward-siblings: Section Movement. (line 20)
* magit-section-cycle: Section Visibility. (line 13)
* magit-section-cycle-diffs: Section Visibility. (line 17)
* magit-section-cycle-global: Section Visibility. (line 22)
* magit-section-forward: Section Movement. (line 16)
* magit-section-forward-siblings: Section Movement. (line 26)
* magit-section-hide: Section Visibility. (line 49)
* magit-section-hide-children: Section Visibility. (line 64)
* magit-section-show: Section Visibility. (line 45)
* magit-section-show-children: Section Visibility. (line 58)
* magit-section-show-headings: Section Visibility. (line 53)
* magit-section-show-level-1: Section Visibility. (line 26)
* magit-section-show-level-1-all: Section Visibility. (line 33)
* magit-section-show-level-2: Section Visibility. (line 27)
* magit-section-show-level-2-all: Section Visibility. (line 34)
* magit-section-show-level-3: Section Visibility. (line 28)
* magit-section-show-level-3-all: Section Visibility. (line 35)
* magit-section-show-level-4: Section Visibility. (line 29)
* magit-section-show-level-4-all: Section Visibility. (line 36)
* magit-section-toggle: Section Visibility. (line 9)
* magit-section-toggle-children: Section Visibility. (line 68)
* magit-section-up: Section Movement. (line 31)
* magit-sequence-abort: Cherry Picking. (line 43)
* magit-sequence-abort <1>: Reverting. (line 38)
* magit-sequence-continue: Cherry Picking. (line 35)
* magit-sequence-continue <1>: Reverting. (line 30)
* magit-sequence-skip: Cherry Picking. (line 39)
* 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 55)
* magit-show-refs: References Buffer. (line 24)
* magit-show-refs-current: References Buffer. (line 19)
* magit-show-refs-head: References Buffer. (line 14)
* magit-show-refs-popup: References Buffer. (line 6)
* magit-snapshot: Stashing. (line 39)
* magit-snapshot-index: Stashing. (line 46)
* magit-snapshot-worktree: Stashing. (line 51)
* magit-stage: Staging and Unstaging.
(line 28)
* magit-stage-file: Staging from File-Visiting Buffers.
(line 10)
* magit-stage-file <1>: Minor Mode for Buffers Visiting Files.
(line 24)
* magit-stage-modified: Staging and Unstaging.
(line 36)
* magit-stash: Stashing. (line 13)
* magit-stash-apply: Stashing. (line 58)
* magit-stash-branch: Stashing. (line 80)
* magit-stash-branch-here: Stashing. (line 85)
* magit-stash-clear: Stashing. (line 95)
* magit-stash-drop: Stashing. (line 71)
* magit-stash-format-patch: Stashing. (line 91)
* magit-stash-index: Stashing. (line 20)
* magit-stash-keep-index: Stashing. (line 32)
* magit-stash-list: Stashing. (line 99)
* magit-stash-pop: Stashing. (line 64)
* magit-stash-popup: Stashing. (line 8)
* magit-stash-show: Diffing. (line 72)
* magit-stash-show <1>: Stashing. (line 76)
* magit-stash-worktree: Stashing. (line 25)
* magit-status: Status Buffer. (line 22)
* magit-submodule-add: Submodule Popup. (line 11)
* magit-submodule-fetch: Fetching. (line 42)
* magit-submodule-fetch <1>: Submodule Popup. (line 35)
* magit-submodule-init: Submodule Popup. (line 22)
* magit-submodule-init <1>: Submodule Popup. (line 39)
* magit-submodule-popup: Submodule Popup. (line 6)
* magit-submodule-setup: Submodule Popup. (line 17)
* magit-submodule-sync: Submodule Popup. (line 31)
* magit-submodule-update: Submodule Popup. (line 26)
* magit-subtree-add: Subtree. (line 20)
* magit-subtree-add-commit: Subtree. (line 24)
* magit-subtree-merge: Subtree. (line 28)
* magit-subtree-pull: Subtree. (line 32)
* magit-subtree-push: Subtree. (line 36)
* magit-subtree-split: Subtree. (line 41)
* magit-tag: Tagging. (line 13)
* magit-tag-delete: Tagging. (line 18)
* magit-tag-popup: Tagging. (line 8)
* magit-tag-prune: Tagging. (line 24)
* magit-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 117)
* magit-wip-commit: Wip Modes. (line 129)
* magit-wip-log: Wip Modes. (line 69)
* magit-wip-log-current: Wip Modes. (line 77)
* scroll-down: Diff Buffer. (line 63)
* scroll-up: Diff Buffer. (line 59)
* with-editor-cancel: Editing Commit Messages.
(line 24)
* with-editor-cancel <1>: Editing Rebase Sequences.
(line 11)
* with-editor-debug: Debugging Tools. (line 35)
* 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 18)
* magit-after-save-refresh-status: Automatic Refreshing of Magit Buffers.
(line 56)
* magit-branch-config-popup: The Branch Config Popup.
(line 6)
* magit-branch-or-checkout: The Branch Popup. (line 218)
* magit-branch-orphan: The Branch Popup. (line 213)
* magit-builtin-completing-read: Completion and Confirmation.
(line 23)
* 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-current-section: Section Selection. (line 6)
* magit-define-section-jumper: Creating Sections. (line 77)
* magit-diff-scope: Matching Sections. (line 110)
* magit-diff-type: Matching Sections. (line 87)
* 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-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 44)
* magit-ido-completing-read: Completion and Confirmation.
(line 28)
* 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-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 107)
* 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 34)
* 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 118)
* 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 100)
* magit-insert-unpushed-cherries: Status Sections. (line 125)
* 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 12)
* magit-log-maybe-show-more-commits: Section Movement. (line 57)
* magit-log-maybe-update-blob-buffer: Section Movement. (line 69)
* magit-log-maybe-update-revision-buffer: Section Movement. (line 63)
* magit-maybe-set-dedicated: Switching Buffers. (line 97)
* magit-mode-display-buffer: Refreshing Buffers. (line 32)
* magit-mode-quit-window: Quitting Windows. (line 31)
* magit-mode-setup: Refreshing Buffers. (line 17)
* magit-push-implicitly: Pushing. (line 73)
* magit-push-to-remote: Pushing. (line 84)
* magit-region-sections: Section Selection. (line 10)
* magit-region-values: Section Selection. (line 29)
* magit-remote-config-popup: The Remote Config Popup.
(line 6)
* magit-repolist-column-ident: Repository List. (line 30)
* magit-repolist-column-path: Repository List. (line 35)
* magit-repolist-column-unpulled-from-pushremote: Repository List.
(line 49)
* magit-repolist-column-unpulled-from-upstream: Repository List.
(line 44)
* magit-repolist-column-unpushed-to-pushremote: Repository List.
(line 59)
* magit-repolist-column-unpushed-to-upstream: Repository List.
(line 54)
* magit-repolist-column-version: Repository List. (line 39)
* magit-restore-window-configuration: Quitting Windows. (line 20)
* magit-revert-buffers: Editing Commit Messages.
(line 178)
* magit-run-git: Calling Git for Effect.
(line 36)
* magit-run-git-async: Calling Git for Effect.
(line 80)
* magit-run-git-with-editor: Calling Git for Effect.
(line 93)
* magit-run-git-with-input: Calling Git for Effect.
(line 40)
* magit-run-git-with-logfile: Calling Git for Effect.
(line 56)
* magit-save-window-configuration: Switching Buffers. (line 86)
* magit-section-case: Matching Sections. (line 63)
* magit-section-hide: Section Visibility. (line 49)
* magit-section-hide-children: Section Visibility. (line 64)
* magit-section-ident: Matching Sections. (line 11)
* magit-section-match: Matching Sections. (line 21)
* magit-section-set-window-start: Section Movement. (line 50)
* magit-section-show: Section Visibility. (line 45)
* magit-section-show-children: Section Visibility. (line 58)
* magit-section-show-headings: Section Visibility. (line 53)
* magit-section-toggle-children: Section Visibility. (line 68)
* magit-section-when: Matching Sections. (line 51)
* 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 81)
* magit-status-maybe-update-revision-buffer: Section Movement.
(line 75)
* magit-wip-log: Wip Modes. (line 69)
* magit-wip-log-current: Wip Modes. (line 77)
* 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 93)
* branch.autoSetupRebase: The Branch Config Popup.
(line 110)
* 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)
* 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-goto-chunk-hook: Blaming. (line 126)
* magit-blame-heading-format: Blaming. (line 112)
* magit-blame-show-headings: Blaming. (line 120)
* magit-blame-time-format: Blaming. (line 116)
* magit-branch-adjust-remote-upstream-alist: The Branch Popup.
(line 171)
* magit-branch-popup-show-variables: The Branch Popup. (line 21)
* magit-branch-prefer-remote-upstream: The Branch Popup. (line 126)
* magit-branch-read-upstream-first: The Branch Popup. (line 120)
* 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: Completion and Confirmation.
(line 10)
* magit-diff-buffer-file-locked: Minor Mode for Buffers Visiting Files.
(line 52)
* magit-diff-hide-trailing-cr-characters: Diff Options. (line 45)
* magit-diff-highlight-hunk-region-functions: Diff Options. (line 49)
* magit-diff-highlight-indentation: Diff Options. (line 30)
* magit-diff-highlight-trailing: Diff Options. (line 25)
* magit-diff-paint-whitespace: Diff Options. (line 16)
* magit-diff-refine-hunk: Diff Options. (line 6)
* magit-diff-unmarked-lines-keep-foreground: Diff Options. (line 75)
* magit-diff-visit-previous-blob: Diff Buffer. (line 25)
* magit-display-buffer-function: Switching Buffers. (line 23)
* magit-display-buffer-noselect: Switching Buffers. (line 14)
* 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 23)
* 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-list-refs-sortby: Completion and Confirmation.
(line 36)
* magit-log-auto-more: Log Buffer. (line 67)
* magit-log-buffer-file-locked: Minor Mode for Buffers Visiting Files.
(line 71)
* magit-log-margin: Log Margin. (line 12)
* magit-log-section-args: Status Options. (line 36)
* magit-log-section-commit-count: Status Sections. (line 112)
* magit-log-select-margin: Select from Log. (line 30)
* magit-log-show-refname-after-summary: Log Buffer. (line 73)
* magit-no-confirm: Completion and Confirmation.
(line 50)
* 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 138)
* 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 54)
* magit-refresh-buffer-hook: Automatic Refreshing of Magit Buffers.
(line 40)
* magit-refresh-function: Refreshing Buffers. (line 48)
* magit-refresh-status-buffer: Automatic Refreshing of Magit Buffers.
(line 46)
* magit-refs-indent-cherry-lines: References Buffer. (line 112)
* magit-refs-local-branch-format: References Buffer. (line 100)
* magit-refs-margin: References Buffer. (line 40)
* magit-refs-margin-for-tags: References Buffer. (line 66)
* magit-refs-remote-branch-format: References Buffer. (line 104)
* magit-refs-sections-hook: References Sections. (line 13)
* magit-refs-show-commit-count: References Buffer. (line 29)
* magit-refs-tags-format: References Buffer. (line 108)
* magit-remote-add-set-remote.pushDefault: The Remote Popup. (line 54)
* magit-remote-popup-show-variables: The Remote Popup. (line 18)
* magit-repolist-columns: Repository List. (line 14)
* magit-repository-directories: Status Buffer. (line 30)
* magit-repository-directories-depth: Status Buffer. (line 40)
* magit-revision-insert-related-refs: Revision Buffer. (line 6)
* magit-revision-show-gravatar: Revision Buffer. (line 10)
* magit-root-section: Matching Sections. (line 79)
* magit-save-repository-buffers: Automatic Saving of File-Visiting Buffers.
(line 13)
* magit-section-movement-hook: Section Movement. (line 39)
* magit-section-set-visibility-hook: Section Visibility. (line 78)
* 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 20)
* magit-this-process: Calling Git for Effect.
(line 146)
* magit-uniquify-buffer-names: Naming Buffers. (line 66)
* magit-unstage-committed: Staging and Unstaging.
(line 56)
* magit-update-other-window-delay: Section Movement. (line 87)
* magit-use-sticky-arguments: Popup Buffers and Prefix Commands.
(line 36)
* magit-visit-ref-behavior: References Buffer. (line 128)
* magit-wip-after-apply-mode: Wip Modes. (line 99)
* magit-wip-after-apply-mode-lighter: Wip Modes. (line 141)
* magit-wip-after-save-local-mode-lighter: Wip Modes. (line 137)
* magit-wip-after-save-mode: Wip Modes. (line 93)
* magit-wip-before-change-mode: Wip Modes. (line 113)
* magit-wip-before-change-mode-lighter: Wip Modes. (line 145)
* magit-wip-namespace: Wip Modes. (line 149)
* 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 83)
Reference in New Issue View Git Blame Copy Permalink