Klimi's new dotfiles with stow.
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

hace 4 años
  1. ;;; magit-autoloads.el --- automatically extracted autoloads
  2. ;;
  3. ;;; Code:
  4. (add-to-list 'load-path (directory-file-name
  5. (or (file-name-directory #$) (car load-path))))
  6. ;;;### (autoloads nil "git-rebase" "git-rebase.el" (0 0 0 0))
  7. ;;; Generated autoloads from git-rebase.el
  8. (autoload 'git-rebase-current-line "git-rebase" "\
  9. Parse current line into a `git-rebase-action' instance.
  10. If the current line isn't recognized as a rebase line, an
  11. instance with all nil values is returned.
  12. \(fn)" nil nil)
  13. (autoload 'git-rebase-mode "git-rebase" "\
  14. Major mode for editing of a Git rebase file.
  15. Rebase files are generated when you run 'git rebase -i' or run
  16. `magit-interactive-rebase'. They describe how Git should perform
  17. the rebase. See the documentation for git-rebase (e.g., by
  18. running 'man git-rebase' at the command line) for details.
  19. \(fn)" t nil)
  20. (defconst git-rebase-filename-regexp "/git-rebase-todo\\'")
  21. (add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp 'git-rebase-mode))
  22. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "git-rebase" '("git-rebase-")))
  23. ;;;***
  24. ;;;### (autoloads nil "magit" "magit.el" (0 0 0 0))
  25. ;;; Generated autoloads from magit.el
  26. (autoload 'magit-dispatch "magit" nil t)
  27. (autoload 'magit-run "magit" nil t)
  28. (autoload 'magit-git-command "magit" "\
  29. Execute COMMAND asynchronously; display output.
  30. Interactively, prompt for COMMAND in the minibuffer. \"git \" is
  31. used as initial input, but can be deleted to run another command.
  32. With a prefix argument COMMAND is run in the top-level directory
  33. of the current working tree, otherwise in `default-directory'.
  34. \(fn COMMAND)" t nil)
  35. (autoload 'magit-git-command-topdir "magit" "\
  36. Execute COMMAND asynchronously; display output.
  37. Interactively, prompt for COMMAND in the minibuffer. \"git \" is
  38. used as initial input, but can be deleted to run another command.
  39. COMMAND is run in the top-level directory of the current
  40. working tree.
  41. \(fn COMMAND)" t nil)
  42. (autoload 'magit-shell-command "magit" "\
  43. Execute COMMAND asynchronously; display output.
  44. Interactively, prompt for COMMAND in the minibuffer. With a
  45. prefix argument COMMAND is run in the top-level directory of
  46. the current working tree, otherwise in `default-directory'.
  47. \(fn COMMAND)" t nil)
  48. (autoload 'magit-shell-command-topdir "magit" "\
  49. Execute COMMAND asynchronously; display output.
  50. Interactively, prompt for COMMAND in the minibuffer. COMMAND
  51. is run in the top-level directory of the current working tree.
  52. \(fn COMMAND)" t nil)
  53. (autoload 'magit-version "magit" "\
  54. Return the version of Magit currently in use.
  55. If optional argument PRINT-DEST is non-nil, output
  56. stream (interactively, the echo area, or the current buffer with
  57. a prefix argument), also print the used versions of Magit, Git,
  58. and Emacs to it.
  59. \(fn &optional PRINT-DEST)" t nil)
  60. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit" '("magit-")))
  61. ;;;***
  62. ;;;### (autoloads nil "magit-apply" "magit-apply.el" (0 0 0 0))
  63. ;;; Generated autoloads from magit-apply.el
  64. (autoload 'magit-stage-file "magit-apply" "\
  65. Stage all changes to FILE.
  66. With a prefix argument or when there is no file at point ask for
  67. the file to be staged. Otherwise stage the file at point without
  68. requiring confirmation.
  69. \(fn FILE)" t nil)
  70. (autoload 'magit-stage-modified "magit-apply" "\
  71. Stage all changes to files modified in the worktree.
  72. Stage all new content of tracked files and remove tracked files
  73. that no longer exist in the working tree from the index also.
  74. With a prefix argument also stage previously untracked (but not
  75. ignored) files.
  76. \(fn &optional ALL)" t nil)
  77. (autoload 'magit-unstage-file "magit-apply" "\
  78. Unstage all changes to FILE.
  79. With a prefix argument or when there is no file at point ask for
  80. the file to be unstaged. Otherwise unstage the file at point
  81. without requiring confirmation.
  82. \(fn FILE)" t nil)
  83. (autoload 'magit-unstage-all "magit-apply" "\
  84. Remove all changes from the staging area.
  85. \(fn)" t nil)
  86. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-apply" '("magit-")))
  87. ;;;***
  88. ;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (0
  89. ;;;;;; 0 0 0))
  90. ;;; Generated autoloads from magit-autorevert.el
  91. (defvar magit-auto-revert-mode (not (or global-auto-revert-mode noninteractive)) "\
  92. Non-nil if Magit-Auto-Revert mode is enabled.
  93. See the `magit-auto-revert-mode' command
  94. for a description of this minor mode.
  95. Setting this variable directly does not take effect;
  96. either customize it (see the info node `Easy Customization')
  97. or call the function `magit-auto-revert-mode'.")
  98. (custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
  99. (autoload 'magit-auto-revert-mode "magit-autorevert" "\
  100. Toggle Auto-Revert mode in all buffers.
  101. With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
  102. otherwise, disable it. If called from Lisp, enable the mode if
  103. ARG is omitted or nil.
  104. Auto-Revert mode is enabled in all buffers where
  105. `magit-turn-on-auto-revert-mode-if-desired' would do it.
  106. See `auto-revert-mode' for more information on Auto-Revert mode.
  107. \(fn &optional ARG)" t nil)
  108. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-")))
  109. ;;;***
  110. ;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (0 0 0 0))
  111. ;;; Generated autoloads from magit-bisect.el
  112. (autoload 'magit-bisect "magit-bisect" nil t)
  113. (autoload 'magit-bisect-start "magit-bisect" "\
  114. Start a bisect session.
  115. Bisecting a bug means to find the commit that introduced it.
  116. This command starts such a bisect session by asking for a know
  117. good and a bad commit. To move the session forward use the
  118. other actions from the bisect transient command (\\<magit-status-mode-map>\\[magit-bisect]).
  119. \(fn BAD GOOD)" t nil)
  120. (autoload 'magit-bisect-reset "magit-bisect" "\
  121. After bisecting, cleanup bisection state and return to original `HEAD'.
  122. \(fn)" t nil)
  123. (autoload 'magit-bisect-good "magit-bisect" "\
  124. While bisecting, mark the current commit as good.
  125. Use this after you have asserted that the commit does not contain
  126. the bug in question.
  127. \(fn)" t nil)
  128. (autoload 'magit-bisect-bad "magit-bisect" "\
  129. While bisecting, mark the current commit as bad.
  130. Use this after you have asserted that the commit does contain the
  131. bug in question.
  132. \(fn)" t nil)
  133. (autoload 'magit-bisect-skip "magit-bisect" "\
  134. While bisecting, skip the current commit.
  135. Use this if for some reason the current commit is not a good one
  136. to test. This command lets Git choose a different one.
  137. \(fn)" t nil)
  138. (autoload 'magit-bisect-run "magit-bisect" "\
  139. Bisect automatically by running commands after each step.
  140. Unlike `git bisect run' this can be used before bisecting has
  141. begun. In that case it behaves like `git bisect start; git
  142. bisect run'.
  143. \(fn CMDLINE &optional BAD GOOD)" t nil)
  144. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bisect" '("magit-")))
  145. ;;;***
  146. ;;;### (autoloads nil "magit-blame" "magit-blame.el" (0 0 0 0))
  147. ;;; Generated autoloads from magit-blame.el
  148. (autoload 'magit-blame-echo "magit-blame" nil t)
  149. (autoload 'magit-blame-addition "magit-blame" nil t)
  150. (autoload 'magit-blame-removal "magit-blame" nil t)
  151. (autoload 'magit-blame-reverse "magit-blame" nil t)
  152. (autoload 'magit-blame "magit-blame" nil t)
  153. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-blame" '("magit-")))
  154. ;;;***
  155. ;;;### (autoloads nil "magit-bookmark" "magit-bookmark.el" (0 0 0
  156. ;;;;;; 0))
  157. ;;; Generated autoloads from magit-bookmark.el
  158. (autoload 'magit--handle-bookmark "magit-bookmark" "\
  159. Open a bookmark created by `magit--make-bookmark'.
  160. Call the `magit-*-setup-buffer' function of the the major-mode
  161. with the variables' values as arguments, which were recorded by
  162. `magit--make-bookmark'. Ignore `magit-display-buffer-function'.
  163. \(fn BOOKMARK)" nil nil)
  164. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bookmark" '("magit--make-bookmark")))
  165. ;;;***
  166. ;;;### (autoloads nil "magit-branch" "magit-branch.el" (0 0 0 0))
  167. ;;; Generated autoloads from magit-branch.el
  168. (autoload 'magit-branch "magit" nil t)
  169. (autoload 'magit-checkout "magit-branch" "\
  170. Checkout REVISION, updating the index and the working tree.
  171. If REVISION is a local branch, then that becomes the current
  172. branch. If it is something else, then `HEAD' becomes detached.
  173. Checkout fails if the working tree or the staging area contain
  174. changes.
  175. \(git checkout REVISION).
  176. \(fn REVISION)" t nil)
  177. (autoload 'magit-branch-create "magit-branch" "\
  178. Create BRANCH at branch or revision START-POINT.
  179. \(fn BRANCH START-POINT)" t nil)
  180. (autoload 'magit-branch-and-checkout "magit-branch" "\
  181. Create and checkout BRANCH at branch or revision START-POINT.
  182. \(fn BRANCH START-POINT)" t nil)
  183. (autoload 'magit-branch-or-checkout "magit-branch" "\
  184. Hybrid between `magit-checkout' and `magit-branch-and-checkout'.
  185. Ask the user for an existing branch or revision. If the user
  186. input actually can be resolved as a branch or revision, then
  187. check that out, just like `magit-checkout' would.
  188. Otherwise create and checkout a new branch using the input as
  189. its name. Before doing so read the starting-point for the new
  190. branch. This is similar to what `magit-branch-and-checkout'
  191. does.
  192. \(fn ARG &optional START-POINT)" t nil)
  193. (autoload 'magit-branch-checkout "magit-branch" "\
  194. Checkout an existing or new local branch.
  195. Read a branch name from the user offering all local branches and
  196. a subset of remote branches as candidates. Omit remote branches
  197. for which a local branch by the same name exists from the list
  198. of candidates. The user can also enter a completely new branch
  199. name.
  200. - If the user selects an existing local branch, then check that
  201. out.
  202. - If the user selects a remote branch, then create and checkout
  203. a new local branch with the same name. Configure the selected
  204. remote branch as push target.
  205. - If the user enters a new branch name, then create and check
  206. that out, after also reading the starting-point from the user.
  207. In the latter two cases the upstream is also set. Whether it is
  208. set to the chosen START-POINT or something else depends on the
  209. value of `magit-branch-adjust-remote-upstream-alist', just like
  210. when using `magit-branch-and-checkout'.
  211. \(fn BRANCH &optional START-POINT)" t nil)
  212. (autoload 'magit-branch-orphan "magit-branch" "\
  213. Create and checkout an orphan BRANCH with contents from revision START-POINT.
  214. \(fn BRANCH START-POINT)" t nil)
  215. (autoload 'magit-branch-spinout "magit-branch" "\
  216. Create new branch from the unpushed commits.
  217. Like `magit-branch-spinoff' but remain on the current branch.
  218. If there are any uncommitted changes, then behave exactly like
  219. `magit-branch-spinoff'.
  220. \(fn BRANCH &optional FROM)" t nil)
  221. (autoload 'magit-branch-spinoff "magit-branch" "\
  222. Create new branch from the unpushed commits.
  223. Create and checkout a new branch starting at and tracking the
  224. current branch. That branch in turn is reset to the last commit
  225. it shares with its upstream. If the current branch has no
  226. upstream or no unpushed commits, then the new branch is created
  227. anyway and the previously current branch is not touched.
  228. This is useful to create a feature branch after work has already
  229. began on the old branch (likely but not necessarily \"master\").
  230. If the current branch is a member of the value of option
  231. `magit-branch-prefer-remote-upstream' (which see), then the
  232. current branch will be used as the starting point as usual, but
  233. the upstream of the starting-point may be used as the upstream
  234. of the new branch, instead of the starting-point itself.
  235. If optional FROM is non-nil, then the source branch is reset
  236. to `FROM~', instead of to the last commit it shares with its
  237. upstream. Interactively, FROM is only ever non-nil, if the
  238. region selects some commits, and among those commits, FROM is
  239. the commit that is the fewest commits ahead of the source
  240. branch.
  241. The commit at the other end of the selection actually does not
  242. matter, all commits between FROM and `HEAD' are moved to the new
  243. branch. If FROM is not reachable from `HEAD' or is reachable
  244. from the source branch's upstream, then an error is raised.
  245. \(fn BRANCH &optional FROM)" t nil)
  246. (autoload 'magit-branch-reset "magit-branch" "\
  247. Reset a branch to the tip of another branch or any other commit.
  248. When the branch being reset is the current branch, then do a
  249. hard reset. If there are any uncommitted changes, then the user
  250. has to confirm the reset because those changes would be lost.
  251. This is useful when you have started work on a feature branch but
  252. realize it's all crap and want to start over.
  253. When resetting to another branch and a prefix argument is used,
  254. then also set the target branch as the upstream of the branch
  255. that is being reset.
  256. \(fn BRANCH TO &optional SET-UPSTREAM)" t nil)
  257. (autoload 'magit-branch-delete "magit-branch" "\
  258. Delete one or multiple branches.
  259. If the region marks multiple branches, then offer to delete
  260. those, otherwise prompt for a single branch to be deleted,
  261. defaulting to the branch at point.
  262. \(fn BRANCHES &optional FORCE)" t nil)
  263. (autoload 'magit-branch-rename "magit-branch" "\
  264. Rename the branch named OLD to NEW.
  265. With a prefix argument FORCE, rename even if a branch named NEW
  266. already exists.
  267. If `branch.OLD.pushRemote' is set, then unset it. Depending on
  268. the value of `magit-branch-rename-push-target' (which see) maybe
  269. set `branch.NEW.pushRemote' and maybe rename the push-target on
  270. the remote.
  271. \(fn OLD NEW &optional FORCE)" t nil)
  272. (autoload 'magit-branch-shelve "magit-branch" "\
  273. Shelve a BRANCH.
  274. Rename \"refs/heads/BRANCH\" to \"refs/shelved/BRANCH\",
  275. and also rename the respective reflog file.
  276. \(fn BRANCH)" t nil)
  277. (autoload 'magit-branch-unshelve "magit-branch" "\
  278. Unshelve a BRANCH
  279. Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\",
  280. and also rename the respective reflog file.
  281. \(fn BRANCH)" t nil)
  282. (autoload 'magit-branch-configure "magit-branch" nil t)
  283. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-branch" '("magit-")))
  284. ;;;***
  285. ;;;### (autoloads nil "magit-clone" "magit-clone.el" (0 0 0 0))
  286. ;;; Generated autoloads from magit-clone.el
  287. (autoload 'magit-clone "magit-clone" nil t)
  288. (autoload 'magit-clone-regular "magit-clone" "\
  289. Create a clone of REPOSITORY in DIRECTORY.
  290. Then show the status buffer for the new repository.
  291. \(fn REPOSITORY DIRECTORY ARGS)" t nil)
  292. (autoload 'magit-clone-shallow "magit-clone" "\
  293. Create a shallow clone of REPOSITORY in DIRECTORY.
  294. Then show the status buffer for the new repository.
  295. With a prefix argument read the DEPTH of the clone;
  296. otherwise use 1.
  297. \(fn REPOSITORY DIRECTORY ARGS DEPTH)" t nil)
  298. (autoload 'magit-clone-shallow-since "magit-clone" "\
  299. Create a shallow clone of REPOSITORY in DIRECTORY.
  300. Then show the status buffer for the new repository.
  301. Exclude commits before DATE, which is read from the
  302. user.
  303. \(fn REPOSITORY DIRECTORY ARGS DATE)" t nil)
  304. (autoload 'magit-clone-shallow-exclude "magit-clone" "\
  305. Create a shallow clone of REPOSITORY in DIRECTORY.
  306. Then show the status buffer for the new repository.
  307. Exclude commits reachable from EXCLUDE, which is a
  308. branch or tag read from the user.
  309. \(fn REPOSITORY DIRECTORY ARGS EXCLUDE)" t nil)
  310. (autoload 'magit-clone-bare "magit-clone" "\
  311. Create a bare clone of REPOSITORY in DIRECTORY.
  312. Then show the status buffer for the new repository.
  313. \(fn REPOSITORY DIRECTORY ARGS)" t nil)
  314. (autoload 'magit-clone-mirror "magit-clone" "\
  315. Create a mirror of REPOSITORY in DIRECTORY.
  316. Then show the status buffer for the new repository.
  317. \(fn REPOSITORY DIRECTORY ARGS)" t nil)
  318. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-clone" '("magit-clone")))
  319. ;;;***
  320. ;;;### (autoloads nil "magit-commit" "magit-commit.el" (0 0 0 0))
  321. ;;; Generated autoloads from magit-commit.el
  322. (autoload 'magit-commit "magit-commit" nil t)
  323. (autoload 'magit-commit-create "magit-commit" "\
  324. Create a new commit on `HEAD'.
  325. With a prefix argument, amend to the commit at `HEAD' instead.
  326. \(git commit [--amend] ARGS)
  327. \(fn &optional ARGS)" t nil)
  328. (autoload 'magit-commit-amend "magit-commit" "\
  329. Amend the last commit.
  330. \(git commit --amend ARGS)
  331. \(fn &optional ARGS)" t nil)
  332. (autoload 'magit-commit-extend "magit-commit" "\
  333. Amend the last commit, without editing the message.
  334. With a prefix argument keep the committer date, otherwise change
  335. it. The option `magit-commit-extend-override-date' can be used
  336. to inverse the meaning of the prefix argument.
  337. \(git commit
  338. --amend --no-edit)
  339. \(fn &optional ARGS OVERRIDE-DATE)" t nil)
  340. (autoload 'magit-commit-reword "magit-commit" "\
  341. Reword the last commit, ignoring staged changes.
  342. With a prefix argument keep the committer date, otherwise change
  343. it. The option `magit-commit-reword-override-date' can be used
  344. to inverse the meaning of the prefix argument.
  345. Non-interactively respect the optional OVERRIDE-DATE argument
  346. and ignore the option.
  347. \(git commit --amend --only)
  348. \(fn &optional ARGS OVERRIDE-DATE)" t nil)
  349. (autoload 'magit-commit-fixup "magit-commit" "\
  350. Create a fixup commit.
  351. With a prefix argument the target COMMIT has to be confirmed.
  352. Otherwise the commit at point may be used without confirmation
  353. depending on the value of option `magit-commit-squash-confirm'.
  354. \(fn &optional COMMIT ARGS)" t nil)
  355. (autoload 'magit-commit-squash "magit-commit" "\
  356. Create a squash commit, without editing the squash message.
  357. With a prefix argument the target COMMIT has to be confirmed.
  358. Otherwise the commit at point may be used without confirmation
  359. depending on the value of option `magit-commit-squash-confirm'.
  360. \(fn &optional COMMIT ARGS)" t nil)
  361. (autoload 'magit-commit-augment "magit-commit" "\
  362. Create a squash commit, editing the squash message.
  363. With a prefix argument the target COMMIT has to be confirmed.
  364. Otherwise the commit at point may be used without confirmation
  365. depending on the value of option `magit-commit-squash-confirm'.
  366. \(fn &optional COMMIT ARGS)" t nil)
  367. (autoload 'magit-commit-instant-fixup "magit-commit" "\
  368. Create a fixup commit targeting COMMIT and instantly rebase.
  369. \(fn &optional COMMIT ARGS)" t nil)
  370. (autoload 'magit-commit-instant-squash "magit-commit" "\
  371. Create a squash commit targeting COMMIT and instantly rebase.
  372. \(fn &optional COMMIT ARGS)" t nil)
  373. (autoload 'magit-commit-reshelve "magit-commit" "\
  374. Change the committer date and possibly the author date of `HEAD'.
  375. If you are the author of `HEAD', then both dates are changed,
  376. otherwise only the committer date. The current time is used
  377. as the initial minibuffer input and the original author (if
  378. that is you) or committer date is available as the previous
  379. history element.
  380. \(fn DATE)" t nil)
  381. (autoload 'magit-commit-absorb "magit-commit" nil t)
  382. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-commit" '("magit")))
  383. ;;;***
  384. ;;;### (autoloads nil "magit-diff" "magit-diff.el" (0 0 0 0))
  385. ;;; Generated autoloads from magit-diff.el
  386. (autoload 'magit-diff "magit-diff" nil t)
  387. (autoload 'magit-diff-refresh "magit-diff" nil t)
  388. (autoload 'magit-diff-dwim "magit-diff" "\
  389. Show changes for the thing at point.
  390. \(fn &optional ARGS FILES)" t nil)
  391. (autoload 'magit-diff-range "magit-diff" "\
  392. Show differences between two commits.
  393. REV-OR-RANGE should be a range or a single revision. If it is a
  394. revision, then show changes in the working tree relative to that
  395. revision. If it is a range, but one side is omitted, then show
  396. changes relative to `HEAD'.
  397. If the region is active, use the revisions on the first and last
  398. line of the region as the two sides of the range. With a prefix
  399. argument, instead of diffing the revisions, choose a revision to
  400. view changes along, starting at the common ancestor of both
  401. revisions (i.e., use a \"...\" range).
  402. \(fn REV-OR-RANGE &optional ARGS FILES)" t nil)
  403. (autoload 'magit-diff-working-tree "magit-diff" "\
  404. Show changes between the current working tree and the `HEAD' commit.
  405. With a prefix argument show changes between the working tree and
  406. a commit read from the minibuffer.
  407. \(fn &optional REV ARGS FILES)" t nil)
  408. (autoload 'magit-diff-staged "magit-diff" "\
  409. Show changes between the index and the `HEAD' commit.
  410. With a prefix argument show changes between the index and
  411. a commit read from the minibuffer.
  412. \(fn &optional REV ARGS FILES)" t nil)
  413. (autoload 'magit-diff-unstaged "magit-diff" "\
  414. Show changes between the working tree and the index.
  415. \(fn &optional ARGS FILES)" t nil)
  416. (autoload 'magit-diff-unmerged "magit-diff" "\
  417. Show changes that are being merged.
  418. \(fn &optional ARGS FILES)" t nil)
  419. (autoload 'magit-diff-while-committing "magit-diff" "\
  420. While committing, show the changes that are about to be committed.
  421. While amending, invoking the command again toggles between
  422. showing just the new changes or all the changes that will
  423. be committed.
  424. \(fn &optional ARGS)" t nil)
  425. (autoload 'magit-diff-buffer-file "magit-diff" "\
  426. Show diff for the blob or file visited in the current buffer.
  427. When the buffer visits a blob, then show the respective commit.
  428. When the buffer visits a file, then show the differenced between
  429. `HEAD' and the working tree. In both cases limit the diff to
  430. the file or blob.
  431. \(fn)" t nil)
  432. (autoload 'magit-diff-paths "magit-diff" "\
  433. Show changes between any two files on disk.
  434. \(fn A B)" t nil)
  435. (autoload 'magit-show-commit "magit-diff" "\
  436. Visit the revision at point in another buffer.
  437. If there is no revision at point or with a prefix argument prompt
  438. for a revision.
  439. \(fn REV &optional ARGS FILES MODULE)" t nil)
  440. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-diff" '("magit")))
  441. ;;;***
  442. ;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (0 0 0 0))
  443. ;;; Generated autoloads from magit-ediff.el
  444. (autoload 'magit-ediff "magit-ediff" nil)
  445. (autoload 'magit-ediff-resolve "magit-ediff" "\
  446. Resolve outstanding conflicts in FILE using Ediff.
  447. FILE has to be relative to the top directory of the repository.
  448. In the rare event that you want to manually resolve all
  449. conflicts, including those already resolved by Git, use
  450. `ediff-merge-revisions-with-ancestor'.
  451. \(fn FILE)" t nil)
  452. (autoload 'magit-ediff-stage "magit-ediff" "\
  453. Stage and unstage changes to FILE using Ediff.
  454. FILE has to be relative to the top directory of the repository.
  455. \(fn FILE)" t nil)
  456. (autoload 'magit-ediff-compare "magit-ediff" "\
  457. Compare REVA:FILEA with REVB:FILEB using Ediff.
  458. FILEA and FILEB have to be relative to the top directory of the
  459. repository. If REVA or REVB is nil, then this stands for the
  460. working tree state.
  461. If the region is active, use the revisions on the first and last
  462. line of the region. With a prefix argument, instead of diffing
  463. the revisions, choose a revision to view changes along, starting
  464. at the common ancestor of both revisions (i.e., use a \"...\"
  465. range).
  466. \(fn REVA REVB FILEA FILEB)" t nil)
  467. (autoload 'magit-ediff-dwim "magit-ediff" "\
  468. Compare, stage, or resolve using Ediff.
  469. This command tries to guess what file, and what commit or range
  470. the user wants to compare, stage, or resolve using Ediff. It
  471. might only be able to guess either the file, or range or commit,
  472. in which case the user is asked about the other. It might not
  473. always guess right, in which case the appropriate `magit-ediff-*'
  474. command has to be used explicitly. If it cannot read the user's
  475. mind at all, then it asks the user for a command to run.
  476. \(fn)" t nil)
  477. (autoload 'magit-ediff-show-staged "magit-ediff" "\
  478. Show staged changes using Ediff.
  479. This only allows looking at the changes; to stage, unstage,
  480. and discard changes using Ediff, use `magit-ediff-stage'.
  481. FILE must be relative to the top directory of the repository.
  482. \(fn FILE)" t nil)
  483. (autoload 'magit-ediff-show-unstaged "magit-ediff" "\
  484. Show unstaged changes using Ediff.
  485. This only allows looking at the changes; to stage, unstage,
  486. and discard changes using Ediff, use `magit-ediff-stage'.
  487. FILE must be relative to the top directory of the repository.
  488. \(fn FILE)" t nil)
  489. (autoload 'magit-ediff-show-working-tree "magit-ediff" "\
  490. Show changes between `HEAD' and working tree using Ediff.
  491. FILE must be relative to the top directory of the repository.
  492. \(fn FILE)" t nil)
  493. (autoload 'magit-ediff-show-commit "magit-ediff" "\
  494. Show changes introduced by COMMIT using Ediff.
  495. \(fn COMMIT)" t nil)
  496. (autoload 'magit-ediff-show-stash "magit-ediff" "\
  497. Show changes introduced by STASH using Ediff.
  498. `magit-ediff-show-stash-with-index' controls whether a
  499. three-buffer Ediff is used in order to distinguish changes in the
  500. stash that were staged.
  501. \(fn STASH)" t nil)
  502. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-ediff" '("magit-ediff")))
  503. ;;;***
  504. ;;;### (autoloads nil "magit-extras" "magit-extras.el" (0 0 0 0))
  505. ;;; Generated autoloads from magit-extras.el
  506. (autoload 'magit-run-git-gui "magit-extras" "\
  507. Run `git gui' for the current git repository.
  508. \(fn)" t nil)
  509. (autoload 'magit-run-git-gui-blame "magit-extras" "\
  510. Run `git gui blame' on the given FILENAME and COMMIT.
  511. Interactively run it for the current file and the `HEAD', with a
  512. prefix or when the current file cannot be determined let the user
  513. choose. When the current buffer is visiting FILENAME instruct
  514. blame to center around the line point is on.
  515. \(fn COMMIT FILENAME &optional LINENUM)" t nil)
  516. (autoload 'magit-run-gitk "magit-extras" "\
  517. Run `gitk' in the current repository.
  518. \(fn)" t nil)
  519. (autoload 'magit-run-gitk-branches "magit-extras" "\
  520. Run `gitk --branches' in the current repository.
  521. \(fn)" t nil)
  522. (autoload 'magit-run-gitk-all "magit-extras" "\
  523. Run `gitk --all' in the current repository.
  524. \(fn)" t nil)
  525. (autoload 'ido-enter-magit-status "magit-extras" "\
  526. Drop into `magit-status' from file switching.
  527. This command does not work in Emacs 26.1.
  528. See https://github.com/magit/magit/issues/3634
  529. and https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.
  530. To make this command available use something like:
  531. (add-hook \\='ido-setup-hook
  532. (lambda ()
  533. (define-key ido-completion-map
  534. (kbd \"C-x g\") \\='ido-enter-magit-status)))
  535. Starting with Emacs 25.1 the Ido keymaps are defined just once
  536. instead of every time Ido is invoked, so now you can modify it
  537. like pretty much every other keymap:
  538. (define-key ido-common-completion-map
  539. (kbd \"C-x g\") \\='ido-enter-magit-status)
  540. \(fn)" t nil)
  541. (autoload 'magit-dired-jump "magit-extras" "\
  542. Visit file at point using Dired.
  543. With a prefix argument, visit in another window. If there
  544. is no file at point, then instead visit `default-directory'.
  545. \(fn &optional OTHER-WINDOW)" t nil)
  546. (autoload 'magit-dired-log "magit-extras" "\
  547. Show log for all marked files, or the current file.
  548. \(fn &optional FOLLOW)" t nil)
  549. (autoload 'magit-do-async-shell-command "magit-extras" "\
  550. Open FILE with `dired-do-async-shell-command'.
  551. Interactively, open the file at point.
  552. \(fn FILE)" t nil)
  553. (autoload 'magit-previous-line "magit-extras" "\
  554. Like `previous-line' but with Magit-specific shift-selection.
  555. Magit's selection mechanism is based on the region but selects an
  556. area that is larger than the region. This causes `previous-line'
  557. when invoked while holding the shift key to move up one line and
  558. thereby select two lines. When invoked inside a hunk body this
  559. command does not move point on the first invocation and thereby
  560. it only selects a single line. Which inconsistency you prefer
  561. is a matter of preference.
  562. \(fn &optional ARG TRY-VSCROLL)" t nil)
  563. (function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.")
  564. (autoload 'magit-next-line "magit-extras" "\
  565. Like `next-line' but with Magit-specific shift-selection.
  566. Magit's selection mechanism is based on the region but selects
  567. an area that is larger than the region. This causes `next-line'
  568. when invoked while holding the shift key to move down one line
  569. and thereby select two lines. When invoked inside a hunk body
  570. this command does not move point on the first invocation and
  571. thereby it only selects a single line. Which inconsistency you
  572. prefer is a matter of preference.
  573. \(fn &optional ARG TRY-VSCROLL)" t nil)
  574. (function-put 'magit-next-line 'interactive-only 'forward-line)
  575. (autoload 'magit-clean "magit-extras" "\
  576. Remove untracked files from the working tree.
  577. With a prefix argument also remove ignored files,
  578. with two prefix arguments remove ignored files only.
  579. \(git clean -f -d [-x|-X])
  580. \(fn &optional ARG)" t nil)
  581. (autoload 'magit-add-change-log-entry "magit-extras" "\
  582. Find change log file and add date entry and item for current change.
  583. This differs from `add-change-log-entry' (which see) in that
  584. it acts on the current hunk in a Magit buffer instead of on
  585. a position in a file-visiting buffer.
  586. \(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)" t nil)
  587. (autoload 'magit-add-change-log-entry-other-window "magit-extras" "\
  588. Find change log file in other window and add entry and item.
  589. This differs from `add-change-log-entry-other-window' (which see)
  590. in that it acts on the current hunk in a Magit buffer instead of
  591. on a position in a file-visiting buffer.
  592. \(fn &optional WHOAMI FILE-NAME)" t nil)
  593. (autoload 'magit-edit-line-commit "magit-extras" "\
  594. Edit the commit that added the current line.
  595. With a prefix argument edit the commit that removes the line,
  596. if any. The commit is determined using `git blame' and made
  597. editable using `git rebase --interactive' if it is reachable
  598. from `HEAD', or by checking out the commit (or a branch that
  599. points at it) otherwise.
  600. \(fn &optional TYPE)" t nil)
  601. (autoload 'magit-diff-edit-hunk-commit "magit-extras" "\
  602. From a hunk, edit the respective commit and visit the file.
  603. First visit the file being modified by the hunk at the correct
  604. location using `magit-diff-visit-file'. This actually visits a
  605. blob. When point is on a diff header, not within an individual
  606. hunk, then this visits the blob the first hunk is about.
  607. Then invoke `magit-edit-line-commit', which uses an interactive
  608. rebase to make the commit editable, or if that is not possible
  609. because the commit is not reachable from `HEAD' by checking out
  610. that commit directly. This also causes the actual worktree file
  611. to be visited.
  612. Neither the blob nor the file buffer are killed when finishing
  613. the rebase. If that is undesirable, then it might be better to
  614. use `magit-rebase-edit-command' instead of this command.
  615. \(fn FILE)" t nil)
  616. (autoload 'magit-reshelve-since "magit-extras" "\
  617. Change the author and committer dates of the commits since REV.
  618. Ask the user for the first reachable commit whose dates should
  619. be changed. The read the new date for that commit. The initial
  620. minibuffer input and the previous history element offer good
  621. values. The next commit will be created one minute later and so
  622. on.
  623. This command is only intended for interactive use and should only
  624. be used on highly rearranged and unpublished history.
  625. \(fn REV)" t nil)
  626. (autoload 'magit-pop-revision-stack "magit-extras" "\
  627. Insert a representation of a revision into the current buffer.
  628. Pop a revision from the `magit-revision-stack' and insert it into
  629. the current buffer according to `magit-pop-revision-stack-format'.
  630. Revisions can be put on the stack using `magit-copy-section-value'
  631. and `magit-copy-buffer-revision'.
  632. If the stack is empty or with a prefix argument, instead read a
  633. revision in the minibuffer. By using the minibuffer history this
  634. allows selecting an item which was popped earlier or to insert an
  635. arbitrary reference or revision without first pushing it onto the
  636. stack.
  637. When reading the revision from the minibuffer, then it might not
  638. be possible to guess the correct repository. When this command
  639. is called inside a repository (e.g. while composing a commit
  640. message), then that repository is used. Otherwise (e.g. while
  641. composing an email) then the repository recorded for the top
  642. element of the stack is used (even though we insert another
  643. revision). If not called inside a repository and with an empty
  644. stack, or with two prefix arguments, then read the repository in
  645. the minibuffer too.
  646. \(fn REV TOPLEVEL)" t nil)
  647. (autoload 'magit-copy-section-value "magit-extras" "\
  648. Save the value of the current section for later use.
  649. Save the section value to the `kill-ring', and, provided that
  650. the current section is a commit, branch, or tag section, push
  651. the (referenced) revision to the `magit-revision-stack' for use
  652. with `magit-pop-revision-stack'.
  653. When the current section is a branch or a tag, and a prefix
  654. argument is used, then save the revision at its tip to the
  655. `kill-ring' instead of the reference name.
  656. When the region is active, then save that to the `kill-ring',
  657. like `kill-ring-save' would, instead of behaving as described
  658. above. If a prefix argument is used and the region is within a
  659. hunk, strip the outer diff marker column.
  660. \(fn)" t nil)
  661. (autoload 'magit-copy-buffer-revision "magit-extras" "\
  662. Save the revision of the current buffer for later use.
  663. Save the revision shown in the current buffer to the `kill-ring'
  664. and push it to the `magit-revision-stack'.
  665. This command is mainly intended for use in `magit-revision-mode'
  666. buffers, the only buffers where it is always unambiguous exactly
  667. which revision should be saved.
  668. Most other Magit buffers usually show more than one revision, in
  669. some way or another, so this command has to select one of them,
  670. and that choice might not always be the one you think would have
  671. been the best pick.
  672. In such buffers it is often more useful to save the value of
  673. the current section instead, using `magit-copy-section-value'.
  674. When the region is active, then save that to the `kill-ring',
  675. like `kill-ring-save' would, instead of behaving as described
  676. above.
  677. \(fn)" t nil)
  678. (autoload 'magit-abort-dwim "magit-extras" "\
  679. Abort current operation.
  680. Depending on the context, this will abort a merge, a rebase, a
  681. patch application, a cherry-pick, a revert, or a bisect.
  682. \(fn)" t nil)
  683. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-extras" '("magit-")))
  684. ;;;***
  685. ;;;### (autoloads nil "magit-fetch" "magit-fetch.el" (0 0 0 0))
  686. ;;; Generated autoloads from magit-fetch.el
  687. (autoload 'magit-fetch "magit-fetch" nil t)
  688. (autoload 'magit-fetch-from-pushremote "magit-fetch" nil t)
  689. (autoload 'magit-fetch-from-upstream "magit-fetch" nil t)
  690. (autoload 'magit-fetch-other "magit-fetch" "\
  691. Fetch from another repository.
  692. \(fn REMOTE ARGS)" t nil)
  693. (autoload 'magit-fetch-branch "magit-fetch" "\
  694. Fetch a BRANCH from a REMOTE.
  695. \(fn REMOTE BRANCH ARGS)" t nil)
  696. (autoload 'magit-fetch-refspec "magit-fetch" "\
  697. Fetch a REFSPEC from a REMOTE.
  698. \(fn REMOTE REFSPEC ARGS)" t nil)
  699. (autoload 'magit-fetch-all "magit-fetch" "\
  700. Fetch from all remotes.
  701. \(fn ARGS)" t nil)
  702. (autoload 'magit-fetch-all-prune "magit-fetch" "\
  703. Fetch from all remotes, and prune.
  704. Prune remote tracking branches for branches that have been
  705. removed on the respective remote.
  706. \(fn)" t nil)
  707. (autoload 'magit-fetch-all-no-prune "magit-fetch" "\
  708. Fetch from all remotes.
  709. \(fn)" t nil)
  710. (autoload 'magit-fetch-modules "magit-fetch" "\
  711. Fetch all submodules.
  712. Option `magit-fetch-modules-jobs' controls how many submodules
  713. are being fetched in parallel. Also fetch the super-repository,
  714. because `git-fetch' does not support not doing that. With a
  715. prefix argument fetch all remotes.
  716. \(fn &optional ALL)" t nil)
  717. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-fetch" '("magit-")))
  718. ;;;***
  719. ;;;### (autoloads nil "magit-files" "magit-files.el" (0 0 0 0))
  720. ;;; Generated autoloads from magit-files.el
  721. (autoload 'magit-find-file "magit-files" "\
  722. View FILE from REV.
  723. Switch to a buffer visiting blob REV:FILE, creating one if none
  724. already exists. If prior to calling this command the current
  725. buffer and/or cursor position is about the same file, then go
  726. to the line and column corresponding to that location.
  727. \(fn REV FILE)" t nil)
  728. (autoload 'magit-find-file-other-window "magit-files" "\
  729. View FILE from REV, in another window.
  730. Switch to a buffer visiting blob REV:FILE, creating one if none
  731. already exists. If prior to calling this command the current
  732. buffer and/or cursor position is about the same file, then go to
  733. the line and column corresponding to that location.
  734. \(fn REV FILE)" t nil)
  735. (autoload 'magit-find-file-other-frame "magit-files" "\
  736. View FILE from REV, in another frame.
  737. Switch to a buffer visiting blob REV:FILE, creating one if none
  738. already exists. If prior to calling this command the current
  739. buffer and/or cursor position is about the same file, then go to
  740. the line and column corresponding to that location.
  741. \(fn REV FILE)" t nil)
  742. (autoload 'magit-file-dispatch "magit" nil t)
  743. (defvar global-magit-file-mode t "\
  744. Non-nil if Global Magit-File mode is enabled.
  745. See the `global-magit-file-mode' command
  746. for a description of this minor mode.
  747. Setting this variable directly does not take effect;
  748. either customize it (see the info node `Easy Customization')
  749. or call the function `global-magit-file-mode'.")
  750. (custom-autoload 'global-magit-file-mode "magit-files" nil)
  751. (autoload 'global-magit-file-mode "magit-files" "\
  752. Toggle Magit-File mode in all buffers.
  753. With prefix ARG, enable Global Magit-File mode if ARG is positive;
  754. otherwise, disable it. If called from Lisp, enable the mode if
  755. ARG is omitted or nil.
  756. Magit-File mode is enabled in all buffers where
  757. `magit-file-mode-turn-on' would do it.
  758. See `magit-file-mode' for more information on Magit-File mode.
  759. \(fn &optional ARG)" t nil)
  760. (autoload 'magit-blob-visit-file "magit-files" "\
  761. View the file from the worktree corresponding to the current blob.
  762. When visiting a blob or the version from the index, then go to
  763. the same location in the respective file in the working tree.
  764. \(fn)" t nil)
  765. (autoload 'magit-file-checkout "magit-files" "\
  766. Checkout FILE from REV.
  767. \(fn REV FILE)" t nil)
  768. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-files" '("magit-")))
  769. ;;;***
  770. ;;;### (autoloads nil "magit-git" "magit-git.el" (0 0 0 0))
  771. ;;; Generated autoloads from magit-git.el
  772. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-git" '("magit-")))
  773. ;;;***
  774. ;;;### (autoloads nil "magit-gitignore" "magit-gitignore.el" (0 0
  775. ;;;;;; 0 0))
  776. ;;; Generated autoloads from magit-gitignore.el
  777. (autoload 'magit-gitignore "magit-gitignore" nil t)
  778. (autoload 'magit-gitignore-in-topdir "magit-gitignore" "\
  779. Add the Git ignore RULE to the top-level \".gitignore\" file.
  780. Since this file is tracked, it is shared with other clones of the
  781. repository. Also stage the file.
  782. \(fn RULE)" t nil)
  783. (autoload 'magit-gitignore-in-subdir "magit-gitignore" "\
  784. Add the Git ignore RULE to a \".gitignore\" file.
  785. Prompted the user for a directory and add the rule to the
  786. \".gitignore\" file in that directory. Since such files are
  787. tracked, they are shared with other clones of the repository.
  788. Also stage the file.
  789. \(fn RULE DIRECTORY)" t nil)
  790. (autoload 'magit-gitignore-in-gitdir "magit-gitignore" "\
  791. Add the Git ignore RULE to \"$GIT_DIR/info/exclude\".
  792. Rules in that file only affects this clone of the repository.
  793. \(fn RULE)" t nil)
  794. (autoload 'magit-gitignore-on-system "magit-gitignore" "\
  795. Add the Git ignore RULE to the file specified by `core.excludesFile'.
  796. Rules that are defined in that file affect all local repositories.
  797. \(fn RULE)" t nil)
  798. (autoload 'magit-skip-worktree "magit-gitignore" "\
  799. Call \"git update-index --skip-worktree -- FILE\".
  800. \(fn FILE)" t nil)
  801. (autoload 'magit-no-skip-worktree "magit-gitignore" "\
  802. Call \"git update-index --no-skip-worktree -- FILE\".
  803. \(fn FILE)" t nil)
  804. (autoload 'magit-assume-unchanged "magit-gitignore" "\
  805. Call \"git update-index --assume-unchanged -- FILE\".
  806. \(fn FILE)" t nil)
  807. (autoload 'magit-no-assume-unchanged "magit-gitignore" "\
  808. Call \"git update-index --no-assume-unchanged -- FILE\".
  809. \(fn FILE)" t nil)
  810. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-gitignore" '("magit-")))
  811. ;;;***
  812. ;;;### (autoloads nil "magit-imenu" "magit-imenu.el" (0 0 0 0))
  813. ;;; Generated autoloads from magit-imenu.el
  814. (autoload 'magit-imenu--log-prev-index-position-function "magit-imenu" "\
  815. Move point to previous line in current buffer.
  816. This function is used as a value for
  817. `imenu-prev-index-position-function'.
  818. \(fn)" nil nil)
  819. (autoload 'magit-imenu--log-extract-index-name-function "magit-imenu" "\
  820. Return imenu name for line at point.
  821. This function is used as a value for
  822. `imenu-extract-index-name-function'. Point should be at the
  823. beginning of the line.
  824. \(fn)" nil nil)
  825. (autoload 'magit-imenu--diff-prev-index-position-function "magit-imenu" "\
  826. Move point to previous file line in current buffer.
  827. This function is used as a value for
  828. `imenu-prev-index-position-function'.
  829. \(fn)" nil nil)
  830. (autoload 'magit-imenu--diff-extract-index-name-function "magit-imenu" "\
  831. Return imenu name for line at point.
  832. This function is used as a value for
  833. `imenu-extract-index-name-function'. Point should be at the
  834. beginning of the line.
  835. \(fn)" nil nil)
  836. (autoload 'magit-imenu--status-create-index-function "magit-imenu" "\
  837. Return an alist of all imenu entries in current buffer.
  838. This function is used as a value for
  839. `imenu-create-index-function'.
  840. \(fn)" nil nil)
  841. (autoload 'magit-imenu--refs-create-index-function "magit-imenu" "\
  842. Return an alist of all imenu entries in current buffer.
  843. This function is used as a value for
  844. `imenu-create-index-function'.
  845. \(fn)" nil nil)
  846. (autoload 'magit-imenu--cherry-create-index-function "magit-imenu" "\
  847. Return an alist of all imenu entries in current buffer.
  848. This function is used as a value for
  849. `imenu-create-index-function'.
  850. \(fn)" nil nil)
  851. (autoload 'magit-imenu--submodule-prev-index-position-function "magit-imenu" "\
  852. Move point to previous line in magit-submodule-list buffer.
  853. This function is used as a value for
  854. `imenu-prev-index-position-function'.
  855. \(fn)" nil nil)
  856. (autoload 'magit-imenu--submodule-extract-index-name-function "magit-imenu" "\
  857. Return imenu name for line at point.
  858. This function is used as a value for
  859. `imenu-extract-index-name-function'. Point should be at the
  860. beginning of the line.
  861. \(fn)" nil nil)
  862. (autoload 'magit-imenu--repolist-prev-index-position-function "magit-imenu" "\
  863. Move point to previous line in magit-repolist buffer.
  864. This function is used as a value for
  865. `imenu-prev-index-position-function'.
  866. \(fn)" nil nil)
  867. (autoload 'magit-imenu--repolist-extract-index-name-function "magit-imenu" "\
  868. Return imenu name for line at point.
  869. This function is used as a value for
  870. `imenu-extract-index-name-function'. Point should be at the
  871. beginning of the line.
  872. \(fn)" nil nil)
  873. (autoload 'magit-imenu--process-prev-index-position-function "magit-imenu" "\
  874. Move point to previous process in magit-process buffer.
  875. This function is used as a value for
  876. `imenu-prev-index-position-function'.
  877. \(fn)" nil nil)
  878. (autoload 'magit-imenu--process-extract-index-name-function "magit-imenu" "\
  879. Return imenu name for line at point.
  880. This function is used as a value for
  881. `imenu-extract-index-name-function'. Point should be at the
  882. beginning of the line.
  883. \(fn)" nil nil)
  884. (autoload 'magit-imenu--rebase-prev-index-position-function "magit-imenu" "\
  885. Move point to previous commit in git-rebase buffer.
  886. This function is used as a value for
  887. `imenu-prev-index-position-function'.
  888. \(fn)" nil nil)
  889. (autoload 'magit-imenu--rebase-extract-index-name-function "magit-imenu" "\
  890. Return imenu name for line at point.
  891. This function is used as a value for
  892. `imenu-extract-index-name-function'. Point should be at the
  893. beginning of the line.
  894. \(fn)" nil nil)
  895. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-imenu" '("magit-imenu--index-function")))
  896. ;;;***
  897. ;;;### (autoloads nil "magit-log" "magit-log.el" (0 0 0 0))
  898. ;;; Generated autoloads from magit-log.el
  899. (autoload 'magit-log "magit-log" nil t)
  900. (autoload 'magit-log-refresh "magit-log" nil t)
  901. (autoload 'magit-log-current "magit-log" "\
  902. Show log for the current branch.
  903. When `HEAD' is detached or with a prefix argument show log for
  904. one or more revs read from the minibuffer.
  905. \(fn REVS &optional ARGS FILES)" t nil)
  906. (autoload 'magit-log-other "magit-log" "\
  907. Show log for one or more revs read from the minibuffer.
  908. The user can input any revision or revisions separated by a
  909. space, or even ranges, but only branches and tags, and a
  910. representation of the commit at point, are available as
  911. completion candidates.
  912. \(fn REVS &optional ARGS FILES)" t nil)
  913. (autoload 'magit-log-head "magit-log" "\
  914. Show log for `HEAD'.
  915. \(fn &optional ARGS FILES)" t nil)
  916. (autoload 'magit-log-branches "magit-log" "\
  917. Show log for all local branches and `HEAD'.
  918. \(fn &optional ARGS FILES)" t nil)
  919. (autoload 'magit-log-all-branches "magit-log" "\
  920. Show log for all local and remote branches and `HEAD'.
  921. \(fn &optional ARGS FILES)" t nil)
  922. (autoload 'magit-log-all "magit-log" "\
  923. Show log for all references and `HEAD'.
  924. \(fn &optional ARGS FILES)" t nil)
  925. (autoload 'magit-log-buffer-file "magit-log" "\
  926. Show log for the blob or file visited in the current buffer.
  927. With a prefix argument or when `--follow' is an active log
  928. argument, then follow renames. When the region is active,
  929. restrict the log to the lines that the region touches.
  930. \(fn &optional FOLLOW BEG END)" t nil)
  931. (autoload 'magit-log-trace-definition "magit-log" "\
  932. Show log for the definition at point.
  933. \(fn FILE FN REV)" t nil)
  934. (autoload 'magit-log-merged "magit-log" "\
  935. Show log for the merge of COMMIT into BRANCH.
  936. More precisely, find merge commit M that brought COMMIT into
  937. BRANCH, and show the log of the range \"M^1..M\". If COMMIT is
  938. directly on BRANCH, then show approximately twenty surrounding
  939. commits instead.
  940. This command requires git-when-merged, which is available from
  941. https://github.com/mhagger/git-when-merged.
  942. \(fn COMMIT BRANCH &optional ARGS FILES)" t nil)
  943. (autoload 'magit-log-move-to-parent "magit-log" "\
  944. Move to the Nth parent of the current commit.
  945. \(fn &optional N)" t nil)
  946. (autoload 'magit-cherry "magit-log" "\
  947. Show commits in a branch that are not merged in the upstream branch.
  948. \(fn HEAD UPSTREAM)" t nil)
  949. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-log" '("magit")))
  950. ;;;***
  951. ;;;### (autoloads nil "magit-margin" "magit-margin.el" (0 0 0 0))
  952. ;;; Generated autoloads from magit-margin.el
  953. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-margin" '("magit-")))
  954. ;;;***
  955. ;;;### (autoloads nil "magit-merge" "magit-merge.el" (0 0 0 0))
  956. ;;; Generated autoloads from magit-merge.el
  957. (autoload 'magit-merge "magit" nil t)
  958. (autoload 'magit-merge-plain "magit-merge" "\
  959. Merge commit REV into the current branch; using default message.
  960. Unless there are conflicts or a prefix argument is used create a
  961. merge commit using a generic commit message and without letting
  962. the user inspect the result. With a prefix argument pretend the
  963. merge failed to give the user the opportunity to inspect the
  964. merge.
  965. \(git merge --no-edit|--no-commit [ARGS] REV)
  966. \(fn REV &optional ARGS NOCOMMIT)" t nil)
  967. (autoload 'magit-merge-editmsg "magit-merge" "\
  968. Merge commit REV into the current branch; and edit message.
  969. Perform the merge and prepare a commit message but let the user
  970. edit it.
  971. \(git merge --edit --no-ff [ARGS] REV)
  972. \(fn REV &optional ARGS)" t nil)
  973. (autoload 'magit-merge-nocommit "magit-merge" "\
  974. Merge commit REV into the current branch; pretending it failed.
  975. Pretend the merge failed to give the user the opportunity to
  976. inspect the merge and change the commit message.
  977. \(git merge --no-commit --no-ff [ARGS] REV)
  978. \(fn REV &optional ARGS)" t nil)
  979. (autoload 'magit-merge-into "magit-merge" "\
  980. Merge the current branch into BRANCH and remove the former.
  981. Before merging, force push the source branch to its push-remote,
  982. provided the respective remote branch already exists, ensuring
  983. that the respective pull-request (if any) won't get stuck on some
  984. obsolete version of the commits that are being merged. Finally
  985. if `forge-branch-pullreq' was used to create the merged branch,
  986. branch, then also remove the respective remote branch.
  987. \(fn BRANCH &optional ARGS)" t nil)
  988. (autoload 'magit-merge-absorb "magit-merge" "\
  989. Merge BRANCH into the current branch and remove the former.
  990. Before merging, force push the source branch to its push-remote,
  991. provided the respective remote branch already exists, ensuring
  992. that the respective pull-request (if any) won't get stuck on some
  993. obsolete version of the commits that are being merged. Finally
  994. if `forge-branch-pullreq' was used to create the merged branch,
  995. then also remove the respective remote branch.
  996. \(fn BRANCH &optional ARGS)" t nil)
  997. (autoload 'magit-merge-squash "magit-merge" "\
  998. Squash commit REV into the current branch; don't create a commit.
  999. \(git merge --squash REV)
  1000. \(fn REV)" t nil)
  1001. (autoload 'magit-merge-preview "magit-merge" "\
  1002. Preview result of merging REV into the current branch.
  1003. \(fn REV)" t nil)
  1004. (autoload 'magit-merge-abort "magit-merge" "\
  1005. Abort the current merge operation.
  1006. \(git merge --abort)
  1007. \(fn)" t nil)
  1008. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-merge" '("magit-")))
  1009. ;;;***
  1010. ;;;### (autoloads nil "magit-mode" "magit-mode.el" (0 0 0 0))
  1011. ;;; Generated autoloads from magit-mode.el
  1012. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-mode" '("magit-" "disable-magit-save-buffers" "inhibit-magit-refresh")))
  1013. ;;;***
  1014. ;;;### (autoloads nil "magit-notes" "magit-notes.el" (0 0 0 0))
  1015. ;;; Generated autoloads from magit-notes.el
  1016. (autoload 'magit-notes "magit" nil t)
  1017. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-notes" '("magit-")))
  1018. ;;;***
  1019. ;;;### (autoloads nil "magit-obsolete" "magit-obsolete.el" (0 0 0
  1020. ;;;;;; 0))
  1021. ;;; Generated autoloads from magit-obsolete.el
  1022. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-obsolete" '("magit--magit-popup-warning")))
  1023. ;;;***
  1024. ;;;### (autoloads nil "magit-patch" "magit-patch.el" (0 0 0 0))
  1025. ;;; Generated autoloads from magit-patch.el
  1026. (autoload 'magit-patch "magit-patch" nil t)
  1027. (autoload 'magit-patch-create "magit-patch" nil t)
  1028. (autoload 'magit-patch-apply "magit-patch" nil t)
  1029. (autoload 'magit-patch-save "magit-patch" "\
  1030. Write current diff into patch FILE.
  1031. What arguments are used to create the patch depends on the value
  1032. of `magit-patch-save-arguments' and whether a prefix argument is
  1033. used.
  1034. If the value is the symbol `buffer', then use the same arguments
  1035. as the buffer. With a prefix argument use no arguments.
  1036. If the value is a list beginning with the symbol `exclude', then
  1037. use the same arguments as the buffer except for those matched by
  1038. entries in the cdr of the list. The comparison is done using
  1039. `string-prefix-p'. With a prefix argument use the same arguments
  1040. as the buffer.
  1041. If the value is a list of strings (including the empty list),
  1042. then use those arguments. With a prefix argument use the same
  1043. arguments as the buffer.
  1044. Of course the arguments that are required to actually show the
  1045. same differences as those shown in the buffer are always used.
  1046. \(fn FILE &optional ARG)" t nil)
  1047. (autoload 'magit-request-pull "magit-patch" "\
  1048. Request upstream to pull from you public repository.
  1049. URL is the url of your publically accessible repository.
  1050. START is a commit that already is in the upstream repository.
  1051. END is the last commit, usually a branch name, which upstream
  1052. is asked to pull. START has to be reachable from that commit.
  1053. \(fn URL START END)" t nil)
  1054. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-patch" '("magit-")))
  1055. ;;;***
  1056. ;;;### (autoloads nil "magit-process" "magit-process.el" (0 0 0 0))
  1057. ;;; Generated autoloads from magit-process.el
  1058. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-process" '("magit-" "tramp-sh-handle-")))
  1059. ;;;***
  1060. ;;;### (autoloads nil "magit-pull" "magit-pull.el" (0 0 0 0))
  1061. ;;; Generated autoloads from magit-pull.el
  1062. (autoload 'magit-pull "magit-pull" nil t)
  1063. (autoload 'magit-pull-from-pushremote "magit-pull" nil t)
  1064. (autoload 'magit-pull-from-upstream "magit-pull" nil t)
  1065. (autoload 'magit-pull-branch "magit-pull" "\
  1066. Pull from a branch read in the minibuffer.
  1067. \(fn SOURCE ARGS)" t nil)
  1068. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-pull" '("magit-pull")))
  1069. ;;;***
  1070. ;;;### (autoloads nil "magit-push" "magit-push.el" (0 0 0 0))
  1071. ;;; Generated autoloads from magit-push.el
  1072. (autoload 'magit-push "magit-push" nil t)
  1073. (autoload 'magit-push-current-to-pushremote "magit-push" nil t)
  1074. (autoload 'magit-push-current-to-upstream "magit-push" nil t)
  1075. (autoload 'magit-push-current "magit-push" "\
  1076. Push the current branch to a branch read in the minibuffer.
  1077. \(fn TARGET ARGS)" t nil)
  1078. (autoload 'magit-push-other "magit-push" "\
  1079. Push an arbitrary branch or commit somewhere.
  1080. Both the source and the target are read in the minibuffer.
  1081. \(fn SOURCE TARGET ARGS)" t nil)
  1082. (autoload 'magit-push-refspecs "magit-push" "\
  1083. Push one or multiple REFSPECS to a REMOTE.
  1084. Both the REMOTE and the REFSPECS are read in the minibuffer. To
  1085. use multiple REFSPECS, separate them with commas. Completion is
  1086. only available for the part before the colon, or when no colon
  1087. is used.
  1088. \(fn REMOTE REFSPECS ARGS)" t nil)
  1089. (autoload 'magit-push-matching "magit-push" "\
  1090. Push all matching branches to another repository.
  1091. If multiple remotes exist, then read one from the user.
  1092. If just one exists, use that without requiring confirmation.
  1093. \(fn REMOTE &optional ARGS)" t nil)
  1094. (autoload 'magit-push-tags "magit-push" "\
  1095. Push all tags to another repository.
  1096. If only one remote exists, then push to that. Otherwise prompt
  1097. for a remote, offering the remote configured for the current
  1098. branch as default.
  1099. \(fn REMOTE &optional ARGS)" t nil)
  1100. (autoload 'magit-push-tag "magit-push" "\
  1101. Push a tag to another repository.
  1102. \(fn TAG REMOTE &optional ARGS)" t nil)
  1103. (autoload 'magit-push-implicitly "magit-push" "\
  1104. Push somewhere without using an explicit refspec.
  1105. This command simply runs \"git push -v [ARGS]\". ARGS are the
  1106. arguments specified in the popup buffer. No explicit refspec
  1107. arguments are used. Instead the behavior depends on at least
  1108. these Git variables: `push.default', `remote.pushDefault',
  1109. `branch.<branch>.pushRemote', `branch.<branch>.remote',
  1110. `branch.<branch>.merge', and `remote.<remote>.push'.
  1111. The function `magit-push-implicitly--desc' attempts to predict
  1112. what this command will do. The value it returns is displayed in
  1113. the popup buffer.
  1114. \(fn ARGS)" t nil)
  1115. (autoload 'magit-push-to-remote "magit-push" "\
  1116. Push to REMOTE without using an explicit refspec.
  1117. The REMOTE is read in the minibuffer.
  1118. This command simply runs \"git push -v [ARGS] REMOTE\". ARGS
  1119. are the arguments specified in the popup buffer. No refspec
  1120. arguments are used. Instead the behavior depends on at least
  1121. these Git variables: `push.default', `remote.pushDefault',
  1122. `branch.<branch>.pushRemote', `branch.<branch>.remote',
  1123. `branch.<branch>.merge', and `remote.<remote>.push'.
  1124. \(fn REMOTE ARGS)" t nil)
  1125. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-push" '("magit-")))
  1126. ;;;***
  1127. ;;;### (autoloads nil "magit-reflog" "magit-reflog.el" (0 0 0 0))
  1128. ;;; Generated autoloads from magit-reflog.el
  1129. (autoload 'magit-reflog-current "magit-reflog" "\
  1130. Display the reflog of the current branch.
  1131. If `HEAD' is detached, then show the reflog for that instead.
  1132. \(fn)" t nil)
  1133. (autoload 'magit-reflog-other "magit-reflog" "\
  1134. Display the reflog of a branch or another ref.
  1135. \(fn REF)" t nil)
  1136. (autoload 'magit-reflog-head "magit-reflog" "\
  1137. Display the `HEAD' reflog.
  1138. \(fn)" t nil)
  1139. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reflog" '("magit-reflog-")))
  1140. ;;;***
  1141. ;;;### (autoloads nil "magit-refs" "magit-refs.el" (0 0 0 0))
  1142. ;;; Generated autoloads from magit-refs.el
  1143. (autoload 'magit-show-refs "magit-refs" nil t)
  1144. (autoload 'magit-show-refs-head "magit-refs" "\
  1145. List and compare references in a dedicated buffer.
  1146. Compared with `HEAD'.
  1147. \(fn &optional ARGS)" t nil)
  1148. (autoload 'magit-show-refs-current "magit-refs" "\
  1149. List and compare references in a dedicated buffer.
  1150. Compare with the current branch or `HEAD' if it is detached.
  1151. \(fn &optional ARGS)" t nil)
  1152. (autoload 'magit-show-refs-other "magit-refs" "\
  1153. List and compare references in a dedicated buffer.
  1154. Compared with a branch read from the user.
  1155. \(fn &optional REF ARGS)" t nil)
  1156. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-refs" '("magit-")))
  1157. ;;;***
  1158. ;;;### (autoloads nil "magit-remote" "magit-remote.el" (0 0 0 0))
  1159. ;;; Generated autoloads from magit-remote.el
  1160. (autoload 'magit-remote "magit-remote" nil t)
  1161. (autoload 'magit-remote-add "magit-remote" "\
  1162. Add a remote named REMOTE and fetch it.
  1163. \(fn REMOTE URL &optional ARGS)" t nil)
  1164. (autoload 'magit-remote-rename "magit-remote" "\
  1165. Rename the remote named OLD to NEW.
  1166. \(fn OLD NEW)" t nil)
  1167. (autoload 'magit-remote-remove "magit-remote" "\
  1168. Delete the remote named REMOTE.
  1169. \(fn REMOTE)" t nil)
  1170. (autoload 'magit-remote-prune "magit-remote" "\
  1171. Remove stale remote-tracking branches for REMOTE.
  1172. \(fn REMOTE)" t nil)
  1173. (autoload 'magit-remote-prune-refspecs "magit-remote" "\
  1174. Remove stale refspecs for REMOTE.
  1175. A refspec is stale if there no longer exists at least one branch
  1176. on the remote that would be fetched due to that refspec. A stale
  1177. refspec is problematic because its existence causes Git to refuse
  1178. to fetch according to the remaining non-stale refspecs.
  1179. If only stale refspecs remain, then offer to either delete the
  1180. remote or to replace the stale refspecs with the default refspec.
  1181. Also remove the remote-tracking branches that were created due to
  1182. the now stale refspecs. Other stale branches are not removed.
  1183. \(fn REMOTE)" t nil)
  1184. (autoload 'magit-remote-set-head "magit-remote" "\
  1185. Set the local representation of REMOTE's default branch.
  1186. Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
  1187. accordingly. With a prefix argument query for the branch to be
  1188. used, which allows you to select an incorrect value if you fancy
  1189. doing that.
  1190. \(fn REMOTE &optional BRANCH)" t nil)
  1191. (autoload 'magit-remote-unset-head "magit-remote" "\
  1192. Unset the local representation of REMOTE's default branch.
  1193. Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\".
  1194. \(fn REMOTE)" t nil)
  1195. (autoload 'magit-remote-configure "magit-remote" nil t)
  1196. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-remote" '("magit-")))
  1197. ;;;***
  1198. ;;;### (autoloads nil "magit-repos" "magit-repos.el" (0 0 0 0))
  1199. ;;; Generated autoloads from magit-repos.el
  1200. (autoload 'magit-list-repositories "magit-repos" "\
  1201. Display a list of repositories.
  1202. Use the options `magit-repository-directories' to control which
  1203. repositories are displayed.
  1204. \(fn)" t nil)
  1205. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-repos" '("magit-")))
  1206. ;;;***
  1207. ;;;### (autoloads nil "magit-reset" "magit-reset.el" (0 0 0 0))
  1208. ;;; Generated autoloads from magit-reset.el
  1209. (autoload 'magit-reset "magit" nil t)
  1210. (autoload 'magit-reset-mixed "magit-reset" "\
  1211. Reset the `HEAD' and index to COMMIT, but not the working tree.
  1212. \(git reset --mixed COMMIT)
  1213. \(fn COMMIT)" t nil)
  1214. (autoload 'magit-reset-soft "magit-reset" "\
  1215. Reset the `HEAD' to COMMIT, but not the index and working tree.
  1216. \(git reset --soft REVISION)
  1217. \(fn COMMIT)" t nil)
  1218. (autoload 'magit-reset-hard "magit-reset" "\
  1219. Reset the `HEAD', index, and working tree to COMMIT.
  1220. \(git reset --hard REVISION)
  1221. \(fn COMMIT)" t nil)
  1222. (autoload 'magit-reset-index "magit-reset" "\
  1223. Reset the index to COMMIT.
  1224. Keep the `HEAD' and working tree as-is, so if COMMIT refers to the
  1225. head this effectively unstages all changes.
  1226. \(git reset COMMIT .)
  1227. \(fn COMMIT)" t nil)
  1228. (autoload 'magit-reset-worktree "magit-reset" "\
  1229. Reset the worktree to COMMIT.
  1230. Keep the `HEAD' and index as-is.
  1231. \(fn COMMIT)" t nil)
  1232. (autoload 'magit-reset-quickly "magit-reset" "\
  1233. Reset the `HEAD' and index to COMMIT, and possibly the working tree.
  1234. With a prefix argument reset the working tree otherwise don't.
  1235. \(git reset --mixed|--hard COMMIT)
  1236. \(fn COMMIT &optional HARD)" t nil)
  1237. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reset" '("magit-reset")))
  1238. ;;;***
  1239. ;;;### (autoloads nil "magit-section" "magit-section.el" (0 0 0 0))
  1240. ;;; Generated autoloads from magit-section.el
  1241. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-section" '("magit-")))
  1242. ;;;***
  1243. ;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (0 0 0
  1244. ;;;;;; 0))
  1245. ;;; Generated autoloads from magit-sequence.el
  1246. (autoload 'magit-sequencer-continue "magit-sequence" "\
  1247. Resume the current cherry-pick or revert sequence.
  1248. \(fn)" t nil)
  1249. (autoload 'magit-sequencer-skip "magit-sequence" "\
  1250. Skip the stopped at commit during a cherry-pick or revert sequence.
  1251. \(fn)" t nil)
  1252. (autoload 'magit-sequencer-abort "magit-sequence" "\
  1253. Abort the current cherry-pick or revert sequence.
  1254. This discards all changes made since the sequence started.
  1255. \(fn)" t nil)
  1256. (autoload 'magit-cherry-pick "magit-sequence" nil t)
  1257. (autoload 'magit-cherry-copy "magit-sequence" "\
  1258. Copy COMMITS from another branch onto the current branch.
  1259. Prompt for a commit, defaulting to the commit at point. If
  1260. the region selects multiple commits, then pick all of them,
  1261. without prompting.
  1262. \(fn COMMITS &optional ARGS)" t nil)
  1263. (autoload 'magit-cherry-apply "magit-sequence" "\
  1264. Apply the changes in COMMITS but do not commit them.
  1265. Prompt for a commit, defaulting to the commit at point. If
  1266. the region selects multiple commits, then apply all of them,
  1267. without prompting.
  1268. \(fn COMMITS &optional ARGS)" t nil)
  1269. (autoload 'magit-cherry-harvest "magit-sequence" "\
  1270. Move COMMITS from another BRANCH onto the current branch.
  1271. Remove the COMMITS from BRANCH and stay on the current branch.
  1272. If a conflict occurs, then you have to fix that and finish the
  1273. process manually.
  1274. \(fn COMMITS BRANCH &optional ARGS)" t nil)
  1275. (autoload 'magit-cherry-donate "magit-sequence" "\
  1276. Move COMMITS from the current branch onto another existing BRANCH.
  1277. Remove COMMITS from the current branch and stay on that branch.
  1278. If a conflict occurs, then you have to fix that and finish the
  1279. process manually.
  1280. \(fn COMMITS BRANCH &optional ARGS)" t nil)
  1281. (autoload 'magit-cherry-spinout "magit-sequence" "\
  1282. Move COMMITS from the current branch onto a new BRANCH.
  1283. Remove COMMITS from the current branch and stay on that branch.
  1284. If a conflict occurs, then you have to fix that and finish the
  1285. process manually.
  1286. \(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
  1287. (autoload 'magit-cherry-spinoff "magit-sequence" "\
  1288. Move COMMITS from the current branch onto a new BRANCH.
  1289. Remove COMMITS from the current branch and checkout BRANCH.
  1290. If a conflict occurs, then you have to fix that and finish
  1291. the process manually.
  1292. \(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
  1293. (autoload 'magit-revert "magit-sequence" nil t)
  1294. (autoload 'magit-revert-and-commit "magit-sequence" "\
  1295. Revert COMMIT by creating a new commit.
  1296. Prompt for a commit, defaulting to the commit at point. If
  1297. the region selects multiple commits, then revert all of them,
  1298. without prompting.
  1299. \(fn COMMIT &optional ARGS)" t nil)
  1300. (autoload 'magit-revert-no-commit "magit-sequence" "\
  1301. Revert COMMIT by applying it in reverse to the worktree.
  1302. Prompt for a commit, defaulting to the commit at point. If
  1303. the region selects multiple commits, then revert all of them,
  1304. without prompting.
  1305. \(fn COMMIT &optional ARGS)" t nil)
  1306. (autoload 'magit-am "magit-sequence" nil t)
  1307. (autoload 'magit-am-apply-patches "magit-sequence" "\
  1308. Apply the patches FILES.
  1309. \(fn &optional FILES ARGS)" t nil)
  1310. (autoload 'magit-am-apply-maildir "magit-sequence" "\
  1311. Apply the patches from MAILDIR.
  1312. \(fn &optional MAILDIR ARGS)" t nil)
  1313. (autoload 'magit-am-continue "magit-sequence" "\
  1314. Resume the current patch applying sequence.
  1315. \(fn)" t nil)
  1316. (autoload 'magit-am-skip "magit-sequence" "\
  1317. Skip the stopped at patch during a patch applying sequence.
  1318. \(fn)" t nil)
  1319. (autoload 'magit-am-abort "magit-sequence" "\
  1320. Abort the current patch applying sequence.
  1321. This discards all changes made since the sequence started.
  1322. \(fn)" t nil)
  1323. (autoload 'magit-rebase "magit-sequence" nil t)
  1324. (autoload 'magit-rebase-onto-pushremote "magit-sequence" nil t)
  1325. (autoload 'magit-rebase-onto-upstream "magit-sequence" nil t)
  1326. (autoload 'magit-rebase-branch "magit-sequence" "\
  1327. Rebase the current branch onto a branch read in the minibuffer.
  1328. All commits that are reachable from `HEAD' but not from the
  1329. selected branch TARGET are being rebased.
  1330. \(fn TARGET ARGS)" t nil)
  1331. (autoload 'magit-rebase-subset "magit-sequence" "\
  1332. Rebase a subset of the current branch's history onto a new base.
  1333. Rebase commits from START to `HEAD' onto NEWBASE.
  1334. START has to be selected from a list of recent commits.
  1335. \(fn NEWBASE START ARGS)" t nil)
  1336. (autoload 'magit-rebase-interactive "magit-sequence" "\
  1337. Start an interactive rebase sequence.
  1338. \(fn COMMIT ARGS)" t nil)
  1339. (autoload 'magit-rebase-autosquash "magit-sequence" "\
  1340. Combine squash and fixup commits with their intended targets.
  1341. \(fn ARGS)" t nil)
  1342. (autoload 'magit-rebase-edit-commit "magit-sequence" "\
  1343. Edit a single older commit using rebase.
  1344. \(fn COMMIT ARGS)" t nil)
  1345. (autoload 'magit-rebase-reword-commit "magit-sequence" "\
  1346. Reword a single older commit using rebase.
  1347. \(fn COMMIT ARGS)" t nil)
  1348. (autoload 'magit-rebase-remove-commit "magit-sequence" "\
  1349. Remove a single older commit using rebase.
  1350. \(fn COMMIT ARGS)" t nil)
  1351. (autoload 'magit-rebase-continue "magit-sequence" "\
  1352. Restart the current rebasing operation.
  1353. In some cases this pops up a commit message buffer for you do
  1354. edit. With a prefix argument the old message is reused as-is.
  1355. \(fn &optional NOEDIT)" t nil)
  1356. (autoload 'magit-rebase-skip "magit-sequence" "\
  1357. Skip the current commit and restart the current rebase operation.
  1358. \(fn)" t nil)
  1359. (autoload 'magit-rebase-edit "magit-sequence" "\
  1360. Edit the todo list of the current rebase operation.
  1361. \(fn)" t nil)
  1362. (autoload 'magit-rebase-abort "magit-sequence" "\
  1363. Abort the current rebase operation, restoring the original branch.
  1364. \(fn)" t nil)
  1365. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-sequence" '("magit-")))
  1366. ;;;***
  1367. ;;;### (autoloads nil "magit-stash" "magit-stash.el" (0 0 0 0))
  1368. ;;; Generated autoloads from magit-stash.el
  1369. (autoload 'magit-stash "magit-stash" nil t)
  1370. (autoload 'magit-stash-both "magit-stash" "\
  1371. Create a stash of the index and working tree.
  1372. Untracked files are included according to infix arguments.
  1373. One prefix argument is equivalent to `--include-untracked'
  1374. while two prefix arguments are equivalent to `--all'.
  1375. \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
  1376. (autoload 'magit-stash-index "magit-stash" "\
  1377. Create a stash of the index only.
  1378. Unstaged and untracked changes are not stashed. The stashed
  1379. changes are applied in reverse to both the index and the
  1380. worktree. This command can fail when the worktree is not clean.
  1381. Applying the resulting stash has the inverse effect.
  1382. \(fn MESSAGE)" t nil)
  1383. (autoload 'magit-stash-worktree "magit-stash" "\
  1384. Create a stash of unstaged changes in the working tree.
  1385. Untracked files are included according to infix arguments.
  1386. One prefix argument is equivalent to `--include-untracked'
  1387. while two prefix arguments are equivalent to `--all'.
  1388. \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
  1389. (autoload 'magit-stash-keep-index "magit-stash" "\
  1390. Create a stash of the index and working tree, keeping index intact.
  1391. Untracked files are included according to infix arguments.
  1392. One prefix argument is equivalent to `--include-untracked'
  1393. while two prefix arguments are equivalent to `--all'.
  1394. \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
  1395. (autoload 'magit-snapshot-both "magit-stash" "\
  1396. Create a snapshot of the index and working tree.
  1397. Untracked files are included according to infix arguments.
  1398. One prefix argument is equivalent to `--include-untracked'
  1399. while two prefix arguments are equivalent to `--all'.
  1400. \(fn &optional INCLUDE-UNTRACKED)" t nil)
  1401. (autoload 'magit-snapshot-index "magit-stash" "\
  1402. Create a snapshot of the index only.
  1403. Unstaged and untracked changes are not stashed.
  1404. \(fn)" t nil)
  1405. (autoload 'magit-snapshot-worktree "magit-stash" "\
  1406. Create a snapshot of unstaged changes in the working tree.
  1407. Untracked files are included according to infix arguments.
  1408. One prefix argument is equivalent to `--include-untracked'
  1409. while two prefix arguments are equivalent to `--all'.
  1410. \(fn &optional INCLUDE-UNTRACKED)" t nil)
  1411. (autoload 'magit-stash-apply "magit-stash" "\
  1412. Apply a stash to the working tree.
  1413. Try to preserve the stash index. If that fails because there
  1414. are staged changes, apply without preserving the stash index.
  1415. \(fn STASH)" t nil)
  1416. (autoload 'magit-stash-drop "magit-stash" "\
  1417. Remove a stash from the stash list.
  1418. When the region is active offer to drop all contained stashes.
  1419. \(fn STASH)" t nil)
  1420. (autoload 'magit-stash-clear "magit-stash" "\
  1421. Remove all stashes saved in REF's reflog by deleting REF.
  1422. \(fn REF)" t nil)
  1423. (autoload 'magit-stash-branch "magit-stash" "\
  1424. Create and checkout a new BRANCH from STASH.
  1425. \(fn STASH BRANCH)" t nil)
  1426. (autoload 'magit-stash-branch-here "magit-stash" "\
  1427. Create and checkout a new BRANCH and apply STASH.
  1428. The branch is created using `magit-branch', using the current
  1429. branch or `HEAD' as the string-point.
  1430. \(fn STASH BRANCH)" t nil)
  1431. (autoload 'magit-stash-format-patch "magit-stash" "\
  1432. Create a patch from STASH
  1433. \(fn STASH)" t nil)
  1434. (autoload 'magit-stash-list "magit-stash" "\
  1435. List all stashes in a buffer.
  1436. \(fn)" t nil)
  1437. (autoload 'magit-stash-show "magit-stash" "\
  1438. Show all diffs of a stash in a buffer.
  1439. \(fn STASH &optional ARGS FILES)" t nil)
  1440. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-stash" '("magit-")))
  1441. ;;;***
  1442. ;;;### (autoloads nil "magit-status" "magit-status.el" (0 0 0 0))
  1443. ;;; Generated autoloads from magit-status.el
  1444. (autoload 'magit-init "magit-status" "\
  1445. Initialize a Git repository, then show its status.
  1446. If the directory is below an existing repository, then the user
  1447. has to confirm that a new one should be created inside. If the
  1448. directory is the root of the existing repository, then the user
  1449. has to confirm that it should be reinitialized.
  1450. Non-interactively DIRECTORY is (re-)initialized unconditionally.
  1451. \(fn DIRECTORY)" t nil)
  1452. (autoload 'magit-status "magit-status" "\
  1453. Show the status of the current Git repository in a buffer.
  1454. If the current directory isn't located within a Git repository,
  1455. then prompt for an existing repository or an arbitrary directory,
  1456. depending on option `magit-repository-directories', and show the
  1457. status of the selected repository instead.
  1458. * If that option specifies any existing repositories, then offer
  1459. those for completion and show the status buffer for the
  1460. selected one.
  1461. * Otherwise read an arbitrary directory using regular file-name
  1462. completion. If the selected directory is the top-level of an
  1463. existing working tree, then show the status buffer for that.
  1464. * Otherwise offer to initialize the selected directory as a new
  1465. repository. After creating the repository show its status
  1466. buffer.
  1467. These fallback behaviors can also be forced using one or more
  1468. prefix arguments:
  1469. * With two prefix arguments (or more precisely a numeric prefix
  1470. value of 16 or greater) read an arbitrary directory and act on
  1471. it as described above. The same could be accomplished using
  1472. the command `magit-init'.
  1473. * With a single prefix argument read an existing repository, or
  1474. if none can be found based on `magit-repository-directories',
  1475. then fall back to the same behavior as with two prefix
  1476. arguments.
  1477. \(fn &optional DIRECTORY CACHE)" t nil)
  1478. (autoload 'magit-status-setup-buffer "magit-status" "\
  1479. \(fn &optional DIRECTORY)" nil nil)
  1480. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-status" '("magit")))
  1481. ;;;***
  1482. ;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (0 0
  1483. ;;;;;; 0 0))
  1484. ;;; Generated autoloads from magit-submodule.el
  1485. (autoload 'magit-submodule "magit-submodule" nil t)
  1486. (autoload 'magit-submodule-add "magit-submodule" nil t)
  1487. (autoload 'magit-submodule-read-name-for-path "magit-submodule" "\
  1488. \(fn PATH &optional PREFER-SHORT)" nil nil)
  1489. (autoload 'magit-submodule-register "magit-submodule" nil t)
  1490. (autoload 'magit-submodule-populate "magit-submodule" nil t)
  1491. (autoload 'magit-submodule-update "magit-submodule" nil t)
  1492. (autoload 'magit-submodule-synchronize "magit-submodule" nil t)
  1493. (autoload 'magit-submodule-unpopulate "magit-submodule" nil t)
  1494. (autoload 'magit-submodule-remove "magit-submodule" "\
  1495. Unregister MODULES and remove their working directories.
  1496. For safety reasons, do not remove the gitdirs and if a module has
  1497. uncomitted changes, then do not remove it at all. If a module's
  1498. gitdir is located inside the working directory, then move it into
  1499. the gitdir of the superproject first.
  1500. With the \"--force\" argument offer to remove dirty working
  1501. directories and with a prefix argument offer to delete gitdirs.
  1502. Both actions are very dangerous and have to be confirmed. There
  1503. are additional safety precautions in place, so you might be able
  1504. to recover from making a mistake here, but don't count on it.
  1505. \(fn MODULES ARGS TRASH-GITDIRS)" t nil)
  1506. (autoload 'magit-insert-modules "magit-submodule" "\
  1507. Insert submodule sections.
  1508. Hook `magit-module-sections-hook' controls which module sections
  1509. are inserted, and option `magit-module-sections-nested' controls
  1510. whether they are wrapped in an additional section.
  1511. \(fn)" nil nil)
  1512. (autoload 'magit-insert-modules-overview "magit-submodule" "\
  1513. Insert sections for all modules.
  1514. For each section insert the path and the output of `git describe --tags',
  1515. or, failing that, the abbreviated HEAD commit hash.
  1516. \(fn)" nil nil)
  1517. (autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\
  1518. Insert sections for modules that haven't been pulled from the upstream.
  1519. These sections can be expanded to show the respective commits.
  1520. \(fn)" nil nil)
  1521. (autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\
  1522. Insert sections for modules that haven't been pulled from the push-remote.
  1523. These sections can be expanded to show the respective commits.
  1524. \(fn)" nil nil)
  1525. (autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\
  1526. Insert sections for modules that haven't been pushed to the upstream.
  1527. These sections can be expanded to show the respective commits.
  1528. \(fn)" nil nil)
  1529. (autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\
  1530. Insert sections for modules that haven't been pushed to the push-remote.
  1531. These sections can be expanded to show the respective commits.
  1532. \(fn)" nil nil)
  1533. (autoload 'magit-list-submodules "magit-submodule" "\
  1534. Display a list of the current repository's submodules.
  1535. \(fn)" t nil)
  1536. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-submodule" '("magit-")))
  1537. ;;;***
  1538. ;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (0 0 0 0))
  1539. ;;; Generated autoloads from magit-subtree.el
  1540. (autoload 'magit-subtree "magit-subtree" nil t)
  1541. (autoload 'magit-subtree-import "magit-subtree" nil t)
  1542. (autoload 'magit-subtree-export "magit-subtree" nil t)
  1543. (autoload 'magit-subtree-add "magit-subtree" "\
  1544. Add REF from REPOSITORY as a new subtree at PREFIX.
  1545. \(fn PREFIX REPOSITORY REF ARGS)" t nil)
  1546. (autoload 'magit-subtree-add-commit "magit-subtree" "\
  1547. Add COMMIT as a new subtree at PREFIX.
  1548. \(fn PREFIX COMMIT ARGS)" t nil)
  1549. (autoload 'magit-subtree-merge "magit-subtree" "\
  1550. Merge COMMIT into the PREFIX subtree.
  1551. \(fn PREFIX COMMIT ARGS)" t nil)
  1552. (autoload 'magit-subtree-pull "magit-subtree" "\
  1553. Pull REF from REPOSITORY into the PREFIX subtree.
  1554. \(fn PREFIX REPOSITORY REF ARGS)" t nil)
  1555. (autoload 'magit-subtree-push "magit-subtree" "\
  1556. Extract the history of the subtree PREFIX and push it to REF on REPOSITORY.
  1557. \(fn PREFIX REPOSITORY REF ARGS)" t nil)
  1558. (autoload 'magit-subtree-split "magit-subtree" "\
  1559. Extract the history of the subtree PREFIX.
  1560. \(fn PREFIX COMMIT ARGS)" t nil)
  1561. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-subtree" '("magit-")))
  1562. ;;;***
  1563. ;;;### (autoloads nil "magit-tag" "magit-tag.el" (0 0 0 0))
  1564. ;;; Generated autoloads from magit-tag.el
  1565. (autoload 'magit-tag "magit" nil t)
  1566. (autoload 'magit-tag-create "magit-tag" "\
  1567. Create a new tag with the given NAME at REV.
  1568. With a prefix argument annotate the tag.
  1569. \(git tag [--annotate] NAME REV)
  1570. \(fn NAME REV &optional ARGS)" t nil)
  1571. (autoload 'magit-tag-delete "magit-tag" "\
  1572. Delete one or more tags.
  1573. If the region marks multiple tags (and nothing else), then offer
  1574. to delete those, otherwise prompt for a single tag to be deleted,
  1575. defaulting to the tag at point.
  1576. \(git tag -d TAGS)
  1577. \(fn TAGS)" t nil)
  1578. (autoload 'magit-tag-prune "magit-tag" "\
  1579. Offer to delete tags missing locally from REMOTE, and vice versa.
  1580. \(fn TAGS REMOTE-TAGS REMOTE)" t nil)
  1581. (autoload 'magit-tag-release "magit-tag" "\
  1582. Create an annotated release tag.
  1583. Assume that release tags match `magit-release-tag-regexp'.
  1584. First prompt for the name of the new tag using the highest
  1585. existing tag as initial input and leaving it to the user to
  1586. increment the desired part of the version string.
  1587. Then prompt for the message of the new tag. Base the proposed
  1588. tag message on the message of the highest tag, provided that
  1589. that contains the corresponding version string and substituting
  1590. the new version string for that. Otherwise propose something
  1591. like \"Foo-Bar 1.2.3\", given, for example, a TAG \"v1.2.3\" and a
  1592. repository located at something like \"/path/to/foo-bar\".
  1593. Then call \"git tag --annotate --sign -m MSG TAG\" to create the,
  1594. tag, regardless of whether these arguments are enabled in the
  1595. popup. Finally show the refs buffer to let the user quickly
  1596. review the result.
  1597. \(fn TAG MSG)" t nil)
  1598. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-tag" '("magit-")))
  1599. ;;;***
  1600. ;;;### (autoloads nil "magit-transient" "magit-transient.el" (0 0
  1601. ;;;;;; 0 0))
  1602. ;;; Generated autoloads from magit-transient.el
  1603. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-transient" '("magit-")))
  1604. ;;;***
  1605. ;;;### (autoloads nil "magit-utils" "magit-utils.el" (0 0 0 0))
  1606. ;;; Generated autoloads from magit-utils.el
  1607. (autoload 'magit-emacs-Q-command "magit-utils" "\
  1608. Show a shell command that runs an uncustomized Emacs with only Magit loaded.
  1609. See info node `(magit)Debugging Tools' for more information.
  1610. \(fn)" t nil)
  1611. (autoload 'Info-follow-nearest-node--magit-gitman "magit-utils" "\
  1612. \(fn FN &optional FORK)" nil nil)
  1613. (advice-add 'Info-follow-nearest-node :around 'Info-follow-nearest-node--magit-gitman)
  1614. (autoload 'org-man-export--magit-gitman "magit-utils" "\
  1615. \(fn FN LINK DESCRIPTION FORMAT)" nil nil)
  1616. (advice-add 'org-man-export :around 'org-man-export--magit-gitman)
  1617. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-utils" '("magit-")))
  1618. ;;;***
  1619. ;;;### (autoloads nil "magit-wip" "magit-wip.el" (0 0 0 0))
  1620. ;;; Generated autoloads from magit-wip.el
  1621. (defvar magit-wip-after-save-mode nil "\
  1622. Non-nil if Magit-Wip-After-Save mode is enabled.
  1623. See the `magit-wip-after-save-mode' command
  1624. for a description of this minor mode.
  1625. Setting this variable directly does not take effect;
  1626. either customize it (see the info node `Easy Customization')
  1627. or call the function `magit-wip-after-save-mode'.")
  1628. (custom-autoload 'magit-wip-after-save-mode "magit-wip" nil)
  1629. (autoload 'magit-wip-after-save-mode "magit-wip" "\
  1630. Toggle Magit-Wip-After-Save-Local mode in all buffers.
  1631. With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive;
  1632. otherwise, disable it. If called from Lisp, enable the mode if
  1633. ARG is omitted or nil.
  1634. Magit-Wip-After-Save-Local mode is enabled in all buffers where
  1635. `magit-wip-after-save-local-mode-turn-on' would do it.
  1636. See `magit-wip-after-save-local-mode' for more information on Magit-Wip-After-Save-Local mode.
  1637. \(fn &optional ARG)" t nil)
  1638. (defvar magit-wip-after-apply-mode nil "\
  1639. Non-nil if Magit-Wip-After-Apply mode is enabled.
  1640. See the `magit-wip-after-apply-mode' command
  1641. for a description of this minor mode.")
  1642. (custom-autoload 'magit-wip-after-apply-mode "magit-wip" nil)
  1643. (autoload 'magit-wip-after-apply-mode "magit-wip" "\
  1644. Commit to work-in-progress refs.
  1645. After applying a change using any \"apply variant\"
  1646. command (apply, stage, unstage, discard, and reverse) commit the
  1647. affected files to the current wip refs. For each branch there
  1648. may be two wip refs; one contains snapshots of the files as found
  1649. in the worktree and the other contains snapshots of the entries
  1650. in the index.
  1651. \(fn &optional ARG)" t nil)
  1652. (defvar magit-wip-before-change-mode nil "\
  1653. Non-nil if Magit-Wip-Before-Change mode is enabled.
  1654. See the `magit-wip-before-change-mode' command
  1655. for a description of this minor mode.")
  1656. (custom-autoload 'magit-wip-before-change-mode "magit-wip" nil)
  1657. (autoload 'magit-wip-before-change-mode "magit-wip" "\
  1658. Commit to work-in-progress refs before certain destructive changes.
  1659. Before invoking a revert command or an \"apply variant\"
  1660. command (apply, stage, unstage, discard, and reverse) commit the
  1661. affected tracked files to the current wip refs. For each branch
  1662. there may be two wip refs; one contains snapshots of the files
  1663. as found in the worktree and the other contains snapshots of the
  1664. entries in the index.
  1665. Only changes to files which could potentially be affected by the
  1666. command which is about to be called are committed.
  1667. \(fn &optional ARG)" t nil)
  1668. (autoload 'magit-wip-commit-initial-backup "magit-wip" "\
  1669. Before saving, commit current file to a worktree wip ref.
  1670. The user has to add this function to `before-save-hook'.
  1671. Commit the current state of the visited file before saving the
  1672. current buffer to that file. This backs up the same version of
  1673. the file as `backup-buffer' would, but stores the backup in the
  1674. worktree wip ref, which is also used by the various Magit Wip
  1675. modes, instead of in a backup file as `backup-buffer' would.
  1676. This function ignores the variables that affect `backup-buffer'
  1677. and can be used along-side that function, which is recommended
  1678. because this function only backs up files that are tracked in
  1679. a Git repository.
  1680. \(fn)" nil nil)
  1681. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-wip" '("magit-")))
  1682. ;;;***
  1683. ;;;### (autoloads nil "magit-worktree" "magit-worktree.el" (0 0 0
  1684. ;;;;;; 0))
  1685. ;;; Generated autoloads from magit-worktree.el
  1686. (autoload 'magit-worktree "magit-worktree" nil t)
  1687. (autoload 'magit-worktree-checkout "magit-worktree" "\
  1688. Checkout BRANCH in a new worktree at PATH.
  1689. \(fn PATH BRANCH)" t nil)
  1690. (autoload 'magit-worktree-branch "magit-worktree" "\
  1691. Create a new BRANCH and check it out in a new worktree at PATH.
  1692. \(fn PATH BRANCH START-POINT &optional FORCE)" t nil)
  1693. (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-worktree" '("magit-")))
  1694. ;;;***
  1695. ;;;### (autoloads nil nil ("magit-core.el" "magit-pkg.el") (0 0 0
  1696. ;;;;;; 0))
  1697. ;;;***
  1698. ;; Local Variables:
  1699. ;; version-control: never
  1700. ;; no-byte-compile: t
  1701. ;; no-update-autoloads: t
  1702. ;; coding: utf-8
  1703. ;; End:
  1704. ;;; magit-autoloads.el ends here