my-emacs-d/elpa/magit-20161001.1454/magit.info-2
Gergely Polonkai 449ebf466d Update packages
2016-10-03 13:57:29 +02:00

820 lines
55 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 is magit.info, produced by makeinfo version 5.2 from magit.texi.
Magit is an interface to the version control system Git, implemented as
an Emacs package. Magit aspires to be a complete Git porcelain. While
we cannot (yet) claim that Magit wraps and improves upon each and every
Git command, it is complete enough to allow even experienced Git users
to perform almost all of their daily version control tasks directly from
within Emacs. While many fine Git clients exist, only Magit and Git
itself deserve to be called porcelains.
Copyright (C) 2015-2016 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: Command Index, Next: Function Index, Prev: Keystroke Index, Up: Top
Appendix C 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-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 31)
* magit-am-apply-maildir: Applying patches. (line 19)
* magit-am-apply-patches: Applying patches. (line 13)
* magit-am-continue: Applying patches. (line 23)
* magit-am-popup: Applying patches. (line 8)
* magit-am-skip: Applying patches. (line 27)
* 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 8)
* magit-blame-copy-hash: Blaming. (line 75)
* magit-blame-next-chunk: Blaming. (line 54)
* magit-blame-next-chunk-same-commit: Blaming. (line 58)
* magit-blame-popup: Blaming. (line 24)
* magit-blame-popup <1>: Minor mode for buffers visiting files.
(line 76)
* magit-blame-previous-chunk: Blaming. (line 62)
* magit-blame-previous-chunk-same-commit: Blaming. (line 66)
* magit-blame-quit: Blaming. (line 70)
* magit-blame-toggle-headings: Blaming. (line 82)
* 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 37)
* magit-branch-and-checkout: The branch popup. (line 47)
* magit-branch-delete: The branch popup. (line 99)
* magit-branch-orphan: The branch popup. (line 196)
* magit-branch-popup: The branch popup. (line 12)
* magit-branch-popup <1>: The branch config popup.
(line 6)
* magit-branch-rename: The branch popup. (line 105)
* magit-branch-reset: The branch popup. (line 82)
* magit-branch-spinoff: The branch popup. (line 54)
* magit-checkout: The branch popup. (line 29)
* magit-checkout-file: Resetting. (line 37)
* magit-cherry: Logging. (line 62)
* 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-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 62)
* magit-diff-dwim: Diffing. (line 25)
* magit-diff-flip-revs: Refreshing diffs. (line 45)
* magit-diff-less-context: Refreshing diffs. (line 54)
* magit-diff-more-context: Refreshing diffs. (line 58)
* 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 44)
* magit-diff-show-or-scroll-down <2>: Editing rebase sequences.
(line 28)
* magit-diff-show-or-scroll-up: Log Buffer. (line 33)
* magit-diff-show-or-scroll-up <1>: Blaming. (line 34)
* magit-diff-show-or-scroll-up <2>: Editing rebase sequences.
(line 21)
* magit-diff-staged: Diffing. (line 49)
* magit-diff-switch-range-type: Refreshing diffs. (line 40)
* 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 21)
* magit-diff-while-committing: Refreshing diffs. (line 70)
* magit-diff-while-committing <1>: Editing commit messages.
(line 57)
* magit-diff-worktree: 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-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-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 19)
* magit-go-backward: Log Buffer. (line 19)
* magit-go-backward <1>: Refreshing diffs. (line 80)
* magit-go-forward: Log Buffer. (line 23)
* magit-go-forward <1>: Refreshing diffs. (line 84)
* magit-init: Repository setup. (line 6)
* magit-jump-to-diffstat-or-diff: Diff buffer. (line 38)
* 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 37)
* magit-log-all: Logging. (line 56)
* magit-log-all-branches: Logging. (line 52)
* magit-log-branches: Logging. (line 48)
* magit-log-buffer-file: Logging. (line 67)
* magit-log-buffer-file <1>: Minor mode for buffers visiting files.
(line 65)
* magit-log-buffer-file-popup: Minor mode for buffers visiting files.
(line 58)
* magit-log-bury-buffer: Log Buffer. (line 12)
* magit-log-current: Logging. (line 31)
* magit-log-double-commit-limit: Log Buffer. (line 59)
* magit-log-half-commit-limit: Log Buffer. (line 63)
* magit-log-head: Logging. (line 44)
* magit-log-move-to-parent: Log Buffer. (line 27)
* magit-log-popup: Logging. (line 26)
* 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 14)
* magit-log-select-quit: Select from log. (line 20)
* magit-log-set-default-arguments: Refreshing logs. (line 21)
* magit-log-toggle-commit-limit: Log Buffer. (line 53)
* 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-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 34)
* magit-rebase-abort: Rebasing. (line 96)
* magit-rebase-autosquash: Rebasing. (line 66)
* magit-rebase-continue: Rebasing. (line 81)
* magit-rebase-edit: Rebasing. (line 92)
* magit-rebase-edit-commit: Rebasing. (line 70)
* magit-rebase-interactive: Rebasing. (line 62)
* magit-rebase-onto-pushremote: Rebasing. (line 25)
* magit-rebase-onto-upstream: Rebasing. (line 30)
* magit-rebase-popup: Rebasing. (line 9)
* magit-rebase-reword-commit: Rebasing. (line 74)
* magit-rebase-skip: Rebasing. (line 88)
* magit-rebase-subset: Rebasing. (line 40)
* 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: Remotes. (line 13)
* magit-remote-popup: Remotes. (line 8)
* magit-remote-remove: Remotes. (line 28)
* magit-remote-rename: Remotes. (line 18)
* magit-remote-set-url: Remotes. (line 23)
* magit-request-pull: Creating and sending patches.
(line 17)
* magit-reset: Resetting. (line 8)
* magit-reset-hard: Resetting. (line 32)
* magit-reset-head: Resetting. (line 21)
* magit-reset-index: Staging and unstaging.
(line 88)
* magit-reset-index <1>: Resetting. (line 14)
* magit-reset-soft: Resetting. (line 26)
* magit-reverse: Applying. (line 44)
* magit-reverse-in-index: Staging and unstaging.
(line 63)
* 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 59)
* magit-run-gitk: Running Git manually.
(line 47)
* magit-run-gitk-all: Running Git manually.
(line 51)
* magit-run-gitk-branches: Running Git manually.
(line 55)
* 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 51)
* magit-section-hide-children: Section visibility. (line 66)
* magit-section-show: Section visibility. (line 47)
* magit-section-show-children: Section visibility. (line 60)
* magit-section-show-headings: Section visibility. (line 55)
* magit-section-show-level-1: Section visibility. (line 26)
* magit-section-show-level-1-all: Section visibility. (line 34)
* magit-section-show-level-2: Section visibility. (line 27)
* magit-section-show-level-2-all: Section visibility. (line 35)
* magit-section-show-level-3: Section visibility. (line 28)
* magit-section-show-level-3-all: Section visibility. (line 36)
* magit-section-show-level-4: Section visibility. (line 29)
* magit-section-show-level-4-all: Section visibility. (line 37)
* magit-section-toggle: Section visibility. (line 9)
* magit-section-toggle-children: Section visibility. (line 70)
* 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 38)
* magit-shell-command-topdir: Running Git manually.
(line 33)
* magit-show-commit: Diffing. (line 67)
* magit-show-commit <1>: Blaming. (line 29)
* 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 29)
* 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 37)
* magit-stash: Stashing. (line 13)
* magit-stash-apply: Stashing. (line 58)
* magit-stash-branch: Stashing. (line 84)
* magit-stash-clear: Stashing. (line 92)
* magit-stash-drop: Stashing. (line 71)
* magit-stash-format-patch: Stashing. (line 88)
* magit-stash-index: Stashing. (line 20)
* magit-stash-keep-index: Stashing. (line 32)
* magit-stash-list: Stashing. (line 76)
* magit-stash-pop: Stashing. (line 64)
* magit-stash-popup: Stashing. (line 8)
* magit-stash-show: Diffing. (line 72)
* magit-stash-show <1>: Stashing. (line 80)
* 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-tree-popup: Subtree. (line 8)
* magit-unstage: Staging and unstaging.
(line 44)
* magit-unstage-all: Staging and unstaging.
(line 53)
* 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-visit-ref: References buffer. (line 99)
* 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 48)
* scroll-up: Diff buffer. (line 44)
* with-editor-cancel: Editing commit messages.
(line 24)
* with-editor-cancel <1>: Editing rebase sequences.
(line 11)
* 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 D 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-orphan: The branch popup. (line 196)
* magit-branch-popup: The branch config popup.
(line 6)
* 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 106)
* magit-diff-type: Matching sections. (line 83)
* 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 37)
* magit-insert-error-header: Status header sections.
(line 27)
* magit-insert-head-branch-header: Status header sections.
(line 41)
* 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-unpulled-from-pushremote: Status sections.
(line 124)
* magit-insert-modules-unpulled-from-upstream: Status sections.
(line 118)
* magit-insert-modules-unpushed-to-pushremote: Status sections.
(line 136)
* magit-insert-modules-unpushed-to-upstream: Status sections. (line 130)
* magit-insert-push-branch-header: Status header sections.
(line 50)
* 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 65)
* magit-insert-repo-header: Status header sections.
(line 61)
* 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 11)
* magit-insert-submodules: Status sections. (line 142)
* magit-insert-submodules <1>: Listing submodules. (line 34)
* magit-insert-tags: References sections. (line 25)
* magit-insert-tags-header: Status header sections.
(line 55)
* magit-insert-tracked-files: Status sections. (line 96)
* magit-insert-unpulled-cherries: Status sections. (line 152)
* 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 159)
* 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 45)
* magit-insert-user-header: Status header sections.
(line 73)
* 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-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 59)
* magit-section-hide: Section visibility. (line 51)
* magit-section-hide-children: Section visibility. (line 66)
* 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 47)
* magit-section-show-children: Section visibility. (line 60)
* magit-section-show-headings: Section visibility. (line 55)
* magit-section-show-level-1: Section visibility. (line 26)
* magit-section-show-level-1-all: Section visibility. (line 34)
* magit-section-show-level-2: Section visibility. (line 27)
* magit-section-show-level-2-all: Section visibility. (line 35)
* magit-section-show-level-3: Section visibility. (line 28)
* magit-section-show-level-3-all: Section visibility. (line 36)
* magit-section-show-level-4: Section visibility. (line 29)
* magit-section-show-level-4-all: Section visibility. (line 37)
* magit-section-toggle-children: Section visibility. (line 70)
* magit-section-when: Matching sections. (line 49)
* 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 E 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 100)
* magit-blame-heading-format: Blaming. (line 86)
* magit-blame-show-headings: Blaming. (line 94)
* magit-blame-time-format: Blaming. (line 90)
* magit-branch-adjust-remote-upstream-alist: The branch popup.
(line 154)
* magit-branch-popup-show-variables: The branch popup. (line 21)
* magit-branch-prefer-remote-upstream: The branch popup. (line 117)
* magit-branch-read-upstream-first: The branch popup. (line 111)
* magit-buffer-name-format: Naming Buffers. (line 27)
* magit-bury-buffer-function: Quitting Windows. (line 11)
* 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 53)
* magit-diff-hide-trailing-cr-characters: Diff options. (line 44)
* magit-diff-highlight-hunk-region-functions: Diff options. (line 48)
* magit-diff-highlight-indentation: Diff options. (line 29)
* magit-diff-highlight-trailing: Diff options. (line 24)
* 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 73)
* 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 36)
* magit-git-global-arguments: Global Git arguments.
(line 6)
* magit-log-auto-more: Log Buffer. (line 67)
* magit-log-buffer-file-locked: Minor mode for buffers visiting files.
(line 71)
* magit-log-section-args: Status options. (line 10)
* magit-log-section-commit-count: Status sections. (line 112)
* magit-log-show-margin: Log Buffer. (line 73)
* magit-log-show-refname-after-summary: Log Buffer. (line 85)
* magit-no-confirm: Completion and confirmation.
(line 42)
* 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-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 88)
* magit-refs-local-branch-format: References buffer. (line 76)
* magit-refs-remote-branch-format: References buffer. (line 80)
* magit-refs-sections-hook: References sections. (line 13)
* magit-refs-show-commit-count: References buffer. (line 29)
* magit-refs-show-margin: References buffer. (line 40)
* magit-refs-tags-format: References buffer. (line 84)
* magit-remote-add-set-remote.pushDefault: Remotes. (line 32)
* 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 75)
* 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 80)
* magit-section-show-child-count: Section options. (line 9)
* magit-status-headers-hook: Status header sections.
(line 17)
* 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 61)
* magit-unstage-committed: Staging and unstaging.
(line 57)
* magit-update-other-window-delay: Section movement. (line 87)
* magit-visit-ref-create: References buffer. (line 115)
* 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.pushDefault: The branch config popup.
(line 83)