No puede seleccionar más de 25 temas
Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
2482 líneas
81 KiB
2482 líneas
81 KiB
;;; 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)
|
|
|
|
(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-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. The 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 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.
|
|
|
|
\(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-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-")))
|
|
|
|
;;;***
|
|
|
|
;;;### (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 publically 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-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-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', using the current
|
|
branch or `HEAD' as the string-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)
|
|
|
|
(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
|
|
uncomitted 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 an annotated 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.
|
|
|
|
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\".
|
|
|
|
Then call \"git tag --annotate --sign -m MSG TAG\" to create the,
|
|
tag, regardless of whether these arguments are enabled in the
|
|
popup. Finally show the refs buffer to let the user quickly
|
|
review the result.
|
|
|
|
\(fn TAG MSG)" 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)
|
|
|
|
(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
|