diff options
Diffstat (limited to 'elpa/magit-20200728.45/magit-autoloads.el')
| -rw-r--r-- | elpa/magit-20200728.45/magit-autoloads.el | 2532 |
1 files changed, 0 insertions, 2532 deletions
diff --git a/elpa/magit-20200728.45/magit-autoloads.el b/elpa/magit-20200728.45/magit-autoloads.el deleted file mode 100644 index aa69e25..0000000 --- a/elpa/magit-20200728.45/magit-autoloads.el +++ /dev/null @@ -1,2532 +0,0 @@ -;;; magit-autoloads.el --- automatically extracted autoloads -;; -;;; Code: - -(add-to-list 'load-path (directory-file-name - (or (file-name-directory #$) (car load-path)))) - - -;;;### (autoloads nil "git-rebase" "git-rebase.el" (0 0 0 0)) -;;; Generated autoloads from git-rebase.el - -(autoload 'git-rebase-current-line "git-rebase" "\ -Parse current line into a `git-rebase-action' instance. -If the current line isn't recognized as a rebase line, an -instance with all nil values is returned. - -\(fn)" nil nil) - -(autoload 'git-rebase-mode "git-rebase" "\ -Major mode for editing of a Git rebase file. - -Rebase files are generated when you run 'git rebase -i' or run -`magit-interactive-rebase'. They describe how Git should perform -the rebase. See the documentation for git-rebase (e.g., by -running 'man git-rebase' at the command line) for details. - -\(fn)" t nil) - -(defconst git-rebase-filename-regexp "/git-rebase-todo\\'") - -(add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp 'git-rebase-mode)) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "git-rebase" '("git-rebase-"))) - -;;;*** - -;;;### (autoloads nil "magit" "magit.el" (0 0 0 0)) -;;; Generated autoloads from magit.el - (autoload 'magit-dispatch "magit" nil t) - (autoload 'magit-run "magit" nil t) - -(autoload 'magit-git-command "magit" "\ -Execute COMMAND asynchronously; display output. - -Interactively, prompt for COMMAND in the minibuffer. \"git \" is -used as initial input, but can be deleted to run another command. - -With a prefix argument COMMAND is run in the top-level directory -of the current working tree, otherwise in `default-directory'. - -\(fn COMMAND)" t nil) - -(autoload 'magit-git-command-topdir "magit" "\ -Execute COMMAND asynchronously; display output. - -Interactively, prompt for COMMAND in the minibuffer. \"git \" is -used as initial input, but can be deleted to run another command. - -COMMAND is run in the top-level directory of the current -working tree. - -\(fn COMMAND)" t nil) - -(autoload 'magit-shell-command "magit" "\ -Execute COMMAND asynchronously; display output. - -Interactively, prompt for COMMAND in the minibuffer. With a -prefix argument COMMAND is run in the top-level directory of -the current working tree, otherwise in `default-directory'. - -\(fn COMMAND)" t nil) - -(autoload 'magit-shell-command-topdir "magit" "\ -Execute COMMAND asynchronously; display output. - -Interactively, prompt for COMMAND in the minibuffer. COMMAND -is run in the top-level directory of the current working tree. - -\(fn COMMAND)" t nil) - -(autoload 'magit-version "magit" "\ -Return the version of Magit currently in use. -If optional argument PRINT-DEST is non-nil, output -stream (interactively, the echo area, or the current buffer with -a prefix argument), also print the used versions of Magit, Git, -and Emacs to it. - -\(fn &optional PRINT-DEST)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-apply" "magit-apply.el" (0 0 0 0)) -;;; Generated autoloads from magit-apply.el - -(autoload 'magit-stage-file "magit-apply" "\ -Stage all changes to FILE. -With a prefix argument or when there is no file at point ask for -the file to be staged. Otherwise stage the file at point without -requiring confirmation. - -\(fn FILE)" t nil) - -(autoload 'magit-stage-modified "magit-apply" "\ -Stage all changes to files modified in the worktree. -Stage all new content of tracked files and remove tracked files -that no longer exist in the working tree from the index also. -With a prefix argument also stage previously untracked (but not -ignored) files. - -\(fn &optional ALL)" t nil) - -(autoload 'magit-unstage-file "magit-apply" "\ -Unstage all changes to FILE. -With a prefix argument or when there is no file at point ask for -the file to be unstaged. Otherwise unstage the file at point -without requiring confirmation. - -\(fn FILE)" t nil) - -(autoload 'magit-unstage-all "magit-apply" "\ -Remove all changes from the staging area. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-apply" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (0 -;;;;;; 0 0 0)) -;;; Generated autoloads from magit-autorevert.el - -(defvar magit-auto-revert-mode (not (or global-auto-revert-mode noninteractive)) "\ -Non-nil if Magit-Auto-Revert mode is enabled. -See the `magit-auto-revert-mode' command -for a description of this minor mode. -Setting this variable directly does not take effect; -either customize it (see the info node `Easy Customization') -or call the function `magit-auto-revert-mode'.") - -(custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil) - -(autoload 'magit-auto-revert-mode "magit-autorevert" "\ -Toggle Auto-Revert mode in all buffers. -With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive; -otherwise, disable it. If called from Lisp, enable the mode if -ARG is omitted or nil. - -Auto-Revert mode is enabled in all buffers where -`magit-turn-on-auto-revert-mode-if-desired' would do it. -See `auto-revert-mode' for more information on Auto-Revert mode. - -\(fn &optional ARG)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (0 0 0 0)) -;;; Generated autoloads from magit-bisect.el - (autoload 'magit-bisect "magit-bisect" nil t) - -(autoload 'magit-bisect-start "magit-bisect" "\ -Start a bisect session. - -Bisecting a bug means to find the commit that introduced it. -This command starts such a bisect session by asking for a know -good and a bad commit. To move the session forward use the -other actions from the bisect transient command (\\<magit-status-mode-map>\\[magit-bisect]). - -\(fn BAD GOOD)" t nil) - -(autoload 'magit-bisect-reset "magit-bisect" "\ -After bisecting, cleanup bisection state and return to original `HEAD'. - -\(fn)" t nil) - -(autoload 'magit-bisect-good "magit-bisect" "\ -While bisecting, mark the current commit as good. -Use this after you have asserted that the commit does not contain -the bug in question. - -\(fn)" t nil) - -(autoload 'magit-bisect-bad "magit-bisect" "\ -While bisecting, mark the current commit as bad. -Use this after you have asserted that the commit does contain the -bug in question. - -\(fn)" t nil) - -(autoload 'magit-bisect-skip "magit-bisect" "\ -While bisecting, skip the current commit. -Use this if for some reason the current commit is not a good one -to test. This command lets Git choose a different one. - -\(fn)" t nil) - -(autoload 'magit-bisect-run "magit-bisect" "\ -Bisect automatically by running commands after each step. - -Unlike `git bisect run' this can be used before bisecting has -begun. In that case it behaves like `git bisect start; git -bisect run'. - -\(fn CMDLINE &optional BAD GOOD)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bisect" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-blame" "magit-blame.el" (0 0 0 0)) -;;; Generated autoloads from magit-blame.el - (autoload 'magit-blame-echo "magit-blame" nil t) - (autoload 'magit-blame-addition "magit-blame" nil t) - (autoload 'magit-blame-removal "magit-blame" nil t) - (autoload 'magit-blame-reverse "magit-blame" nil t) - (autoload 'magit-blame "magit-blame" nil t) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-blame" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-bookmark" "magit-bookmark.el" (0 0 0 -;;;;;; 0)) -;;; Generated autoloads from magit-bookmark.el - -(autoload 'magit--handle-bookmark "magit-bookmark" "\ -Open a bookmark created by `magit--make-bookmark'. -Call the `magit-*-setup-buffer' function of the the major-mode -with the variables' values as arguments, which were recorded by -`magit--make-bookmark'. Ignore `magit-display-buffer-function'. - -\(fn BOOKMARK)" nil nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bookmark" '("magit--make-bookmark"))) - -;;;*** - -;;;### (autoloads nil "magit-branch" "magit-branch.el" (0 0 0 0)) -;;; Generated autoloads from magit-branch.el - (autoload 'magit-branch "magit" nil t) - -(autoload 'magit-checkout "magit-branch" "\ -Checkout REVISION, updating the index and the working tree. -If REVISION is a local branch, then that becomes the current -branch. If it is something else, then `HEAD' becomes detached. -Checkout fails if the working tree or the staging area contain -changes. - -\(git checkout REVISION). - -\(fn REVISION)" t nil) - -(autoload 'magit-branch-create "magit-branch" "\ -Create BRANCH at branch or revision START-POINT. - -\(fn BRANCH START-POINT)" t nil) - -(autoload 'magit-branch-and-checkout "magit-branch" "\ -Create and checkout BRANCH at branch or revision START-POINT. - -\(fn BRANCH START-POINT)" t nil) - -(autoload 'magit-branch-or-checkout "magit-branch" "\ -Hybrid between `magit-checkout' and `magit-branch-and-checkout'. - -Ask the user for an existing branch or revision. If the user -input actually can be resolved as a branch or revision, then -check that out, just like `magit-checkout' would. - -Otherwise create and checkout a new branch using the input as -its name. Before doing so read the starting-point for the new -branch. This is similar to what `magit-branch-and-checkout' -does. - -\(fn ARG &optional START-POINT)" t nil) - -(autoload 'magit-branch-checkout "magit-branch" "\ -Checkout an existing or new local branch. - -Read a branch name from the user offering all local branches and -a subset of remote branches as candidates. Omit remote branches -for which a local branch by the same name exists from the list -of candidates. The user can also enter a completely new branch -name. - -- If the user selects an existing local branch, then check that - out. - -- If the user selects a remote branch, then create and checkout - a new local branch with the same name. Configure the selected - remote branch as push target. - -- If the user enters a new branch name, then create and check - that out, after also reading the starting-point from the user. - -In the latter two cases the upstream is also set. Whether it is -set to the chosen START-POINT or something else depends on the -value of `magit-branch-adjust-remote-upstream-alist', just like -when using `magit-branch-and-checkout'. - -\(fn BRANCH &optional START-POINT)" t nil) - -(autoload 'magit-branch-orphan "magit-branch" "\ -Create and checkout an orphan BRANCH with contents from revision START-POINT. - -\(fn BRANCH START-POINT)" t nil) - -(autoload 'magit-branch-spinout "magit-branch" "\ -Create new branch from the unpushed commits. -Like `magit-branch-spinoff' but remain on the current branch. -If there are any uncommitted changes, then behave exactly like -`magit-branch-spinoff'. - -\(fn BRANCH &optional FROM)" t nil) - -(autoload 'magit-branch-spinoff "magit-branch" "\ -Create new branch from the unpushed commits. - -Create and checkout a new branch starting at and tracking the -current branch. That branch in turn is reset to the last commit -it shares with its upstream. If the current branch has no -upstream or no unpushed commits, then the new branch is created -anyway and the previously current branch is not touched. - -This is useful to create a feature branch after work has already -began on the old branch (likely but not necessarily \"master\"). - -If the current branch is a member of the value of option -`magit-branch-prefer-remote-upstream' (which see), then the -current branch will be used as the starting point as usual, but -the upstream of the starting-point may be used as the upstream -of the new branch, instead of the starting-point itself. - -If optional FROM is non-nil, then the source branch is reset -to `FROM~', instead of to the last commit it shares with its -upstream. Interactively, FROM is only ever non-nil, if the -region selects some commits, and among those commits, FROM is -the commit that is the fewest commits ahead of the source -branch. - -The commit at the other end of the selection actually does not -matter, all commits between FROM and `HEAD' are moved to the new -branch. If FROM is not reachable from `HEAD' or is reachable -from the source branch's upstream, then an error is raised. - -\(fn BRANCH &optional FROM)" t nil) - -(autoload 'magit-branch-reset "magit-branch" "\ -Reset a branch to the tip of another branch or any other commit. - -When the branch being reset is the current branch, then do a -hard reset. If there are any uncommitted changes, then the user -has to confirm the reset because those changes would be lost. - -This is useful when you have started work on a feature branch but -realize it's all crap and want to start over. - -When resetting to another branch and a prefix argument is used, -then also set the target branch as the upstream of the branch -that is being reset. - -\(fn BRANCH TO &optional SET-UPSTREAM)" t nil) - -(autoload 'magit-branch-delete "magit-branch" "\ -Delete one or multiple branches. -If the region marks multiple branches, then offer to delete -those, otherwise prompt for a single branch to be deleted, -defaulting to the branch at point. - -\(fn BRANCHES &optional FORCE)" t nil) - -(autoload 'magit-branch-rename "magit-branch" "\ -Rename the branch named OLD to NEW. - -With a prefix argument FORCE, rename even if a branch named NEW -already exists. - -If `branch.OLD.pushRemote' is set, then unset it. Depending on -the value of `magit-branch-rename-push-target' (which see) maybe -set `branch.NEW.pushRemote' and maybe rename the push-target on -the remote. - -\(fn OLD NEW &optional FORCE)" t nil) - -(autoload 'magit-branch-shelve "magit-branch" "\ -Shelve a BRANCH. -Rename \"refs/heads/BRANCH\" to \"refs/shelved/BRANCH\", -and also rename the respective reflog file. - -\(fn BRANCH)" t nil) - -(autoload 'magit-branch-unshelve "magit-branch" "\ -Unshelve a BRANCH -Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\", -and also rename the respective reflog file. - -\(fn BRANCH)" t nil) - (autoload 'magit-branch-configure "magit-branch" nil t) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-branch" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-clone" "magit-clone.el" (0 0 0 0)) -;;; Generated autoloads from magit-clone.el - (autoload 'magit-clone "magit-clone" nil t) - -(autoload 'magit-clone-regular "magit-clone" "\ -Create a clone of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. - -\(fn REPOSITORY DIRECTORY ARGS)" t nil) - -(autoload 'magit-clone-shallow "magit-clone" "\ -Create a shallow clone of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. -With a prefix argument read the DEPTH of the clone; -otherwise use 1. - -\(fn REPOSITORY DIRECTORY ARGS DEPTH)" t nil) - -(autoload 'magit-clone-shallow-since "magit-clone" "\ -Create a shallow clone of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. -Exclude commits before DATE, which is read from the -user. - -\(fn REPOSITORY DIRECTORY ARGS DATE)" t nil) - -(autoload 'magit-clone-shallow-exclude "magit-clone" "\ -Create a shallow clone of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. -Exclude commits reachable from EXCLUDE, which is a -branch or tag read from the user. - -\(fn REPOSITORY DIRECTORY ARGS EXCLUDE)" t nil) - -(autoload 'magit-clone-bare "magit-clone" "\ -Create a bare clone of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. - -\(fn REPOSITORY DIRECTORY ARGS)" t nil) - -(autoload 'magit-clone-mirror "magit-clone" "\ -Create a mirror of REPOSITORY in DIRECTORY. -Then show the status buffer for the new repository. - -\(fn REPOSITORY DIRECTORY ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-clone" '("magit-clone-"))) - -;;;*** - -;;;### (autoloads nil "magit-commit" "magit-commit.el" (0 0 0 0)) -;;; Generated autoloads from magit-commit.el - (autoload 'magit-commit "magit-commit" nil t) - -(autoload 'magit-commit-create "magit-commit" "\ -Create a new commit on `HEAD'. -With a prefix argument, amend to the commit at `HEAD' instead. - -\(git commit [--amend] ARGS) - -\(fn &optional ARGS)" t nil) - -(autoload 'magit-commit-amend "magit-commit" "\ -Amend the last commit. - -\(git commit --amend ARGS) - -\(fn &optional ARGS)" t nil) - -(autoload 'magit-commit-extend "magit-commit" "\ -Amend the last commit, without editing the message. - -With a prefix argument keep the committer date, otherwise change -it. The option `magit-commit-extend-override-date' can be used -to inverse the meaning of the prefix argument. -\(git commit ---amend --no-edit) - -\(fn &optional ARGS OVERRIDE-DATE)" t nil) - -(autoload 'magit-commit-reword "magit-commit" "\ -Reword the last commit, ignoring staged changes. - -With a prefix argument keep the committer date, otherwise change -it. The option `magit-commit-reword-override-date' can be used -to inverse the meaning of the prefix argument. - -Non-interactively respect the optional OVERRIDE-DATE argument -and ignore the option. - -\(git commit --amend --only) - -\(fn &optional ARGS OVERRIDE-DATE)" t nil) - -(autoload 'magit-commit-fixup "magit-commit" "\ -Create a fixup commit. - -With a prefix argument the target COMMIT has to be confirmed. -Otherwise the commit at point may be used without confirmation -depending on the value of option `magit-commit-squash-confirm'. - -\(fn &optional COMMIT ARGS)" t nil) - -(autoload 'magit-commit-squash "magit-commit" "\ -Create a squash commit, without editing the squash message. - -With a prefix argument the target COMMIT has to be confirmed. -Otherwise the commit at point may be used without confirmation -depending on the value of option `magit-commit-squash-confirm'. - -\(fn &optional COMMIT ARGS)" t nil) - -(autoload 'magit-commit-augment "magit-commit" "\ -Create a squash commit, editing the squash message. - -With a prefix argument the target COMMIT has to be confirmed. -Otherwise the commit at point may be used without confirmation -depending on the value of option `magit-commit-squash-confirm'. - -\(fn &optional COMMIT ARGS)" t nil) - -(autoload 'magit-commit-instant-fixup "magit-commit" "\ -Create a fixup commit targeting COMMIT and instantly rebase. - -\(fn &optional COMMIT ARGS)" t nil) - -(autoload 'magit-commit-instant-squash "magit-commit" "\ -Create a squash commit targeting COMMIT and instantly rebase. - -\(fn &optional COMMIT ARGS)" t nil) - -(autoload 'magit-commit-reshelve "magit-commit" "\ -Change the committer date and possibly the author date of `HEAD'. - -If you are the author of `HEAD', then both dates are changed, -otherwise only the committer date. The current time is used -as the initial minibuffer input and the original author (if -that is you) or committer date is available as the previous -history element. - -\(fn DATE)" t nil) - (autoload 'magit-commit-absorb "magit-commit" nil t) - (autoload 'magit-commit-autofixup "magit-commit" nil t) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-commit" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-diff" "magit-diff.el" (0 0 0 0)) -;;; Generated autoloads from magit-diff.el - (autoload 'magit-diff "magit-diff" nil t) - (autoload 'magit-diff-refresh "magit-diff" nil t) - -(autoload 'magit-diff-dwim "magit-diff" "\ -Show changes for the thing at point. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-diff-range "magit-diff" "\ -Show differences between two commits. - -REV-OR-RANGE should be a range or a single revision. If it is a -revision, then show changes in the working tree relative to that -revision. If it is a range, but one side is omitted, then show -changes relative to `HEAD'. - -If the region is active, use the revisions on the first and last -line of the region as the two sides of the range. With a prefix -argument, instead of diffing the revisions, choose a revision to -view changes along, starting at the common ancestor of both -revisions (i.e., use a \"...\" range). - -\(fn REV-OR-RANGE &optional ARGS FILES)" t nil) - -(autoload 'magit-diff-working-tree "magit-diff" "\ -Show changes between the current working tree and the `HEAD' commit. -With a prefix argument show changes between the working tree and -a commit read from the minibuffer. - -\(fn &optional REV ARGS FILES)" t nil) - -(autoload 'magit-diff-staged "magit-diff" "\ -Show changes between the index and the `HEAD' commit. -With a prefix argument show changes between the index and -a commit read from the minibuffer. - -\(fn &optional REV ARGS FILES)" t nil) - -(autoload 'magit-diff-unstaged "magit-diff" "\ -Show changes between the working tree and the index. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-diff-unmerged "magit-diff" "\ -Show changes that are being merged. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-diff-while-committing "magit-diff" "\ -While committing, show the changes that are about to be committed. -While amending, invoking the command again toggles between -showing just the new changes or all the changes that will -be committed. - -\(fn &optional ARGS)" t nil) - -(autoload 'magit-diff-buffer-file "magit-diff" "\ -Show diff for the blob or file visited in the current buffer. - -When the buffer visits a blob, then show the respective commit. -When the buffer visits a file, then show the differenced between -`HEAD' and the working tree. In both cases limit the diff to -the file or blob. - -\(fn)" t nil) - -(autoload 'magit-diff-paths "magit-diff" "\ -Show changes between any two files on disk. - -\(fn A B)" t nil) - -(autoload 'magit-show-commit "magit-diff" "\ -Visit the revision at point in another buffer. -If there is no revision at point or with a prefix argument prompt -for a revision. - -\(fn REV &optional ARGS FILES MODULE)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-diff" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (0 0 0 0)) -;;; Generated autoloads from magit-ediff.el - (autoload 'magit-ediff "magit-ediff" nil) - -(autoload 'magit-ediff-resolve "magit-ediff" "\ -Resolve outstanding conflicts in FILE using Ediff. -FILE has to be relative to the top directory of the repository. - -In the rare event that you want to manually resolve all -conflicts, including those already resolved by Git, use -`ediff-merge-revisions-with-ancestor'. - -\(fn FILE)" t nil) - -(autoload 'magit-ediff-stage "magit-ediff" "\ -Stage and unstage changes to FILE using Ediff. -FILE has to be relative to the top directory of the repository. - -\(fn FILE)" t nil) - -(autoload 'magit-ediff-compare "magit-ediff" "\ -Compare REVA:FILEA with REVB:FILEB using Ediff. - -FILEA and FILEB have to be relative to the top directory of the -repository. If REVA or REVB is nil, then this stands for the -working tree state. - -If the region is active, use the revisions on the first and last -line of the region. With a prefix argument, instead of diffing -the revisions, choose a revision to view changes along, starting -at the common ancestor of both revisions (i.e., use a \"...\" -range). - -\(fn REVA REVB FILEA FILEB)" t nil) - -(autoload 'magit-ediff-dwim "magit-ediff" "\ -Compare, stage, or resolve using Ediff. -This command tries to guess what file, and what commit or range -the user wants to compare, stage, or resolve using Ediff. It -might only be able to guess either the file, or range or commit, -in which case the user is asked about the other. It might not -always guess right, in which case the appropriate `magit-ediff-*' -command has to be used explicitly. If it cannot read the user's -mind at all, then it asks the user for a command to run. - -\(fn)" t nil) - -(autoload 'magit-ediff-show-staged "magit-ediff" "\ -Show staged changes using Ediff. - -This only allows looking at the changes; to stage, unstage, -and discard changes using Ediff, use `magit-ediff-stage'. - -FILE must be relative to the top directory of the repository. - -\(fn FILE)" t nil) - -(autoload 'magit-ediff-show-unstaged "magit-ediff" "\ -Show unstaged changes using Ediff. - -This only allows looking at the changes; to stage, unstage, -and discard changes using Ediff, use `magit-ediff-stage'. - -FILE must be relative to the top directory of the repository. - -\(fn FILE)" t nil) - -(autoload 'magit-ediff-show-working-tree "magit-ediff" "\ -Show changes between `HEAD' and working tree using Ediff. -FILE must be relative to the top directory of the repository. - -\(fn FILE)" t nil) - -(autoload 'magit-ediff-show-commit "magit-ediff" "\ -Show changes introduced by COMMIT using Ediff. - -\(fn COMMIT)" t nil) - -(autoload 'magit-ediff-show-stash "magit-ediff" "\ -Show changes introduced by STASH using Ediff. -`magit-ediff-show-stash-with-index' controls whether a -three-buffer Ediff is used in order to distinguish changes in the -stash that were staged. - -\(fn STASH)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-ediff" '("magit-ediff-"))) - -;;;*** - -;;;### (autoloads nil "magit-extras" "magit-extras.el" (0 0 0 0)) -;;; Generated autoloads from magit-extras.el - -(autoload 'magit-run-git-gui "magit-extras" "\ -Run `git gui' for the current git repository. - -\(fn)" t nil) - -(autoload 'magit-run-git-gui-blame "magit-extras" "\ -Run `git gui blame' on the given FILENAME and COMMIT. -Interactively run it for the current file and the `HEAD', with a -prefix or when the current file cannot be determined let the user -choose. When the current buffer is visiting FILENAME instruct -blame to center around the line point is on. - -\(fn COMMIT FILENAME &optional LINENUM)" t nil) - -(autoload 'magit-run-gitk "magit-extras" "\ -Run `gitk' in the current repository. - -\(fn)" t nil) - -(autoload 'magit-run-gitk-branches "magit-extras" "\ -Run `gitk --branches' in the current repository. - -\(fn)" t nil) - -(autoload 'magit-run-gitk-all "magit-extras" "\ -Run `gitk --all' in the current repository. - -\(fn)" t nil) - -(autoload 'ido-enter-magit-status "magit-extras" "\ -Drop into `magit-status' from file switching. - -This command does not work in Emacs 26.1. -See https://github.com/magit/magit/issues/3634 -and https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707. - -To make this command available use something like: - - (add-hook \\='ido-setup-hook - (lambda () - (define-key ido-completion-map - (kbd \"C-x g\") \\='ido-enter-magit-status))) - -Starting with Emacs 25.1 the Ido keymaps are defined just once -instead of every time Ido is invoked, so now you can modify it -like pretty much every other keymap: - - (define-key ido-common-completion-map - (kbd \"C-x g\") \\='ido-enter-magit-status) - -\(fn)" t nil) - -(autoload 'magit-project-status "magit-extras" "\ -Run `magit-status' in the current project's root. - -\(fn)" t nil) - -(autoload 'magit-dired-jump "magit-extras" "\ -Visit file at point using Dired. -With a prefix argument, visit in another window. If there -is no file at point, then instead visit `default-directory'. - -\(fn &optional OTHER-WINDOW)" t nil) - -(autoload 'magit-dired-log "magit-extras" "\ -Show log for all marked files, or the current file. - -\(fn &optional FOLLOW)" t nil) - -(autoload 'magit-do-async-shell-command "magit-extras" "\ -Open FILE with `dired-do-async-shell-command'. -Interactively, open the file at point. - -\(fn FILE)" t nil) - -(autoload 'magit-previous-line "magit-extras" "\ -Like `previous-line' but with Magit-specific shift-selection. - -Magit's selection mechanism is based on the region but selects an -area that is larger than the region. This causes `previous-line' -when invoked while holding the shift key to move up one line and -thereby select two lines. When invoked inside a hunk body this -command does not move point on the first invocation and thereby -it only selects a single line. Which inconsistency you prefer -is a matter of preference. - -\(fn &optional ARG TRY-VSCROLL)" t nil) - -(function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.") - -(autoload 'magit-next-line "magit-extras" "\ -Like `next-line' but with Magit-specific shift-selection. - -Magit's selection mechanism is based on the region but selects -an area that is larger than the region. This causes `next-line' -when invoked while holding the shift key to move down one line -and thereby select two lines. When invoked inside a hunk body -this command does not move point on the first invocation and -thereby it only selects a single line. Which inconsistency you -prefer is a matter of preference. - -\(fn &optional ARG TRY-VSCROLL)" t nil) - -(function-put 'magit-next-line 'interactive-only 'forward-line) - -(autoload 'magit-clean "magit-extras" "\ -Remove untracked files from the working tree. -With a prefix argument also remove ignored files, -with two prefix arguments remove ignored files only. - -\(git clean -f -d [-x|-X]) - -\(fn &optional ARG)" t nil) - -(autoload 'magit-add-change-log-entry "magit-extras" "\ -Find change log file and add date entry and item for current change. -This differs from `add-change-log-entry' (which see) in that -it acts on the current hunk in a Magit buffer instead of on -a position in a file-visiting buffer. - -\(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)" t nil) - -(autoload 'magit-add-change-log-entry-other-window "magit-extras" "\ -Find change log file in other window and add entry and item. -This differs from `add-change-log-entry-other-window' (which see) -in that it acts on the current hunk in a Magit buffer instead of -on a position in a file-visiting buffer. - -\(fn &optional WHOAMI FILE-NAME)" t nil) - -(autoload 'magit-edit-line-commit "magit-extras" "\ -Edit the commit that added the current line. - -With a prefix argument edit the commit that removes the line, -if any. The commit is determined using `git blame' and made -editable using `git rebase --interactive' if it is reachable -from `HEAD', or by checking out the commit (or a branch that -points at it) otherwise. - -\(fn &optional TYPE)" t nil) - -(autoload 'magit-diff-edit-hunk-commit "magit-extras" "\ -From a hunk, edit the respective commit and visit the file. - -First visit the file being modified by the hunk at the correct -location using `magit-diff-visit-file'. This actually visits a -blob. When point is on a diff header, not within an individual -hunk, then this visits the blob the first hunk is about. - -Then invoke `magit-edit-line-commit', which uses an interactive -rebase to make the commit editable, or if that is not possible -because the commit is not reachable from `HEAD' by checking out -that commit directly. This also causes the actual worktree file -to be visited. - -Neither the blob nor the file buffer are killed when finishing -the rebase. If that is undesirable, then it might be better to -use `magit-rebase-edit-command' instead of this command. - -\(fn FILE)" t nil) - -(autoload 'magit-reshelve-since "magit-extras" "\ -Change the author and committer dates of the commits since REV. - -Ask the user for the first reachable commit whose dates should -be changed. Then read the new date for that commit. The initial -minibuffer input and the previous history element offer good -values. The next commit will be created one minute later and so -on. - -This command is only intended for interactive use and should only -be used on highly rearranged and unpublished history. - -\(fn REV)" t nil) - -(autoload 'magit-pop-revision-stack "magit-extras" "\ -Insert a representation of a revision into the current buffer. - -Pop a revision from the `magit-revision-stack' and insert it into -the current buffer according to `magit-pop-revision-stack-format'. -Revisions can be put on the stack using `magit-copy-section-value' -and `magit-copy-buffer-revision'. - -If the stack is empty or with a prefix argument, instead read a -revision in the minibuffer. By using the minibuffer history this -allows selecting an item which was popped earlier or to insert an -arbitrary reference or revision without first pushing it onto the -stack. - -When reading the revision from the minibuffer, then it might not -be possible to guess the correct repository. When this command -is called inside a repository (e.g. while composing a commit -message), then that repository is used. Otherwise (e.g. while -composing an email) then the repository recorded for the top -element of the stack is used (even though we insert another -revision). If not called inside a repository and with an empty -stack, or with two prefix arguments, then read the repository in -the minibuffer too. - -\(fn REV TOPLEVEL)" t nil) - -(autoload 'magit-copy-section-value "magit-extras" "\ -Save the value of the current section for later use. - -Save the section value to the `kill-ring', and, provided that -the current section is a commit, branch, or tag section, push -the (referenced) revision to the `magit-revision-stack' for use -with `magit-pop-revision-stack'. - -When `magit-copy-revision-abbreviated' is non-nil, save the -abbreviated revision to the `kill-ring' and the -`magit-revision-stack'. - -When the current section is a branch or a tag, and a prefix -argument is used, then save the revision at its tip to the -`kill-ring' instead of the reference name. - -When the region is active, then save that to the `kill-ring', -like `kill-ring-save' would, instead of behaving as described -above. If a prefix argument is used and the region is within a -hunk, strip the outer diff marker column. - -\(fn)" t nil) - -(autoload 'magit-copy-buffer-revision "magit-extras" "\ -Save the revision of the current buffer for later use. - -Save the revision shown in the current buffer to the `kill-ring' -and push it to the `magit-revision-stack'. - -This command is mainly intended for use in `magit-revision-mode' -buffers, the only buffers where it is always unambiguous exactly -which revision should be saved. - -Most other Magit buffers usually show more than one revision, in -some way or another, so this command has to select one of them, -and that choice might not always be the one you think would have -been the best pick. - -In such buffers it is often more useful to save the value of -the current section instead, using `magit-copy-section-value'. - -When the region is active, then save that to the `kill-ring', -like `kill-ring-save' would, instead of behaving as described -above. - -When `magit-copy-revision-abbreviated' is non-nil, save the -abbreviated revision to the `kill-ring' and the -`magit-revision-stack'. - -\(fn)" t nil) - -(autoload 'magit-abort-dwim "magit-extras" "\ -Abort current operation. -Depending on the context, this will abort a merge, a rebase, a -patch application, a cherry-pick, a revert, or a bisect. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-extras" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-fetch" "magit-fetch.el" (0 0 0 0)) -;;; Generated autoloads from magit-fetch.el - (autoload 'magit-fetch "magit-fetch" nil t) - (autoload 'magit-fetch-from-pushremote "magit-fetch" nil t) - (autoload 'magit-fetch-from-upstream "magit-fetch" nil t) - -(autoload 'magit-fetch-other "magit-fetch" "\ -Fetch from another repository. - -\(fn REMOTE ARGS)" t nil) - -(autoload 'magit-fetch-branch "magit-fetch" "\ -Fetch a BRANCH from a REMOTE. - -\(fn REMOTE BRANCH ARGS)" t nil) - -(autoload 'magit-fetch-refspec "magit-fetch" "\ -Fetch a REFSPEC from a REMOTE. - -\(fn REMOTE REFSPEC ARGS)" t nil) - -(autoload 'magit-fetch-all "magit-fetch" "\ -Fetch from all remotes. - -\(fn ARGS)" t nil) - -(autoload 'magit-fetch-all-prune "magit-fetch" "\ -Fetch from all remotes, and prune. -Prune remote tracking branches for branches that have been -removed on the respective remote. - -\(fn)" t nil) - -(autoload 'magit-fetch-all-no-prune "magit-fetch" "\ -Fetch from all remotes. - -\(fn)" t nil) - -(autoload 'magit-fetch-modules "magit-fetch" "\ -Fetch all submodules. - -Option `magit-fetch-modules-jobs' controls how many submodules -are being fetched in parallel. Also fetch the super-repository, -because `git-fetch' does not support not doing that. With a -prefix argument fetch all remotes. - -\(fn &optional ALL)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-fetch" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-files" "magit-files.el" (0 0 0 0)) -;;; Generated autoloads from magit-files.el - -(autoload 'magit-find-file "magit-files" "\ -View FILE from REV. -Switch to a buffer visiting blob REV:FILE, creating one if none -already exists. If prior to calling this command the current -buffer and/or cursor position is about the same file, then go -to the line and column corresponding to that location. - -\(fn REV FILE)" t nil) - -(autoload 'magit-find-file-other-window "magit-files" "\ -View FILE from REV, in another window. -Switch to a buffer visiting blob REV:FILE, creating one if none -already exists. If prior to calling this command the current -buffer and/or cursor position is about the same file, then go to -the line and column corresponding to that location. - -\(fn REV FILE)" t nil) - -(autoload 'magit-find-file-other-frame "magit-files" "\ -View FILE from REV, in another frame. -Switch to a buffer visiting blob REV:FILE, creating one if none -already exists. If prior to calling this command the current -buffer and/or cursor position is about the same file, then go to -the line and column corresponding to that location. - -\(fn REV FILE)" t nil) - (autoload 'magit-file-dispatch "magit" nil t) - -(defvar global-magit-file-mode t "\ -Non-nil if Global Magit-File mode is enabled. -See the `global-magit-file-mode' command -for a description of this minor mode. -Setting this variable directly does not take effect; -either customize it (see the info node `Easy Customization') -or call the function `global-magit-file-mode'.") - -(custom-autoload 'global-magit-file-mode "magit-files" nil) - -(autoload 'global-magit-file-mode "magit-files" "\ -Toggle Magit-File mode in all buffers. -With prefix ARG, enable Global Magit-File mode if ARG is positive; -otherwise, disable it. If called from Lisp, enable the mode if -ARG is omitted or nil. - -Magit-File mode is enabled in all buffers where -`magit-file-mode-turn-on' would do it. -See `magit-file-mode' for more information on Magit-File mode. - -\(fn &optional ARG)" t nil) - -(autoload 'magit-blob-visit-file "magit-files" "\ -View the file from the worktree corresponding to the current blob. -When visiting a blob or the version from the index, then go to -the same location in the respective file in the working tree. - -\(fn)" t nil) - -(autoload 'magit-file-checkout "magit-files" "\ -Checkout FILE from REV. - -\(fn REV FILE)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-files" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-git" "magit-git.el" (0 0 0 0)) -;;; Generated autoloads from magit-git.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-git" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-gitignore" "magit-gitignore.el" (0 0 -;;;;;; 0 0)) -;;; Generated autoloads from magit-gitignore.el - (autoload 'magit-gitignore "magit-gitignore" nil t) - -(autoload 'magit-gitignore-in-topdir "magit-gitignore" "\ -Add the Git ignore RULE to the top-level \".gitignore\" file. -Since this file is tracked, it is shared with other clones of the -repository. Also stage the file. - -\(fn RULE)" t nil) - -(autoload 'magit-gitignore-in-subdir "magit-gitignore" "\ -Add the Git ignore RULE to a \".gitignore\" file. -Prompted the user for a directory and add the rule to the -\".gitignore\" file in that directory. Since such files are -tracked, they are shared with other clones of the repository. -Also stage the file. - -\(fn RULE DIRECTORY)" t nil) - -(autoload 'magit-gitignore-in-gitdir "magit-gitignore" "\ -Add the Git ignore RULE to \"$GIT_DIR/info/exclude\". -Rules in that file only affects this clone of the repository. - -\(fn RULE)" t nil) - -(autoload 'magit-gitignore-on-system "magit-gitignore" "\ -Add the Git ignore RULE to the file specified by `core.excludesFile'. -Rules that are defined in that file affect all local repositories. - -\(fn RULE)" t nil) - -(autoload 'magit-skip-worktree "magit-gitignore" "\ -Call \"git update-index --skip-worktree -- FILE\". - -\(fn FILE)" t nil) - -(autoload 'magit-no-skip-worktree "magit-gitignore" "\ -Call \"git update-index --no-skip-worktree -- FILE\". - -\(fn FILE)" t nil) - -(autoload 'magit-assume-unchanged "magit-gitignore" "\ -Call \"git update-index --assume-unchanged -- FILE\". - -\(fn FILE)" t nil) - -(autoload 'magit-no-assume-unchanged "magit-gitignore" "\ -Call \"git update-index --no-assume-unchanged -- FILE\". - -\(fn FILE)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-gitignore" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-imenu" "magit-imenu.el" (0 0 0 0)) -;;; Generated autoloads from magit-imenu.el - -(autoload 'magit-imenu--log-prev-index-position-function "magit-imenu" "\ -Move point to previous line in current buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--log-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(autoload 'magit-imenu--diff-prev-index-position-function "magit-imenu" "\ -Move point to previous file line in current buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--diff-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(autoload 'magit-imenu--status-create-index-function "magit-imenu" "\ -Return an alist of all imenu entries in current buffer. -This function is used as a value for -`imenu-create-index-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--refs-create-index-function "magit-imenu" "\ -Return an alist of all imenu entries in current buffer. -This function is used as a value for -`imenu-create-index-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--cherry-create-index-function "magit-imenu" "\ -Return an alist of all imenu entries in current buffer. -This function is used as a value for -`imenu-create-index-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--submodule-prev-index-position-function "magit-imenu" "\ -Move point to previous line in magit-submodule-list buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--submodule-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(autoload 'magit-imenu--repolist-prev-index-position-function "magit-imenu" "\ -Move point to previous line in magit-repolist buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--repolist-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(autoload 'magit-imenu--process-prev-index-position-function "magit-imenu" "\ -Move point to previous process in magit-process buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--process-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(autoload 'magit-imenu--rebase-prev-index-position-function "magit-imenu" "\ -Move point to previous commit in git-rebase buffer. -This function is used as a value for -`imenu-prev-index-position-function'. - -\(fn)" nil nil) - -(autoload 'magit-imenu--rebase-extract-index-name-function "magit-imenu" "\ -Return imenu name for line at point. -This function is used as a value for -`imenu-extract-index-name-function'. Point should be at the -beginning of the line. - -\(fn)" nil nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-imenu" '("magit-imenu--index-function"))) - -;;;*** - -;;;### (autoloads nil "magit-log" "magit-log.el" (0 0 0 0)) -;;; Generated autoloads from magit-log.el - (autoload 'magit-log "magit-log" nil t) - (autoload 'magit-log-refresh "magit-log" nil t) - -(autoload 'magit-log-current "magit-log" "\ -Show log for the current branch. -When `HEAD' is detached or with a prefix argument show log for -one or more revs read from the minibuffer. - -\(fn REVS &optional ARGS FILES)" t nil) - -(autoload 'magit-log-other "magit-log" "\ -Show log for one or more revs read from the minibuffer. -The user can input any revision or revisions separated by a -space, or even ranges, but only branches and tags, and a -representation of the commit at point, are available as -completion candidates. - -\(fn REVS &optional ARGS FILES)" t nil) - -(autoload 'magit-log-head "magit-log" "\ -Show log for `HEAD'. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-log-branches "magit-log" "\ -Show log for all local branches and `HEAD'. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-log-matching-branches "magit-log" "\ -Show log for all branches matching PATTERN and `HEAD'. - -\(fn PATTERN &optional ARGS FILES)" t nil) - -(autoload 'magit-log-matching-tags "magit-log" "\ -Show log for all tags matching PATTERN and `HEAD'. - -\(fn PATTERN &optional ARGS FILES)" t nil) - -(autoload 'magit-log-all-branches "magit-log" "\ -Show log for all local and remote branches and `HEAD'. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-log-all "magit-log" "\ -Show log for all references and `HEAD'. - -\(fn &optional ARGS FILES)" t nil) - -(autoload 'magit-log-buffer-file "magit-log" "\ -Show log for the blob or file visited in the current buffer. -With a prefix argument or when `--follow' is an active log -argument, then follow renames. When the region is active, -restrict the log to the lines that the region touches. - -\(fn &optional FOLLOW BEG END)" t nil) - -(autoload 'magit-log-trace-definition "magit-log" "\ -Show log for the definition at point. - -\(fn FILE FN REV)" t nil) - -(autoload 'magit-log-merged "magit-log" "\ -Show log for the merge of COMMIT into BRANCH. - -More precisely, find merge commit M that brought COMMIT into -BRANCH, and show the log of the range \"M^1..M\". If COMMIT is -directly on BRANCH, then show approximately twenty surrounding -commits instead. - -This command requires git-when-merged, which is available from -https://github.com/mhagger/git-when-merged. - -\(fn COMMIT BRANCH &optional ARGS FILES)" t nil) - -(autoload 'magit-log-move-to-parent "magit-log" "\ -Move to the Nth parent of the current commit. - -\(fn &optional N)" t nil) - -(autoload 'magit-cherry "magit-log" "\ -Show commits in a branch that are not merged in the upstream branch. - -\(fn HEAD UPSTREAM)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-log" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-margin" "magit-margin.el" (0 0 0 0)) -;;; Generated autoloads from magit-margin.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-margin" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-merge" "magit-merge.el" (0 0 0 0)) -;;; Generated autoloads from magit-merge.el - (autoload 'magit-merge "magit" nil t) - -(autoload 'magit-merge-plain "magit-merge" "\ -Merge commit REV into the current branch; using default message. - -Unless there are conflicts or a prefix argument is used create a -merge commit using a generic commit message and without letting -the user inspect the result. With a prefix argument pretend the -merge failed to give the user the opportunity to inspect the -merge. - -\(git merge --no-edit|--no-commit [ARGS] REV) - -\(fn REV &optional ARGS NOCOMMIT)" t nil) - -(autoload 'magit-merge-editmsg "magit-merge" "\ -Merge commit REV into the current branch; and edit message. -Perform the merge and prepare a commit message but let the user -edit it. - -\(git merge --edit --no-ff [ARGS] REV) - -\(fn REV &optional ARGS)" t nil) - -(autoload 'magit-merge-nocommit "magit-merge" "\ -Merge commit REV into the current branch; pretending it failed. -Pretend the merge failed to give the user the opportunity to -inspect the merge and change the commit message. - -\(git merge --no-commit --no-ff [ARGS] REV) - -\(fn REV &optional ARGS)" t nil) - -(autoload 'magit-merge-into "magit-merge" "\ -Merge the current branch into BRANCH and remove the former. - -Before merging, force push the source branch to its push-remote, -provided the respective remote branch already exists, ensuring -that the respective pull-request (if any) won't get stuck on some -obsolete version of the commits that are being merged. Finally -if `forge-branch-pullreq' was used to create the merged branch, -branch, then also remove the respective remote branch. - -\(fn BRANCH &optional ARGS)" t nil) - -(autoload 'magit-merge-absorb "magit-merge" "\ -Merge BRANCH into the current branch and remove the former. - -Before merging, force push the source branch to its push-remote, -provided the respective remote branch already exists, ensuring -that the respective pull-request (if any) won't get stuck on some -obsolete version of the commits that are being merged. Finally -if `forge-branch-pullreq' was used to create the merged branch, -then also remove the respective remote branch. - -\(fn BRANCH &optional ARGS)" t nil) - -(autoload 'magit-merge-squash "magit-merge" "\ -Squash commit REV into the current branch; don't create a commit. - -\(git merge --squash REV) - -\(fn REV)" t nil) - -(autoload 'magit-merge-preview "magit-merge" "\ -Preview result of merging REV into the current branch. - -\(fn REV)" t nil) - -(autoload 'magit-merge-abort "magit-merge" "\ -Abort the current merge operation. - -\(git merge --abort) - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-merge" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-mode" "magit-mode.el" (0 0 0 0)) -;;; Generated autoloads from magit-mode.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-mode" '("magit-" "disable-magit-save-buffers" "inhibit-magit-refresh"))) - -;;;*** - -;;;### (autoloads nil "magit-notes" "magit-notes.el" (0 0 0 0)) -;;; Generated autoloads from magit-notes.el - (autoload 'magit-notes "magit" nil t) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-notes" '("magit-notes-"))) - -;;;*** - -;;;### (autoloads nil "magit-obsolete" "magit-obsolete.el" (0 0 0 -;;;;;; 0)) -;;; Generated autoloads from magit-obsolete.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-obsolete" '("magit--magit-popup-warning"))) - -;;;*** - -;;;### (autoloads nil "magit-patch" "magit-patch.el" (0 0 0 0)) -;;; Generated autoloads from magit-patch.el - (autoload 'magit-patch "magit-patch" nil t) - (autoload 'magit-patch-create "magit-patch" nil t) - (autoload 'magit-patch-apply "magit-patch" nil t) - -(autoload 'magit-patch-save "magit-patch" "\ -Write current diff into patch FILE. - -What arguments are used to create the patch depends on the value -of `magit-patch-save-arguments' and whether a prefix argument is -used. - -If the value is the symbol `buffer', then use the same arguments -as the buffer. With a prefix argument use no arguments. - -If the value is a list beginning with the symbol `exclude', then -use the same arguments as the buffer except for those matched by -entries in the cdr of the list. The comparison is done using -`string-prefix-p'. With a prefix argument use the same arguments -as the buffer. - -If the value is a list of strings (including the empty list), -then use those arguments. With a prefix argument use the same -arguments as the buffer. - -Of course the arguments that are required to actually show the -same differences as those shown in the buffer are always used. - -\(fn FILE &optional ARG)" t nil) - -(autoload 'magit-request-pull "magit-patch" "\ -Request upstream to pull from you public repository. - -URL is the url of your publicly accessible repository. -START is a commit that already is in the upstream repository. -END is the last commit, usually a branch name, which upstream -is asked to pull. START has to be reachable from that commit. - -\(fn URL START END)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-patch" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-process" "magit-process.el" (0 0 0 0)) -;;; Generated autoloads from magit-process.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-process" '("magit-" "tramp-sh-handle-"))) - -;;;*** - -;;;### (autoloads nil "magit-pull" "magit-pull.el" (0 0 0 0)) -;;; Generated autoloads from magit-pull.el - (autoload 'magit-pull "magit-pull" nil t) - (autoload 'magit-pull-from-pushremote "magit-pull" nil t) - (autoload 'magit-pull-from-upstream "magit-pull" nil t) - -(autoload 'magit-pull-branch "magit-pull" "\ -Pull from a branch read in the minibuffer. - -\(fn SOURCE ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-pull" '("magit-pull-"))) - -;;;*** - -;;;### (autoloads nil "magit-push" "magit-push.el" (0 0 0 0)) -;;; Generated autoloads from magit-push.el - (autoload 'magit-push "magit-push" nil t) - (autoload 'magit-push-current-to-pushremote "magit-push" nil t) - (autoload 'magit-push-current-to-upstream "magit-push" nil t) - -(autoload 'magit-push-current "magit-push" "\ -Push the current branch to a branch read in the minibuffer. - -\(fn TARGET ARGS)" t nil) - -(autoload 'magit-push-other "magit-push" "\ -Push an arbitrary branch or commit somewhere. -Both the source and the target are read in the minibuffer. - -\(fn SOURCE TARGET ARGS)" t nil) - -(autoload 'magit-push-refspecs "magit-push" "\ -Push one or multiple REFSPECS to a REMOTE. -Both the REMOTE and the REFSPECS are read in the minibuffer. To -use multiple REFSPECS, separate them with commas. Completion is -only available for the part before the colon, or when no colon -is used. - -\(fn REMOTE REFSPECS ARGS)" t nil) - -(autoload 'magit-push-matching "magit-push" "\ -Push all matching branches to another repository. -If multiple remotes exist, then read one from the user. -If just one exists, use that without requiring confirmation. - -\(fn REMOTE &optional ARGS)" t nil) - -(autoload 'magit-push-tags "magit-push" "\ -Push all tags to another repository. -If only one remote exists, then push to that. Otherwise prompt -for a remote, offering the remote configured for the current -branch as default. - -\(fn REMOTE &optional ARGS)" t nil) - -(autoload 'magit-push-tag "magit-push" "\ -Push a tag to another repository. - -\(fn TAG REMOTE &optional ARGS)" t nil) - -(autoload 'magit-push-notes-ref "magit-push" "\ -Push a notes ref to another repository. - -\(fn REF REMOTE &optional ARGS)" t nil) - -(autoload 'magit-push-implicitly "magit-push" "\ -Push somewhere without using an explicit refspec. - -This command simply runs \"git push -v [ARGS]\". ARGS are the -arguments specified in the popup buffer. No explicit refspec -arguments are used. Instead the behavior depends on at least -these Git variables: `push.default', `remote.pushDefault', -`branch.<branch>.pushRemote', `branch.<branch>.remote', -`branch.<branch>.merge', and `remote.<remote>.push'. - -The function `magit-push-implicitly--desc' attempts to predict -what this command will do. The value it returns is displayed in -the popup buffer. - -\(fn ARGS)" t nil) - -(autoload 'magit-push-to-remote "magit-push" "\ -Push to REMOTE without using an explicit refspec. -The REMOTE is read in the minibuffer. - -This command simply runs \"git push -v [ARGS] REMOTE\". ARGS -are the arguments specified in the popup buffer. No refspec -arguments are used. Instead the behavior depends on at least -these Git variables: `push.default', `remote.pushDefault', -`branch.<branch>.pushRemote', `branch.<branch>.remote', -`branch.<branch>.merge', and `remote.<remote>.push'. - -\(fn REMOTE ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-push" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-reflog" "magit-reflog.el" (0 0 0 0)) -;;; Generated autoloads from magit-reflog.el - -(autoload 'magit-reflog-current "magit-reflog" "\ -Display the reflog of the current branch. -If `HEAD' is detached, then show the reflog for that instead. - -\(fn)" t nil) - -(autoload 'magit-reflog-other "magit-reflog" "\ -Display the reflog of a branch or another ref. - -\(fn REF)" t nil) - -(autoload 'magit-reflog-head "magit-reflog" "\ -Display the `HEAD' reflog. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reflog" '("magit-reflog-"))) - -;;;*** - -;;;### (autoloads nil "magit-refs" "magit-refs.el" (0 0 0 0)) -;;; Generated autoloads from magit-refs.el - (autoload 'magit-show-refs "magit-refs" nil t) - -(autoload 'magit-show-refs-head "magit-refs" "\ -List and compare references in a dedicated buffer. -Compared with `HEAD'. - -\(fn &optional ARGS)" t nil) - -(autoload 'magit-show-refs-current "magit-refs" "\ -List and compare references in a dedicated buffer. -Compare with the current branch or `HEAD' if it is detached. - -\(fn &optional ARGS)" t nil) - -(autoload 'magit-show-refs-other "magit-refs" "\ -List and compare references in a dedicated buffer. -Compared with a branch read from the user. - -\(fn &optional REF ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-refs" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-remote" "magit-remote.el" (0 0 0 0)) -;;; Generated autoloads from magit-remote.el - (autoload 'magit-remote "magit-remote" nil t) - -(autoload 'magit-remote-add "magit-remote" "\ -Add a remote named REMOTE and fetch it. - -\(fn REMOTE URL &optional ARGS)" t nil) - -(autoload 'magit-remote-rename "magit-remote" "\ -Rename the remote named OLD to NEW. - -\(fn OLD NEW)" t nil) - -(autoload 'magit-remote-remove "magit-remote" "\ -Delete the remote named REMOTE. - -\(fn REMOTE)" t nil) - -(autoload 'magit-remote-prune "magit-remote" "\ -Remove stale remote-tracking branches for REMOTE. - -\(fn REMOTE)" t nil) - -(autoload 'magit-remote-prune-refspecs "magit-remote" "\ -Remove stale refspecs for REMOTE. - -A refspec is stale if there no longer exists at least one branch -on the remote that would be fetched due to that refspec. A stale -refspec is problematic because its existence causes Git to refuse -to fetch according to the remaining non-stale refspecs. - -If only stale refspecs remain, then offer to either delete the -remote or to replace the stale refspecs with the default refspec. - -Also remove the remote-tracking branches that were created due to -the now stale refspecs. Other stale branches are not removed. - -\(fn REMOTE)" t nil) - -(autoload 'magit-remote-set-head "magit-remote" "\ -Set the local representation of REMOTE's default branch. -Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD -accordingly. With a prefix argument query for the branch to be -used, which allows you to select an incorrect value if you fancy -doing that. - -\(fn REMOTE &optional BRANCH)" t nil) - -(autoload 'magit-remote-unset-head "magit-remote" "\ -Unset the local representation of REMOTE's default branch. -Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\". - -\(fn REMOTE)" t nil) - (autoload 'magit-remote-configure "magit-remote" nil t) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-remote" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-repos" "magit-repos.el" (0 0 0 0)) -;;; Generated autoloads from magit-repos.el - -(autoload 'magit-list-repositories "magit-repos" "\ -Display a list of repositories. - -Use the options `magit-repository-directories' to control which -repositories are displayed. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-repos" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-reset" "magit-reset.el" (0 0 0 0)) -;;; Generated autoloads from magit-reset.el - (autoload 'magit-reset "magit" nil t) - -(autoload 'magit-reset-mixed "magit-reset" "\ -Reset the `HEAD' and index to COMMIT, but not the working tree. - -\(git reset --mixed COMMIT) - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-soft "magit-reset" "\ -Reset the `HEAD' to COMMIT, but not the index and working tree. - -\(git reset --soft REVISION) - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-hard "magit-reset" "\ -Reset the `HEAD', index, and working tree to COMMIT. - -\(git reset --hard REVISION) - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-keep "magit-reset" "\ -Reset the `HEAD' and index to COMMIT, while keeping uncommitted changes. - -\(git reset --keep REVISION) - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-index "magit-reset" "\ -Reset the index to COMMIT. -Keep the `HEAD' and working tree as-is, so if COMMIT refers to the -head this effectively unstages all changes. - -\(git reset COMMIT .) - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-worktree "magit-reset" "\ -Reset the worktree to COMMIT. -Keep the `HEAD' and index as-is. - -\(fn COMMIT)" t nil) - -(autoload 'magit-reset-quickly "magit-reset" "\ -Reset the `HEAD' and index to COMMIT, and possibly the working tree. -With a prefix argument reset the working tree otherwise don't. - -\(git reset --mixed|--hard COMMIT) - -\(fn COMMIT &optional HARD)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reset" '("magit-reset-"))) - -;;;*** - -;;;### (autoloads nil "magit-section" "magit-section.el" (0 0 0 0)) -;;; Generated autoloads from magit-section.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-section" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (0 0 0 -;;;;;; 0)) -;;; Generated autoloads from magit-sequence.el - -(autoload 'magit-sequencer-continue "magit-sequence" "\ -Resume the current cherry-pick or revert sequence. - -\(fn)" t nil) - -(autoload 'magit-sequencer-skip "magit-sequence" "\ -Skip the stopped at commit during a cherry-pick or revert sequence. - -\(fn)" t nil) - -(autoload 'magit-sequencer-abort "magit-sequence" "\ -Abort the current cherry-pick or revert sequence. -This discards all changes made since the sequence started. - -\(fn)" t nil) - (autoload 'magit-cherry-pick "magit-sequence" nil t) - -(autoload 'magit-cherry-copy "magit-sequence" "\ -Copy COMMITS from another branch onto the current branch. -Prompt for a commit, defaulting to the commit at point. If -the region selects multiple commits, then pick all of them, -without prompting. - -\(fn COMMITS &optional ARGS)" t nil) - -(autoload 'magit-cherry-apply "magit-sequence" "\ -Apply the changes in COMMITS but do not commit them. -Prompt for a commit, defaulting to the commit at point. If -the region selects multiple commits, then apply all of them, -without prompting. - -\(fn COMMITS &optional ARGS)" t nil) - -(autoload 'magit-cherry-harvest "magit-sequence" "\ -Move COMMITS from another BRANCH onto the current branch. -Remove the COMMITS from BRANCH and stay on the current branch. -If a conflict occurs, then you have to fix that and finish the -process manually. - -\(fn COMMITS BRANCH &optional ARGS)" t nil) - -(autoload 'magit-cherry-donate "magit-sequence" "\ -Move COMMITS from the current branch onto another existing BRANCH. -Remove COMMITS from the current branch and stay on that branch. -If a conflict occurs, then you have to fix that and finish the -process manually. - -\(fn COMMITS BRANCH &optional ARGS)" t nil) - -(autoload 'magit-cherry-spinout "magit-sequence" "\ -Move COMMITS from the current branch onto a new BRANCH. -Remove COMMITS from the current branch and stay on that branch. -If a conflict occurs, then you have to fix that and finish the -process manually. - -\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil) - -(autoload 'magit-cherry-spinoff "magit-sequence" "\ -Move COMMITS from the current branch onto a new BRANCH. -Remove COMMITS from the current branch and checkout BRANCH. -If a conflict occurs, then you have to fix that and finish -the process manually. - -\(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil) - (autoload 'magit-revert "magit-sequence" nil t) - -(autoload 'magit-revert-and-commit "magit-sequence" "\ -Revert COMMIT by creating a new commit. -Prompt for a commit, defaulting to the commit at point. If -the region selects multiple commits, then revert all of them, -without prompting. - -\(fn COMMIT &optional ARGS)" t nil) - -(autoload 'magit-revert-no-commit "magit-sequence" "\ -Revert COMMIT by applying it in reverse to the worktree. -Prompt for a commit, defaulting to the commit at point. If -the region selects multiple commits, then revert all of them, -without prompting. - -\(fn COMMIT &optional ARGS)" t nil) - (autoload 'magit-am "magit-sequence" nil t) - -(autoload 'magit-am-apply-patches "magit-sequence" "\ -Apply the patches FILES. - -\(fn &optional FILES ARGS)" t nil) - -(autoload 'magit-am-apply-maildir "magit-sequence" "\ -Apply the patches from MAILDIR. - -\(fn &optional MAILDIR ARGS)" t nil) - -(autoload 'magit-am-continue "magit-sequence" "\ -Resume the current patch applying sequence. - -\(fn)" t nil) - -(autoload 'magit-am-skip "magit-sequence" "\ -Skip the stopped at patch during a patch applying sequence. - -\(fn)" t nil) - -(autoload 'magit-am-abort "magit-sequence" "\ -Abort the current patch applying sequence. -This discards all changes made since the sequence started. - -\(fn)" t nil) - (autoload 'magit-rebase "magit-sequence" nil t) - (autoload 'magit-rebase-onto-pushremote "magit-sequence" nil t) - (autoload 'magit-rebase-onto-upstream "magit-sequence" nil t) - -(autoload 'magit-rebase-branch "magit-sequence" "\ -Rebase the current branch onto a branch read in the minibuffer. -All commits that are reachable from `HEAD' but not from the -selected branch TARGET are being rebased. - -\(fn TARGET ARGS)" t nil) - -(autoload 'magit-rebase-subset "magit-sequence" "\ -Rebase a subset of the current branch's history onto a new base. -Rebase commits from START to `HEAD' onto NEWBASE. -START has to be selected from a list of recent commits. - -\(fn NEWBASE START ARGS)" t nil) - -(autoload 'magit-rebase-interactive "magit-sequence" "\ -Start an interactive rebase sequence. - -\(fn COMMIT ARGS)" t nil) - -(autoload 'magit-rebase-autosquash "magit-sequence" "\ -Combine squash and fixup commits with their intended targets. - -\(fn ARGS)" t nil) - -(autoload 'magit-rebase-edit-commit "magit-sequence" "\ -Edit a single older commit using rebase. - -\(fn COMMIT ARGS)" t nil) - -(autoload 'magit-rebase-reword-commit "magit-sequence" "\ -Reword a single older commit using rebase. - -\(fn COMMIT ARGS)" t nil) - -(autoload 'magit-rebase-remove-commit "magit-sequence" "\ -Remove a single older commit using rebase. - -\(fn COMMIT ARGS)" t nil) - -(autoload 'magit-rebase-continue "magit-sequence" "\ -Restart the current rebasing operation. -In some cases this pops up a commit message buffer for you do -edit. With a prefix argument the old message is reused as-is. - -\(fn &optional NOEDIT)" t nil) - -(autoload 'magit-rebase-skip "magit-sequence" "\ -Skip the current commit and restart the current rebase operation. - -\(fn)" t nil) - -(autoload 'magit-rebase-edit "magit-sequence" "\ -Edit the todo list of the current rebase operation. - -\(fn)" t nil) - -(autoload 'magit-rebase-abort "magit-sequence" "\ -Abort the current rebase operation, restoring the original branch. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-sequence" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-stash" "magit-stash.el" (0 0 0 0)) -;;; Generated autoloads from magit-stash.el - (autoload 'magit-stash "magit-stash" nil t) - -(autoload 'magit-stash-both "magit-stash" "\ -Create a stash of the index and working tree. -Untracked files are included according to infix arguments. -One prefix argument is equivalent to `--include-untracked' -while two prefix arguments are equivalent to `--all'. - -\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil) - -(autoload 'magit-stash-index "magit-stash" "\ -Create a stash of the index only. -Unstaged and untracked changes are not stashed. The stashed -changes are applied in reverse to both the index and the -worktree. This command can fail when the worktree is not clean. -Applying the resulting stash has the inverse effect. - -\(fn MESSAGE)" t nil) - -(autoload 'magit-stash-worktree "magit-stash" "\ -Create a stash of unstaged changes in the working tree. -Untracked files are included according to infix arguments. -One prefix argument is equivalent to `--include-untracked' -while two prefix arguments are equivalent to `--all'. - -\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil) - -(autoload 'magit-stash-keep-index "magit-stash" "\ -Create a stash of the index and working tree, keeping index intact. -Untracked files are included according to infix arguments. -One prefix argument is equivalent to `--include-untracked' -while two prefix arguments are equivalent to `--all'. - -\(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil) - -(autoload 'magit-snapshot-both "magit-stash" "\ -Create a snapshot of the index and working tree. -Untracked files are included according to infix arguments. -One prefix argument is equivalent to `--include-untracked' -while two prefix arguments are equivalent to `--all'. - -\(fn &optional INCLUDE-UNTRACKED)" t nil) - -(autoload 'magit-snapshot-index "magit-stash" "\ -Create a snapshot of the index only. -Unstaged and untracked changes are not stashed. - -\(fn)" t nil) - -(autoload 'magit-snapshot-worktree "magit-stash" "\ -Create a snapshot of unstaged changes in the working tree. -Untracked files are included according to infix arguments. -One prefix argument is equivalent to `--include-untracked' -while two prefix arguments are equivalent to `--all'. - -\(fn &optional INCLUDE-UNTRACKED)" t nil) - -(autoload 'magit-stash-apply "magit-stash" "\ -Apply a stash to the working tree. -Try to preserve the stash index. If that fails because there -are staged changes, apply without preserving the stash index. - -\(fn STASH)" t nil) - -(autoload 'magit-stash-drop "magit-stash" "\ -Remove a stash from the stash list. -When the region is active offer to drop all contained stashes. - -\(fn STASH)" t nil) - -(autoload 'magit-stash-clear "magit-stash" "\ -Remove all stashes saved in REF's reflog by deleting REF. - -\(fn REF)" t nil) - -(autoload 'magit-stash-branch "magit-stash" "\ -Create and checkout a new BRANCH from STASH. - -\(fn STASH BRANCH)" t nil) - -(autoload 'magit-stash-branch-here "magit-stash" "\ -Create and checkout a new BRANCH and apply STASH. -The branch is created using `magit-branch-and-checkout', using the -current branch or `HEAD' as the start-point. - -\(fn STASH BRANCH)" t nil) - -(autoload 'magit-stash-format-patch "magit-stash" "\ -Create a patch from STASH - -\(fn STASH)" t nil) - -(autoload 'magit-stash-list "magit-stash" "\ -List all stashes in a buffer. - -\(fn)" t nil) - -(autoload 'magit-stash-show "magit-stash" "\ -Show all diffs of a stash in a buffer. - -\(fn STASH &optional ARGS FILES)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-stash" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-status" "magit-status.el" (0 0 0 0)) -;;; Generated autoloads from magit-status.el - -(autoload 'magit-init "magit-status" "\ -Initialize a Git repository, then show its status. - -If the directory is below an existing repository, then the user -has to confirm that a new one should be created inside. If the -directory is the root of the existing repository, then the user -has to confirm that it should be reinitialized. - -Non-interactively DIRECTORY is (re-)initialized unconditionally. - -\(fn DIRECTORY)" t nil) - -(autoload 'magit-status "magit-status" "\ -Show the status of the current Git repository in a buffer. - -If the current directory isn't located within a Git repository, -then prompt for an existing repository or an arbitrary directory, -depending on option `magit-repository-directories', and show the -status of the selected repository instead. - -* If that option specifies any existing repositories, then offer - those for completion and show the status buffer for the - selected one. - -* Otherwise read an arbitrary directory using regular file-name - completion. If the selected directory is the top-level of an - existing working tree, then show the status buffer for that. - -* Otherwise offer to initialize the selected directory as a new - repository. After creating the repository show its status - buffer. - -These fallback behaviors can also be forced using one or more -prefix arguments: - -* With two prefix arguments (or more precisely a numeric prefix - value of 16 or greater) read an arbitrary directory and act on - it as described above. The same could be accomplished using - the command `magit-init'. - -* With a single prefix argument read an existing repository, or - if none can be found based on `magit-repository-directories', - then fall back to the same behavior as with two prefix - arguments. - -\(fn &optional DIRECTORY CACHE)" t nil) - -(defalias 'magit 'magit-status "\ -An alias for `magit-status' for better discoverability. - -Instead of invoking this alias for `magit-status' using -\"M-x magit RET\", you should bind a key to `magit-status' -and read the info node `(magit)Getting Started', which -also contains other useful hints.") - -(autoload 'magit-status-here "magit-status" "\ -Like `magit-status' but with non-nil `magit-status-goto-file-position'. - -\(fn)" t nil) - -(autoload 'magit-status-setup-buffer "magit-status" "\ - - -\(fn &optional DIRECTORY)" nil nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-status" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (0 0 -;;;;;; 0 0)) -;;; Generated autoloads from magit-submodule.el - (autoload 'magit-submodule "magit-submodule" nil t) - (autoload 'magit-submodule-add "magit-submodule" nil t) - -(autoload 'magit-submodule-read-name-for-path "magit-submodule" "\ - - -\(fn PATH &optional PREFER-SHORT)" nil nil) - (autoload 'magit-submodule-register "magit-submodule" nil t) - (autoload 'magit-submodule-populate "magit-submodule" nil t) - (autoload 'magit-submodule-update "magit-submodule" nil t) - (autoload 'magit-submodule-synchronize "magit-submodule" nil t) - (autoload 'magit-submodule-unpopulate "magit-submodule" nil t) - -(autoload 'magit-submodule-remove "magit-submodule" "\ -Unregister MODULES and remove their working directories. - -For safety reasons, do not remove the gitdirs and if a module has -uncommitted changes, then do not remove it at all. If a module's -gitdir is located inside the working directory, then move it into -the gitdir of the superproject first. - -With the \"--force\" argument offer to remove dirty working -directories and with a prefix argument offer to delete gitdirs. -Both actions are very dangerous and have to be confirmed. There -are additional safety precautions in place, so you might be able -to recover from making a mistake here, but don't count on it. - -\(fn MODULES ARGS TRASH-GITDIRS)" t nil) - -(autoload 'magit-insert-modules "magit-submodule" "\ -Insert submodule sections. -Hook `magit-module-sections-hook' controls which module sections -are inserted, and option `magit-module-sections-nested' controls -whether they are wrapped in an additional section. - -\(fn)" nil nil) - -(autoload 'magit-insert-modules-overview "magit-submodule" "\ -Insert sections for all modules. -For each section insert the path and the output of `git describe --tags', -or, failing that, the abbreviated HEAD commit hash. - -\(fn)" nil nil) - -(autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\ -Insert sections for modules that haven't been pulled from the upstream. -These sections can be expanded to show the respective commits. - -\(fn)" nil nil) - -(autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\ -Insert sections for modules that haven't been pulled from the push-remote. -These sections can be expanded to show the respective commits. - -\(fn)" nil nil) - -(autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\ -Insert sections for modules that haven't been pushed to the upstream. -These sections can be expanded to show the respective commits. - -\(fn)" nil nil) - -(autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\ -Insert sections for modules that haven't been pushed to the push-remote. -These sections can be expanded to show the respective commits. - -\(fn)" nil nil) - -(autoload 'magit-list-submodules "magit-submodule" "\ -Display a list of the current repository's submodules. - -\(fn)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-submodule" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (0 0 0 0)) -;;; Generated autoloads from magit-subtree.el - (autoload 'magit-subtree "magit-subtree" nil t) - (autoload 'magit-subtree-import "magit-subtree" nil t) - (autoload 'magit-subtree-export "magit-subtree" nil t) - -(autoload 'magit-subtree-add "magit-subtree" "\ -Add REF from REPOSITORY as a new subtree at PREFIX. - -\(fn PREFIX REPOSITORY REF ARGS)" t nil) - -(autoload 'magit-subtree-add-commit "magit-subtree" "\ -Add COMMIT as a new subtree at PREFIX. - -\(fn PREFIX COMMIT ARGS)" t nil) - -(autoload 'magit-subtree-merge "magit-subtree" "\ -Merge COMMIT into the PREFIX subtree. - -\(fn PREFIX COMMIT ARGS)" t nil) - -(autoload 'magit-subtree-pull "magit-subtree" "\ -Pull REF from REPOSITORY into the PREFIX subtree. - -\(fn PREFIX REPOSITORY REF ARGS)" t nil) - -(autoload 'magit-subtree-push "magit-subtree" "\ -Extract the history of the subtree PREFIX and push it to REF on REPOSITORY. - -\(fn PREFIX REPOSITORY REF ARGS)" t nil) - -(autoload 'magit-subtree-split "magit-subtree" "\ -Extract the history of the subtree PREFIX. - -\(fn PREFIX COMMIT ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-subtree" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-tag" "magit-tag.el" (0 0 0 0)) -;;; Generated autoloads from magit-tag.el - (autoload 'magit-tag "magit" nil t) - -(autoload 'magit-tag-create "magit-tag" "\ -Create a new tag with the given NAME at REV. -With a prefix argument annotate the tag. - -\(git tag [--annotate] NAME REV) - -\(fn NAME REV &optional ARGS)" t nil) - -(autoload 'magit-tag-delete "magit-tag" "\ -Delete one or more tags. -If the region marks multiple tags (and nothing else), then offer -to delete those, otherwise prompt for a single tag to be deleted, -defaulting to the tag at point. - -\(git tag -d TAGS) - -\(fn TAGS)" t nil) - -(autoload 'magit-tag-prune "magit-tag" "\ -Offer to delete tags missing locally from REMOTE, and vice versa. - -\(fn TAGS REMOTE-TAGS REMOTE)" t nil) - -(autoload 'magit-tag-release "magit-tag" "\ -Create a release tag. - -Assume that release tags match `magit-release-tag-regexp'. - -First prompt for the name of the new tag using the highest -existing tag as initial input and leaving it to the user to -increment the desired part of the version string. - -If `--annotate' is enabled, then prompt for the message of the -new tag. Base the proposed tag message on the message of the -highest tag, provided that that contains the corresponding -version string and substituting the new version string for that. -Otherwise propose something like \"Foo-Bar 1.2.3\", given, for -example, a TAG \"v1.2.3\" and a repository located at something -like \"/path/to/foo-bar\". - -\(fn TAG MSG &optional ARGS)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-tag" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-transient" "magit-transient.el" (0 0 -;;;;;; 0 0)) -;;; Generated autoloads from magit-transient.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-transient" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-utils" "magit-utils.el" (0 0 0 0)) -;;; Generated autoloads from magit-utils.el - -(autoload 'magit-emacs-Q-command "magit-utils" "\ -Show a shell command that runs an uncustomized Emacs with only Magit loaded. -See info node `(magit)Debugging Tools' for more information. - -\(fn)" t nil) - -(autoload 'Info-follow-nearest-node--magit-gitman "magit-utils" "\ - - -\(fn FN &optional FORK)" nil nil) - -(advice-add 'Info-follow-nearest-node :around 'Info-follow-nearest-node--magit-gitman) - -(autoload 'org-man-export--magit-gitman "magit-utils" "\ - - -\(fn FN LINK DESCRIPTION FORMAT)" nil nil) - -(advice-add 'org-man-export :around 'org-man-export--magit-gitman) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-utils" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-wip" "magit-wip.el" (0 0 0 0)) -;;; Generated autoloads from magit-wip.el - -(defvar magit-wip-after-save-mode nil "\ -Non-nil if Magit-Wip-After-Save mode is enabled. -See the `magit-wip-after-save-mode' command -for a description of this minor mode. -Setting this variable directly does not take effect; -either customize it (see the info node `Easy Customization') -or call the function `magit-wip-after-save-mode'.") - -(custom-autoload 'magit-wip-after-save-mode "magit-wip" nil) - -(autoload 'magit-wip-after-save-mode "magit-wip" "\ -Toggle Magit-Wip-After-Save-Local mode in all buffers. -With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive; -otherwise, disable it. If called from Lisp, enable the mode if -ARG is omitted or nil. - -Magit-Wip-After-Save-Local mode is enabled in all buffers where -`magit-wip-after-save-local-mode-turn-on' would do it. -See `magit-wip-after-save-local-mode' for more information on Magit-Wip-After-Save-Local mode. - -\(fn &optional ARG)" t nil) - -(defvar magit-wip-after-apply-mode nil "\ -Non-nil if Magit-Wip-After-Apply mode is enabled. -See the `magit-wip-after-apply-mode' command -for a description of this minor mode.") - -(custom-autoload 'magit-wip-after-apply-mode "magit-wip" nil) - -(autoload 'magit-wip-after-apply-mode "magit-wip" "\ -Commit to work-in-progress refs. - -After applying a change using any \"apply variant\" -command (apply, stage, unstage, discard, and reverse) commit the -affected files to the current wip refs. For each branch there -may be two wip refs; one contains snapshots of the files as found -in the worktree and the other contains snapshots of the entries -in the index. - -\(fn &optional ARG)" t nil) - -(defvar magit-wip-before-change-mode nil "\ -Non-nil if Magit-Wip-Before-Change mode is enabled. -See the `magit-wip-before-change-mode' command -for a description of this minor mode.") - -(custom-autoload 'magit-wip-before-change-mode "magit-wip" nil) - -(autoload 'magit-wip-before-change-mode "magit-wip" "\ -Commit to work-in-progress refs before certain destructive changes. - -Before invoking a revert command or an \"apply variant\" -command (apply, stage, unstage, discard, and reverse) commit the -affected tracked files to the current wip refs. For each branch -there may be two wip refs; one contains snapshots of the files -as found in the worktree and the other contains snapshots of the -entries in the index. - -Only changes to files which could potentially be affected by the -command which is about to be called are committed. - -\(fn &optional ARG)" t nil) - -(autoload 'magit-wip-commit-initial-backup "magit-wip" "\ -Before saving, commit current file to a worktree wip ref. - -The user has to add this function to `before-save-hook'. - -Commit the current state of the visited file before saving the -current buffer to that file. This backs up the same version of -the file as `backup-buffer' would, but stores the backup in the -worktree wip ref, which is also used by the various Magit Wip -modes, instead of in a backup file as `backup-buffer' would. - -This function ignores the variables that affect `backup-buffer' -and can be used along-side that function, which is recommended -because this function only backs up files that are tracked in -a Git repository. - -\(fn)" nil nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-wip" '("magit-"))) - -;;;*** - -;;;### (autoloads nil "magit-worktree" "magit-worktree.el" (0 0 0 -;;;;;; 0)) -;;; Generated autoloads from magit-worktree.el - (autoload 'magit-worktree "magit-worktree" nil t) - -(autoload 'magit-worktree-checkout "magit-worktree" "\ -Checkout BRANCH in a new worktree at PATH. - -\(fn PATH BRANCH)" t nil) - -(autoload 'magit-worktree-branch "magit-worktree" "\ -Create a new BRANCH and check it out in a new worktree at PATH. - -\(fn PATH BRANCH START-POINT &optional FORCE)" t nil) - -(autoload 'magit-worktree-move "magit-worktree" "\ -Move WORKTREE to PATH. - -\(fn WORKTREE PATH)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-worktree" '("magit-"))) - -;;;*** - -;;;### (autoloads nil nil ("magit-core.el" "magit-pkg.el") (0 0 0 -;;;;;; 0)) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; coding: utf-8 -;; End: -;;; magit-autoloads.el ends here |