mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-17 c4001ccd1864293b64aa37d83a9d9457eb875e70
commit | author | age
5cb5f7 1 ;;; magit-autoloads.el --- automatically extracted autoloads
C 2 ;;
3 ;;; Code:
4
5 (add-to-list 'load-path (directory-file-name
6                          (or (file-name-directory #$) (car load-path))))
7
8
9 ;;;### (autoloads nil "git-rebase" "git-rebase.el" (0 0 0 0))
10 ;;; Generated autoloads from git-rebase.el
11
12 (autoload 'git-rebase-mode "git-rebase" "\
13 Major mode for editing of a Git rebase file.
14
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
20 \(fn)" t nil)
21
22 (defconst git-rebase-filename-regexp "/git-rebase-todo\\'")
23
24 (add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp 'git-rebase-mode))
25
26 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "git-rebase" '("git-rebase-")))
27
28 ;;;***
29
30 ;;;### (autoloads nil "magit" "magit.el" (0 0 0 0))
31 ;;; Generated autoloads from magit.el
32  (autoload 'magit-dispatch-popup "magit" nil t)
33  (autoload 'magit-run-popup "magit" nil t)
34
35 (autoload 'magit-git-command "magit" "\
36 Execute COMMAND asynchronously; display output.
37
38 Interactively, prompt for COMMAND in the minibuffer. \"git \" is
39 used as initial input, but can be deleted to run another command.
40
41 With a prefix argument COMMAND is run in the top-level directory
42 of the current working tree, otherwise in `default-directory'.
43
44 \(fn COMMAND)" t nil)
45
46 (autoload 'magit-git-command-topdir "magit" "\
47 Execute COMMAND asynchronously; display output.
48
49 Interactively, prompt for COMMAND in the minibuffer. \"git \" is
50 used as initial input, but can be deleted to run another command.
51
52 COMMAND is run in the top-level directory of the current
53 working tree.
54
55 \(fn COMMAND)" t nil)
56
57 (autoload 'magit-shell-command "magit" "\
58 Execute COMMAND asynchronously; display output.
59
60 Interactively, prompt for COMMAND in the minibuffer.  With a
61 prefix argument COMMAND is run in the top-level directory of
62 the current working tree, otherwise in `default-directory'.
63
64 \(fn COMMAND)" t nil)
65
66 (autoload 'magit-shell-command-topdir "magit" "\
67 Execute COMMAND asynchronously; display output.
68
69 Interactively, prompt for COMMAND in the minibuffer.  COMMAND
70 is run in the top-level directory of the current working tree.
71
72 \(fn COMMAND)" t nil)
73
74 (autoload 'magit-version "magit" "\
75 Return the version of Magit currently in use.
76 If optional argument PRINT-DEST is non-nil, output
77 stream (interactively, the echo area, or the current buffer with
78 a prefix argument), also print the used versions of Magit, Git,
79 and Emacs to it.
80
81 \(fn &optional PRINT-DEST)" t nil)
82
83 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit" '("magit-")))
84
85 ;;;***
86
87 ;;;### (autoloads nil "magit-apply" "magit-apply.el" (0 0 0 0))
88 ;;; Generated autoloads from magit-apply.el
89
90 (autoload 'magit-stage-file "magit-apply" "\
91 Stage all changes to FILE.
92 With a prefix argument or when there is no file at point ask for
93 the file to be staged.  Otherwise stage the file at point without
94 requiring confirmation.
95
96 \(fn FILE)" t nil)
97
98 (autoload 'magit-stage-modified "magit-apply" "\
99 Stage all changes to files modified in the worktree.
100 Stage all new content of tracked files and remove tracked files
101 that no longer exist in the working tree from the index also.
102 With a prefix argument also stage previously untracked (but not
103 ignored) files.
104
105 \(fn &optional ALL)" t nil)
106
107 (autoload 'magit-unstage-file "magit-apply" "\
108 Unstage all changes to FILE.
109 With a prefix argument or when there is no file at point ask for
110 the file to be unstaged.  Otherwise unstage the file at point
111 without requiring confirmation.
112
113 \(fn FILE)" t nil)
114
115 (autoload 'magit-unstage-all "magit-apply" "\
116 Remove all changes from the staging area.
117
118 \(fn)" t nil)
119
120 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-apply" '("magit-")))
121
122 ;;;***
123
124 ;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (0
125 ;;;;;;  0 0 0))
126 ;;; Generated autoloads from magit-autorevert.el
127
128 (defvar magit-auto-revert-mode (and (not global-auto-revert-mode) (not noninteractive)) "\
129 Non-nil if Magit-Auto-Revert mode is enabled.
130 See the `magit-auto-revert-mode' command
131 for a description of this minor mode.
132 Setting this variable directly does not take effect;
133 either customize it (see the info node `Easy Customization')
134 or call the function `magit-auto-revert-mode'.")
135
136 (custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
137
138 (autoload 'magit-auto-revert-mode "magit-autorevert" "\
139 Toggle Auto-Revert mode in all buffers.
140 With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
141 otherwise, disable it.  If called from Lisp, enable the mode if
142 ARG is omitted or nil.
143
144 Auto-Revert mode is enabled in all buffers where
145 `magit-turn-on-auto-revert-mode-if-desired' would do it.
146 See `auto-revert-mode' for more information on Auto-Revert mode.
147
148 \(fn &optional ARG)" t nil)
149
150 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-")))
151
152 ;;;***
153
154 ;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (0 0 0 0))
155 ;;; Generated autoloads from magit-bisect.el
156  (autoload 'magit-bisect-popup "magit-bisect" nil t)
157
158 (autoload 'magit-bisect-start "magit-bisect" "\
159 Start a bisect session.
160
161 Bisecting a bug means to find the commit that introduced it.
162 This command starts such a bisect session by asking for a know
163 good and a bad commit.  To move the session forward use the
164 other actions from the bisect popup (\\<magit-status-mode-map>\\[magit-bisect-popup]).
165
166 \(fn BAD GOOD)" t nil)
167
168 (autoload 'magit-bisect-reset "magit-bisect" "\
169 After bisecting, cleanup bisection state and return to original `HEAD'.
170
171 \(fn)" t nil)
172
173 (autoload 'magit-bisect-good "magit-bisect" "\
174 While bisecting, mark the current commit as good.
175 Use this after you have asserted that the commit does not contain
176 the bug in question.
177
178 \(fn)" t nil)
179
180 (autoload 'magit-bisect-bad "magit-bisect" "\
181 While bisecting, mark the current commit as bad.
182 Use this after you have asserted that the commit does contain the
183 bug in question.
184
185 \(fn)" t nil)
186
187 (autoload 'magit-bisect-skip "magit-bisect" "\
188 While bisecting, skip the current commit.
189 Use this if for some reason the current commit is not a good one
190 to test.  This command lets Git choose a different one.
191
192 \(fn)" t nil)
193
194 (autoload 'magit-bisect-run "magit-bisect" "\
195 Bisect automatically by running commands after each step.
196
197 Unlike `git bisect run' this can be used before bisecting has
198 begun.  In that case it behaves like `git bisect start; git
199 bisect run'.
200
201 \(fn CMDLINE &optional BAD GOOD)" t nil)
202
203 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bisect" '("magit-")))
204
205 ;;;***
206
207 ;;;### (autoloads nil "magit-blame" "magit-blame.el" (0 0 0 0))
208 ;;; Generated autoloads from magit-blame.el
209
210 (autoload 'magit-blame-echo "magit-blame" "\
211 For each line show the revision in which it was added.
212 Show the information about the chunk at point in the echo area
213 when moving between chunks.  Unlike other blaming commands, do
214 not turn on `read-only-mode'.
215
216 \(fn)" t nil)
217
218 (autoload 'magit-blame-addition "magit-blame" "\
219 For each line show the revision in which it was added.
220
221 \(fn)" t nil)
222
223 (autoload 'magit-blame-removal "magit-blame" "\
224 For each line show the revision in which it was removed.
225
226 \(fn)" t nil)
227
228 (autoload 'magit-blame-reverse "magit-blame" "\
229 For each line show the last revision in which it still exists.
230
231 \(fn)" t nil)
232  (autoload 'magit-blame-popup "magit-blame" nil t)
233
234 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-blame" '("magit-")))
235
236 ;;;***
237
238 ;;;### (autoloads nil "magit-bookmark" "magit-bookmark.el" (0 0 0
239 ;;;;;;  0))
240 ;;; Generated autoloads from magit-bookmark.el
241
242 (autoload 'magit-bookmark--status-jump "magit-bookmark" "\
243 Handle a Magit status BOOKMARK.
244
245 \(fn BOOKMARK)" nil nil)
246
247 (autoload 'magit-bookmark--status-make-record "magit-bookmark" "\
248 Create a Magit status bookmark.
249
250 \(fn)" nil nil)
251
252 (autoload 'magit-bookmark--refs-jump "magit-bookmark" "\
253 Handle a Magit refs BOOKMARK.
254
255 \(fn BOOKMARK)" nil nil)
256
257 (autoload 'magit-bookmark--refs-make-record "magit-bookmark" "\
258 Create a Magit refs bookmark.
259
260 \(fn)" nil nil)
261
262 (autoload 'magit-bookmark--log-jump "magit-bookmark" "\
263 Handle a Magit log BOOKMARK.
264
265 \(fn BOOKMARK)" nil nil)
266
267 (autoload 'magit-bookmark--log-make-record "magit-bookmark" "\
268 Create a Magit log bookmark.
269
270 \(fn)" nil nil)
271
272 (autoload 'magit-bookmark--reflog-jump "magit-bookmark" "\
273 Handle a Magit reflog BOOKMARK.
274
275 \(fn BOOKMARK)" nil nil)
276
277 (autoload 'magit-bookmark--reflog-make-record "magit-bookmark" "\
278 Create a Magit reflog bookmark.
279
280 \(fn)" nil nil)
281
282 (autoload 'magit-bookmark--stashes-jump "magit-bookmark" "\
283 Handle a Magit stash list BOOKMARK.
284
285 \(fn BOOKMARK)" nil nil)
286
287 (autoload 'magit-bookmark--stashes-make-record "magit-bookmark" "\
288 Create a Magit stash list bookmark.
289
290 \(fn)" nil nil)
291
292 (autoload 'magit-bookmark--cherry-jump "magit-bookmark" "\
293 Handle a Magit cherry BOOKMARK.
294
295 \(fn BOOKMARK)" nil nil)
296
297 (autoload 'magit-bookmark--cherry-make-record "magit-bookmark" "\
298 Create a Magit cherry bookmark.
299
300 \(fn)" nil nil)
301
302 (autoload 'magit-bookmark--diff-jump "magit-bookmark" "\
303 Handle a Magit diff BOOKMARK.
304
305 \(fn BOOKMARK)" nil nil)
306
307 (autoload 'magit-bookmark--diff-make-record "magit-bookmark" "\
308 Create a Magit diff bookmark.
309
310 \(fn)" nil nil)
311
312 (autoload 'magit-bookmark--revision-jump "magit-bookmark" "\
313 Handle a Magit revision BOOKMARK.
314
315 \(fn BOOKMARK)" nil nil)
316
317 (autoload 'magit-bookmark--revision-make-record "magit-bookmark" "\
318 Create a Magit revision bookmark.
319
320 \(fn)" nil nil)
321
322 (autoload 'magit-bookmark--stash-jump "magit-bookmark" "\
323 Handle a Magit stash BOOKMARK.
324
325 \(fn BOOKMARK)" nil nil)
326
327 (autoload 'magit-bookmark--stash-make-record "magit-bookmark" "\
328 Create a Magit stash bookmark.
329
330 \(fn)" nil nil)
331
332 (autoload 'magit-bookmark--submodules-jump "magit-bookmark" "\
333 Handle a Magit submodule list BOOKMARK.
334
335 \(fn BOOKMARK)" nil nil)
336
337 (autoload 'magit-bookmark--submodules-make-record "magit-bookmark" "\
338 Create a Magit submodule list bookmark.
339
340 \(fn)" nil nil)
341
342 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-bookmark" '("magit-bookmark--")))
343
344 ;;;***
345
346 ;;;### (autoloads nil "magit-branch" "magit-branch.el" (0 0 0 0))
347 ;;; Generated autoloads from magit-branch.el
348  (autoload 'magit-branch-popup "magit" nil t)
349
350 (autoload 'magit-checkout "magit-branch" "\
351 Checkout REVISION, updating the index and the working tree.
352 If REVISION is a local branch, then that becomes the current
353 branch.  If it is something else, then `HEAD' becomes detached.
354 Checkout fails if the working tree or the staging area contain
355 changes.
356
357 \(git checkout REVISION).
358
359 \(fn REVISION)" t nil)
360
361 (autoload 'magit-branch-create "magit-branch" "\
362 Create BRANCH at branch or revision START-POINT.
363
364 \(git branch [ARGS] BRANCH START-POINT).
365
366 \(fn BRANCH START-POINT &optional ARGS)" t nil)
367
368 (autoload 'magit-branch-and-checkout "magit-branch" "\
369 Create and checkout BRANCH at branch or revision START-POINT.
370
371 \(git checkout [ARGS] -b BRANCH START-POINT).
372
373 \(fn BRANCH START-POINT &optional ARGS)" t nil)
374
375 (autoload 'magit-branch-or-checkout "magit-branch" "\
376 Hybrid between `magit-checkout' and `magit-branch-and-checkout'.
377
378 Ask the user for an existing branch or revision.  If the user
379 input actually can be resolved as a branch or revision, then
380 check that out, just like `magit-checkout' would.
381
382 Otherwise create and checkout a new branch using the input as
383 its name.  Before doing so read the starting-point for the new
384 branch.  This is similar to what `magit-branch-and-checkout'
385 does.
386
387 \(fn ARG &optional START-POINT)" t nil)
388
389 (autoload 'magit-branch-checkout "magit-branch" "\
390 Checkout an existing or new local branch.
391
392 Read a branch name from the user offering all local branches and
393 a subset of remote branches as candidates.  Omit remote branches
394 for which a local branch by the same name exists from the list
395 of candidates.  The user can also enter a completely new branch
396 name.
397
398 - If the user selects an existing local branch, then check that
399   out.
400
401 - If the user selects a remote branch, then create and checkout
402   a new local branch with the same name.  Configure the selected
403   remote branch as push target.
404
405 - If the user enters a new branch name, then create and check
406   that out, after also reading the starting-point from the user.
407
408 In the latter two cases the upstream is also set.  Whether it is
409 set to the chosen START-POINT or something else depends on the
410 value of `magit-branch-adjust-remote-upstream-alist', just like
411 when using `magit-branch-and-checkout'.
412
413 \(fn BRANCH &optional START-POINT)" t nil)
414
415 (autoload 'magit-branch-orphan "magit-branch" "\
416 Create and checkout an orphan BRANCH with contents from revision START-POINT.
417
418 \(git checkout --orphan [ARGS] BRANCH START-POINT).
419
420 \(fn BRANCH START-POINT &optional ARGS)" t nil)
421
422 (autoload 'magit-branch-pull-request "magit-branch" "\
423 Create and configure a new branch from a pull-request.
424 Please see the manual for more information.
425
426 \(fn PR)" t nil)
427
428 (autoload 'magit-branch-spinoff "magit-branch" "\
429 Create new branch from the unpushed commits.
430
431 Create and checkout a new branch starting at and tracking the
432 current branch.  That branch in turn is reset to the last commit
433 it shares with its upstream.  If the current branch has no
434 upstream or no unpushed commits, then the new branch is created
435 anyway and the previously current branch is not touched.
436
437 This is useful to create a feature branch after work has already
438 began on the old branch (likely but not necessarily \"master\").
439
440 If the current branch is a member of the value of option
441 `magit-branch-prefer-remote-upstream' (which see), then the
442 current branch will be used as the starting point as usual, but
443 the upstream of the starting-point may be used as the upstream
444 of the new branch, instead of the starting-point itself.
445
446 If optional FROM is non-nil, then the source branch is reset
447 to `FROM~', instead of to the last commit it shares with its
448 upstream.  Interactively, FROM is only ever non-nil, if the
449 region selects some commits, and among those commits, FROM is
450 the commit that is the fewest commits ahead of the source
451 branch.
452
453 The commit at the other end of the selection actually does not
454 matter, all commits between FROM and `HEAD' are moved to the new
455 branch.  If FROM is not reachable from `HEAD' or is reachable
456 from the source branch's upstream, then an error is raised.
457
458 \(fn BRANCH &optional FROM &rest ARGS)" t nil)
459
460 (autoload 'magit-branch-reset "magit-branch" "\
461 Reset a branch to the tip of another branch or any other commit.
462
463 When the branch being reset is the current branch, then do a
464 hard reset.  If there are any uncommitted changes, then the user
465 has to confirm the reset because those changes would be lost.
466
467 This is useful when you have started work on a feature branch but
468 realize it's all crap and want to start over.
469
470 When resetting to another branch and a prefix argument is used,
471 then also set the target branch as the upstream of the branch
472 that is being reset.
473
474 \(fn BRANCH TO &optional ARGS SET-UPSTREAM)" t nil)
475
476 (autoload 'magit-branch-delete "magit-branch" "\
477 Delete one or multiple branches.
478 If the region marks multiple branches, then offer to delete
479 those, otherwise prompt for a single branch to be deleted,
480 defaulting to the branch at point.
481
482 \(fn BRANCHES &optional FORCE)" t nil)
483
484 (autoload 'magit-branch-rename "magit-branch" "\
485 Rename the branch named OLD to NEW.
486
487 With a prefix argument FORCE, rename even if a branch named NEW
488 already exists.
489
490 If `branch.OLD.pushRemote' is set, then unset it.  Depending on
491 the value of `magit-branch-rename-push-target' (which see) maybe
492 set `branch.NEW.pushRemote' and maybe rename the push-target on
493 the remote.
494
495 \(fn OLD NEW &optional FORCE)" t nil)
496
497 (autoload 'magit-branch-shelve "magit-branch" "\
498 Shelve a BRANCH.
499 Rename \"refs/heads/BRANCH\" to \"refs/shelved/BRANCH\",
500 and also rename the respective reflog file.
501
502 \(fn BRANCH)" t nil)
503
504 (autoload 'magit-branch-unshelve "magit-branch" "\
505 Unshelve a BRANCH
506 Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\",
507 and also rename the respective reflog file.
508
509 \(fn BRANCH)" t nil)
510
511 (autoload 'magit-branch-config-popup "magit-branch" "\
512 Popup console for setting branch variables.
513
514 \(fn BRANCH)" t nil)
515
516 (autoload 'magit-edit-branch*description "magit-branch" "\
517 Edit the description of the current branch.
518 With a prefix argument edit the description of another branch.
519
520 The description for the branch named NAME is stored in the Git
521 variable `branch.<name>.description'.
522
523 \(fn BRANCH)" t nil)
524
525 (autoload 'magit-set-branch*merge/remote "magit-branch" "\
526 Set or unset the upstream of the current branch.
527 With a prefix argument do so for another branch.
528
529 When the branch in question already has an upstream then simply
530 unsets it.  Invoke this command again to set another upstream.
531
532 Together the Git variables `branch.<name>.remote' and
533 `branch.<name>.merge' define the upstream branch of the local
534 branch named NAME.  The value of `branch.<name>.remote' is the
535 name of the upstream remote.  The value of `branch.<name>.merge'
536 is the full reference of the upstream branch, on the remote.
537
538 Non-interactively, when UPSTREAM is non-nil, then always set it
539 as the new upstream, regardless of whether another upstream was
540 already set.  When nil, then always unset.
541
542 \(fn BRANCH UPSTREAM)" t nil)
543
544 (autoload 'magit-cycle-branch*rebase "magit-branch" "\
545 Cycle the value of `branch.<name>.rebase' for the current branch.
546 With a prefix argument cycle the value for another branch.
547
548 The Git variables `branch.<name>.rebase' controls whether pulling
549 into the branch named NAME is done by rebasing that branch onto
550 the fetched branch or by merging that branch.
551
552 When `true' then pulling is done by rebasing.
553 When `false' then pulling is done by merging.
554
555 When that variable is undefined then the value of `pull.rebase'
556 is used instead.  It defaults to `false'.
557
558 \(fn BRANCH)" t nil)
559
560 (autoload 'magit-cycle-branch*pushRemote "magit-branch" "\
561 Cycle the value of `branch.<name>.pushRemote' for the current branch.
562 With a prefix argument cycle the value for another branch.
563
564 The Git variable `branch.<name>.pushRemote' specifies the remote
565 that the branch named NAME is usually pushed to.  The value has
566 to be the name of an existing remote.
567
568 If that variable is undefined, then the value of the Git variable
569 `remote.pushDefault' is used instead, provided that it is defined,
570 which by default it is not.
571
572 \(fn BRANCH)" t nil)
573
574 (autoload 'magit-cycle-pull\.rebase "magit-branch" "\
575 Cycle the repository-local value of `pull.rebase'.
576
577 The Git variable `pull.rebase' specifies whether pulling is done
578 by rebasing or by merging.  It can be overwritten using the Git
579 variable `branch.<name>.rebase'.
580
581 When `true' then pulling is done by rebasing.
582 When `false' (the default) then pulling is done by merging.
583
584 \(fn)" t nil)
585
586 (autoload 'magit-cycle-remote\.pushDefault "magit-branch" "\
587 Cycle the repository-local value of `remote.pushDefault'.
588
589 The Git variable `remote.pushDefault' specifies the remote that
590 local branches are usually pushed to.  It can be overwritten
591 using the Git variable `branch.<name>.pushRemote'.
592
593 \(fn)" t nil)
594
595 (autoload 'magit-cycle-branch*autoSetupMerge "magit-branch" "\
596 Cycle the repository-local value of `branch.autoSetupMerge'.
597
598 The Git variable `branch.autoSetupMerge' under what circumstances
599 creating a branch (named NAME) should result in the variables
600 `branch.<name>.merge' and `branch.<name>.remote' being set
601 according to the starting point used to create the branch.  If
602 the starting point isn't a branch, then these variables are never
603 set.
604
605 When `always' then the variables are set regardless of whether
606 the starting point is a local or a remote branch.
607
608 When `true' (the default) then the variable are set when the
609 starting point is a remote branch, but not when it is a local
610 branch.
611
612 When `false' then the variables are never set.
613
614 \(fn)" t nil)
615
616 (autoload 'magit-cycle-branch*autoSetupRebase "magit-branch" "\
617 Cycle the repository-local value of `branch.autoSetupRebase'.
618
619 The Git variable `branch.autoSetupRebase' specifies whether
620 creating a branch (named NAME) should result in the variable
621 `branch.<name>.rebase' being set to `true'.
622
623 When `always' then the variable is set regardless of whether the
624 starting point is a local or a remote branch.
625
626 When `local' then the variable are set when the starting point
627 is a local branch, but not when it is a remote branch.
628
629 When `remote' then the variable are set when the starting point
630 is a remote branch, but not when it is a local branch.
631
632 When `never' (the default) then the variable is never set.
633
634 \(fn)" t nil)
635
636 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-branch" '("magit-")))
637
638 ;;;***
639
640 ;;;### (autoloads nil "magit-clone" "magit-clone.el" (0 0 0 0))
641 ;;; Generated autoloads from magit-clone.el
642
643 (autoload 'magit-clone "magit-clone" "\
644 Clone the REPOSITORY to DIRECTORY.
645 Then show the status buffer for the new repository.
646
647 \(fn REPOSITORY DIRECTORY)" t nil)
648
649 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-clone" '("magit-clone-")))
650
651 ;;;***
652
653 ;;;### (autoloads nil "magit-collab" "magit-collab.el" (0 0 0 0))
654 ;;; Generated autoloads from magit-collab.el
655
656 (autoload 'magit-browse-pull-request "magit-collab" "\
657 Visit pull-request PR using `browse-url'.
658
659 Currently this only supports Github, but that restriction will
660 be lifted eventually to support other Git forges.
661
662 \(fn PR)" t nil)
663
664 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-collab" '("magit-")))
665
666 ;;;***
667
668 ;;;### (autoloads nil "magit-commit" "magit-commit.el" (0 0 0 0))
669 ;;; Generated autoloads from magit-commit.el
670
671 (autoload 'magit-commit-create "magit-commit" "\
672 Create a new commit on `HEAD'.
673 With a prefix argument, amend to the commit at `HEAD' instead.
674
675 \(git commit [--amend] ARGS)
676
677 \(fn &optional ARGS)" t nil)
678
679 (autoload 'magit-commit-amend "magit-commit" "\
680 Amend the last commit.
681
682 \(git commit --amend ARGS)
683
684 \(fn &optional ARGS)" t nil)
685
686 (autoload 'magit-commit-extend "magit-commit" "\
687 Amend the last commit, without editing the message.
688
689 With a prefix argument keep the committer date, otherwise change
690 it.  The option `magit-commit-extend-override-date' can be used
691 to inverse the meaning of the prefix argument.  
692 \(git commit
693 --amend --no-edit)
694
695 \(fn &optional ARGS OVERRIDE-DATE)" t nil)
696
697 (autoload 'magit-commit-reword "magit-commit" "\
698 Reword the last commit, ignoring staged changes.
699
700 With a prefix argument keep the committer date, otherwise change
701 it.  The option `magit-commit-reword-override-date' can be used
702 to inverse the meaning of the prefix argument.
703
704 Non-interactively respect the optional OVERRIDE-DATE argument
705 and ignore the option.
706
707 \(git commit --amend --only)
708
709 \(fn &optional ARGS OVERRIDE-DATE)" t nil)
710
711 (autoload 'magit-commit-fixup "magit-commit" "\
712 Create a fixup commit.
713
714 With a prefix argument the target COMMIT has to be confirmed.
715 Otherwise the commit at point may be used without confirmation
716 depending on the value of option `magit-commit-squash-confirm'.
717
718 \(fn &optional COMMIT ARGS)" t nil)
719
720 (autoload 'magit-commit-squash "magit-commit" "\
721 Create a squash commit, without editing the squash message.
722
723 With a prefix argument the target COMMIT has to be confirmed.
724 Otherwise the commit at point may be used without confirmation
725 depending on the value of option `magit-commit-squash-confirm'.
726
727 \(fn &optional COMMIT ARGS)" t nil)
728
729 (autoload 'magit-commit-augment "magit-commit" "\
730 Create a squash commit, editing the squash message.
731
732 With a prefix argument the target COMMIT has to be confirmed.
733 Otherwise the commit at point may be used without confirmation
734 depending on the value of option `magit-commit-squash-confirm'.
735
736 \(fn &optional COMMIT ARGS)" t nil)
737
738 (autoload 'magit-commit-instant-fixup "magit-commit" "\
739 Create a fixup commit targeting COMMIT and instantly rebase.
740
741 \(fn &optional COMMIT ARGS)" t nil)
742
743 (autoload 'magit-commit-instant-squash "magit-commit" "\
744 Create a squash commit targeting COMMIT and instantly rebase.
745
746 \(fn &optional COMMIT ARGS)" t nil)
747
748 (autoload 'magit-commit-reshelve "magit-commit" "\
749 Change the committer date and possibly the author date of `HEAD'.
750
751 If you are the author of `HEAD', then both dates are changed,
752 otherwise only the committer date.  The current time is used
753 as the initial minibuffer input and the original author (if
754 that is you) or committer date is available as the previous
755 history element.
756
757 \(fn DATE)" t nil)
758  (autoload 'magit-commit-absorb-popup "magit-commit" nil t)
759
760 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-commit" '("magit-")))
761
762 ;;;***
763
764 ;;;### (autoloads nil "magit-diff" "magit-diff.el" (0 0 0 0))
765 ;;; Generated autoloads from magit-diff.el
766
767 (autoload 'magit-diff-popup "magit-diff" "\
768 Popup console for diff commands.
769
770 \(fn ARG)" t nil)
771
772 (autoload 'magit-diff-buffer-file-popup "magit-diff" "\
773 Popup console for diff commands.
774
775 This is a variant of `magit-diff-popup' which shows the same popup
776 but which limits the diff to the file being visited in the current
777 buffer.
778
779 \(fn)" t nil)
780
781 (autoload 'magit-diff-dwim "magit-diff" "\
782 Show changes for the thing at point.
783
784 \(fn &optional ARGS FILES)" t nil)
785
786 (autoload 'magit-diff-range "magit-diff" "\
787 Show differences between two commits.
788
789 REV-OR-RANGE should be a range or a single revision.  If it is a
790 revision, then show changes in the working tree relative to that
791 revision.  If it is a range, but one side is omitted, then show
792 changes relative to `HEAD'.
793
794 If the region is active, use the revisions on the first and last
795 line of the region as the two sides of the range.  With a prefix
796 argument, instead of diffing the revisions, choose a revision to
797 view changes along, starting at the common ancestor of both
798 revisions (i.e., use a \"...\" range).
799
800 \(fn REV-OR-RANGE &optional ARGS FILES)" t nil)
801
802 (autoload 'magit-diff-working-tree "magit-diff" "\
803 Show changes between the current working tree and the `HEAD' commit.
804 With a prefix argument show changes between the working tree and
805 a commit read from the minibuffer.
806
807 \(fn &optional REV ARGS FILES)" t nil)
808
809 (autoload 'magit-diff-staged "magit-diff" "\
810 Show changes between the index and the `HEAD' commit.
811 With a prefix argument show changes between the index and
812 a commit read from the minibuffer.
813
814 \(fn &optional REV ARGS FILES)" t nil)
815
816 (autoload 'magit-diff-unstaged "magit-diff" "\
817 Show changes between the working tree and the index.
818
819 \(fn &optional ARGS FILES)" t nil)
820
821 (autoload 'magit-diff-unmerged "magit-diff" "\
822 Show changes that are being merged.
823
824 \(fn &optional ARGS FILES)" t nil)
825
826 (autoload 'magit-diff-while-committing "magit-diff" "\
827 While committing, show the changes that are about to be committed.
828 While amending, invoking the command again toggles between
829 showing just the new changes or all the changes that will
830 be committed.
831
832 \(fn &optional ARGS)" t nil)
833
834 (autoload 'magit-diff-buffer-file "magit-diff" "\
835 Show diff for the blob or file visited in the current buffer.
836
837 \(fn)" t nil)
838
839 (autoload 'magit-diff-paths "magit-diff" "\
840 Show changes between any two files on disk.
841
842 \(fn A B)" t nil)
843
844 (autoload 'magit-show-commit "magit-diff" "\
845 Visit the revision at point in another buffer.
846 If there is no revision at point or with a prefix argument prompt
847 for a revision.
848
849 \(fn REV &optional ARGS FILES MODULE)" t nil)
850
851 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-diff" '("magit-")))
852
853 ;;;***
854
855 ;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (0 0 0 0))
856 ;;; Generated autoloads from magit-ediff.el
857  (autoload 'magit-ediff-popup "magit-ediff" nil t)
858
859 (autoload 'magit-ediff-resolve "magit-ediff" "\
860 Resolve outstanding conflicts in FILE using Ediff.
861 FILE has to be relative to the top directory of the repository.
862
863 In the rare event that you want to manually resolve all
864 conflicts, including those already resolved by Git, use
865 `ediff-merge-revisions-with-ancestor'.
866
867 \(fn FILE)" t nil)
868
869 (autoload 'magit-ediff-stage "magit-ediff" "\
870 Stage and unstage changes to FILE using Ediff.
871 FILE has to be relative to the top directory of the repository.
872
873 \(fn FILE)" t nil)
874
875 (autoload 'magit-ediff-compare "magit-ediff" "\
876 Compare REVA:FILEA with REVB:FILEB using Ediff.
877
878 FILEA and FILEB have to be relative to the top directory of the
879 repository.  If REVA or REVB is nil, then this stands for the
880 working tree state.
881
882 If the region is active, use the revisions on the first and last
883 line of the region.  With a prefix argument, instead of diffing
884 the revisions, choose a revision to view changes along, starting
885 at the common ancestor of both revisions (i.e., use a \"...\"
886 range).
887
888 \(fn REVA REVB FILEA FILEB)" t nil)
889
890 (autoload 'magit-ediff-dwim "magit-ediff" "\
891 Compare, stage, or resolve using Ediff.
892 This command tries to guess what file, and what commit or range
893 the user wants to compare, stage, or resolve using Ediff.  It
894 might only be able to guess either the file, or range or commit,
895 in which case the user is asked about the other.  It might not
896 always guess right, in which case the appropriate `magit-ediff-*'
897 command has to be used explicitly.  If it cannot read the user's
898 mind at all, then it asks the user for a command to run.
899
900 \(fn)" t nil)
901
902 (autoload 'magit-ediff-show-staged "magit-ediff" "\
903 Show staged changes using Ediff.
904
905 This only allows looking at the changes; to stage, unstage,
906 and discard changes using Ediff, use `magit-ediff-stage'.
907
908 FILE must be relative to the top directory of the repository.
909
910 \(fn FILE)" t nil)
911
912 (autoload 'magit-ediff-show-unstaged "magit-ediff" "\
913 Show unstaged changes using Ediff.
914
915 This only allows looking at the changes; to stage, unstage,
916 and discard changes using Ediff, use `magit-ediff-stage'.
917
918 FILE must be relative to the top directory of the repository.
919
920 \(fn FILE)" t nil)
921
922 (autoload 'magit-ediff-show-working-tree "magit-ediff" "\
923 Show changes between `HEAD' and working tree using Ediff.
924 FILE must be relative to the top directory of the repository.
925
926 \(fn FILE)" t nil)
927
928 (autoload 'magit-ediff-show-commit "magit-ediff" "\
929 Show changes introduced by COMMIT using Ediff.
930
931 \(fn COMMIT)" t nil)
932
933 (autoload 'magit-ediff-show-stash "magit-ediff" "\
934 Show changes introduced by STASH using Ediff.
935 `magit-ediff-show-stash-with-index' controls whether a
936 three-buffer Ediff is used in order to distinguish changes in the
937 stash that were staged.
938
939 \(fn STASH)" t nil)
940
941 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-ediff" '("magit-ediff-")))
942
943 ;;;***
944
945 ;;;### (autoloads nil "magit-extras" "magit-extras.el" (0 0 0 0))
946 ;;; Generated autoloads from magit-extras.el
947
948 (autoload 'magit-run-git-gui "magit-extras" "\
949 Run `git gui' for the current git repository.
950
951 \(fn)" t nil)
952
953 (autoload 'magit-run-git-gui-blame "magit-extras" "\
954 Run `git gui blame' on the given FILENAME and COMMIT.
955 Interactively run it for the current file and the `HEAD', with a
956 prefix or when the current file cannot be determined let the user
957 choose.  When the current buffer is visiting FILENAME instruct
958 blame to center around the line point is on.
959
960 \(fn COMMIT FILENAME &optional LINENUM)" t nil)
961
962 (autoload 'magit-run-gitk "magit-extras" "\
963 Run `gitk' in the current repository.
964
965 \(fn)" t nil)
966
967 (autoload 'magit-run-gitk-branches "magit-extras" "\
968 Run `gitk --branches' in the current repository.
969
970 \(fn)" t nil)
971
972 (autoload 'magit-run-gitk-all "magit-extras" "\
973 Run `gitk --all' in the current repository.
974
975 \(fn)" t nil)
976
977 (autoload 'ido-enter-magit-status "magit-extras" "\
978 Drop into `magit-status' from file switching.
979
980 This command does not work in Emacs 26.  It does work in Emacs 25
981 and Emacs 27.  See https://github.com/magit/magit/issues/3634 and
982 https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.
983
984 To make this command available use something like:
985
986   (add-hook \\='ido-setup-hook
987             (lambda ()
988               (define-key ido-completion-map
989                 (kbd \"C-x g\") \\='ido-enter-magit-status)))
990
991 Starting with Emacs 25.1 the Ido keymaps are defined just once
992 instead of every time Ido is invoked, so now you can modify it
993 like pretty much every other keymap:
994
995   (define-key ido-common-completion-map
996     (kbd \"C-x g\") \\='ido-enter-magit-status)
997
998 \(fn)" t nil)
999
1000 (autoload 'magit-dired-jump "magit-extras" "\
1001 Visit file at point using Dired.
1002 With a prefix argument, visit in another window.  If there
1003 is no file at point, then instead visit `default-directory'.
1004
1005 \(fn &optional OTHER-WINDOW)" t nil)
1006
1007 (autoload 'magit-dired-log "magit-extras" "\
1008 Show log for all marked files, or the current file.
1009
1010 \(fn &optional FOLLOW)" t nil)
1011
1012 (autoload 'magit-do-async-shell-command "magit-extras" "\
1013 Open FILE with `dired-do-async-shell-command'.
1014 Interactively, open the file at point.
1015
1016 \(fn FILE)" t nil)
1017
1018 (autoload 'magit-previous-line "magit-extras" "\
1019 Like `previous-line' but with Magit-specific shift-selection.
1020
1021 Magit's selection mechanism is based on the region but selects an
1022 area that is larger than the region.  This causes `previous-line'
1023 when invoked while holding the shift key to move up one line and
1024 thereby select two lines.  When invoked inside a hunk body this
1025 command does not move point on the first invocation and thereby
1026 it only selects a single line.  Which inconsistency you prefer
1027 is a matter of preference.
1028
1029 \(fn &optional ARG TRY-VSCROLL)" t nil)
1030
1031 (function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.")
1032
1033 (autoload 'magit-next-line "magit-extras" "\
1034 Like `next-line' but with Magit-specific shift-selection.
1035
1036 Magit's selection mechanism is based on the region but selects
1037 an area that is larger than the region.  This causes `next-line'
1038 when invoked while holding the shift key to move down one line
1039 and thereby select two lines.  When invoked inside a hunk body
1040 this command does not move point on the first invocation and
1041 thereby it only selects a single line.  Which inconsistency you
1042 prefer is a matter of preference.
1043
1044 \(fn &optional ARG TRY-VSCROLL)" t nil)
1045
1046 (function-put 'magit-next-line 'interactive-only 'forward-line)
1047
1048 (autoload 'magit-clean "magit-extras" "\
1049 Remove untracked files from the working tree.
1050 With a prefix argument also remove ignored files,
1051 with two prefix arguments remove ignored files only.
1052
1053 \(git clean -f -d [-x|-X])
1054
1055 \(fn &optional ARG)" t nil)
1056
1057 (autoload 'magit-add-change-log-entry "magit-extras" "\
1058 Find change log file and add date entry and item for current change.
1059 This differs from `add-change-log-entry' (which see) in that
1060 it acts on the current hunk in a Magit buffer instead of on
1061 a position in a file-visiting buffer.
1062
1063 \(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)" t nil)
1064
1065 (autoload 'magit-add-change-log-entry-other-window "magit-extras" "\
1066 Find change log file in other window and add entry and item.
1067 This differs from `add-change-log-entry-other-window' (which see)
1068 in that it acts on the current hunk in a Magit buffer instead of
1069 on a position in a file-visiting buffer.
1070
1071 \(fn &optional WHOAMI FILE-NAME)" t nil)
1072
1073 (autoload 'magit-edit-line-commit "magit-extras" "\
1074 Edit the commit that added the current line.
1075
1076 With a prefix argument edit the commit that removes the line,
1077 if any.  The commit is determined using `git blame' and made
1078 editable using `git rebase --interactive' if it is reachable
1079 from `HEAD', or by checking out the commit (or a branch that
1080 points at it) otherwise.
1081
1082 \(fn &optional TYPE)" t nil)
1083
1084 (autoload 'magit-reshelve-since "magit-extras" "\
1085 Change the author and committer dates of the commits since REV.
1086
1087 Ask the user for the first reachable commit whose dates should
1088 be changed.  The read the new date for that commit.  The initial
1089 minibuffer input and the previous history element offer good
1090 values.  The next commit will be created one minute later and so
1091 on.
1092
1093 This command is only intended for interactive use and should only
1094 be used on highly rearranged and unpublished history.
1095
1096 \(fn REV)" t nil)
1097
1098 (autoload 'magit-pop-revision-stack "magit-extras" "\
1099 Insert a representation of a revision into the current buffer.
1100
1101 Pop a revision from the `magit-revision-stack' and insert it into
1102 the current buffer according to `magit-pop-revision-stack-format'.
1103 Revisions can be put on the stack using `magit-copy-section-value'
1104 and `magit-copy-buffer-revision'.
1105
1106 If the stack is empty or with a prefix argument, instead read a
1107 revision in the minibuffer.  By using the minibuffer history this
1108 allows selecting an item which was popped earlier or to insert an
1109 arbitrary reference or revision without first pushing it onto the
1110 stack.
1111
1112 When reading the revision from the minibuffer, then it might not
1113 be possible to guess the correct repository.  When this command
1114 is called inside a repository (e.g. while composing a commit
1115 message), then that repository is used.  Otherwise (e.g. while
1116 composing an email) then the repository recorded for the top
1117 element of the stack is used (even though we insert another
1118 revision).  If not called inside a repository and with an empty
1119 stack, or with two prefix arguments, then read the repository in
1120 the minibuffer too.
1121
1122 \(fn REV TOPLEVEL)" t nil)
1123
1124 (autoload 'magit-copy-section-value "magit-extras" "\
1125 Save the value of the current section for later use.
1126
1127 Save the section value to the `kill-ring', and, provided that
1128 the current section is a commit, branch, or tag section, push
1129 the (referenced) revision to the `magit-revision-stack' for use
1130 with `magit-pop-revision-stack'.
1131
1132 When the current section is a branch or a tag, and a prefix
1133 argument is used, then save the revision at its tip to the
1134 `kill-ring' instead of the reference name.
1135
1136 When the region is active, then save that to the `kill-ring',
1137 like `kill-ring-save' would, instead of behaving as described
1138 above.
1139
1140 \(fn)" t nil)
1141
1142 (autoload 'magit-copy-buffer-revision "magit-extras" "\
1143 Save the revision of the current buffer for later use.
1144
1145 Save the revision shown in the current buffer to the `kill-ring'
1146 and push it to the `magit-revision-stack'.
1147
1148 This command is mainly intended for use in `magit-revision-mode'
1149 buffers, the only buffers where it is always unambiguous exactly
1150 which revision should be saved.
1151
1152 Most other Magit buffers usually show more than one revision, in
1153 some way or another, so this command has to select one of them,
1154 and that choice might not always be the one you think would have
1155 been the best pick.
1156
1157 In such buffers it is often more useful to save the value of
1158 the current section instead, using `magit-copy-section-value'.
1159
1160 When the region is active, then save that to the `kill-ring',
1161 like `kill-ring-save' would, instead of behaving as described
1162 above.
1163
1164 \(fn)" t nil)
1165
1166 (autoload 'magit-abort-dwim "magit-extras" "\
1167 Abort current operation.
1168 Depending on the context, this will abort a merge, a rebase, a
1169 patch application, a cherry-pick, a revert, or a bisect.
1170
1171 \(fn)" t nil)
1172
1173 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-extras" '("magit-")))
1174
1175 ;;;***
1176
1177 ;;;### (autoloads nil "magit-fetch" "magit-fetch.el" (0 0 0 0))
1178 ;;; Generated autoloads from magit-fetch.el
1179  (autoload 'magit-fetch-popup "magit-fetch" nil t)
1180
1181 (autoload 'magit-fetch-from-pushremote "magit-fetch" "\
1182 Fetch from the push-remote of the current branch.
1183
1184 \(fn ARGS)" t nil)
1185
1186 (autoload 'magit-fetch-from-upstream "magit-fetch" "\
1187 Fetch from the upstream repository of the current branch.
1188
1189 \(fn ARGS)" t nil)
1190
1191 (autoload 'magit-fetch-other "magit-fetch" "\
1192 Fetch from another repository.
1193
1194 \(fn REMOTE ARGS)" t nil)
1195
1196 (autoload 'magit-fetch-branch "magit-fetch" "\
1197 Fetch a BRANCH from a REMOTE.
1198
1199 \(fn REMOTE BRANCH ARGS)" t nil)
1200
1201 (autoload 'magit-fetch-refspec "magit-fetch" "\
1202 Fetch a REFSPEC from a REMOTE.
1203
1204 \(fn REMOTE REFSPEC ARGS)" t nil)
1205
1206 (autoload 'magit-fetch-all "magit-fetch" "\
1207 Fetch from all remotes.
1208
1209 \(fn ARGS)" t nil)
1210
1211 (autoload 'magit-fetch-all-prune "magit-fetch" "\
1212 Fetch from all remotes, and prune.
1213 Prune remote tracking branches for branches that have been
1214 removed on the respective remote.
1215
1216 \(fn)" t nil)
1217
1218 (autoload 'magit-fetch-all-no-prune "magit-fetch" "\
1219 Fetch from all remotes.
1220
1221 \(fn)" t nil)
1222
1223 (autoload 'magit-fetch-modules "magit-fetch" "\
1224 Fetch all submodules.
1225
1226 Option `magit-fetch-modules-jobs' controls how many submodules
1227 are being fetched in parallel.  Also fetch the super-repository,
1228 because `git-fetch' does not support not doing that.  With a
1229 prefix argument fetch all remotes.
1230
1231 \(fn &optional ALL)" t nil)
1232
1233 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-fetch" '("magit-")))
1234
1235 ;;;***
1236
1237 ;;;### (autoloads nil "magit-files" "magit-files.el" (0 0 0 0))
1238 ;;; Generated autoloads from magit-files.el
1239
1240 (autoload 'magit-find-file "magit-files" "\
1241 View FILE from REV.
1242 Switch to a buffer visiting blob REV:FILE,
1243 creating one if none already exists.
1244
1245 \(fn REV FILE)" t nil)
1246
1247 (autoload 'magit-find-file-other-window "magit-files" "\
1248 View FILE from REV, in another window.
1249 Like `magit-find-file', but create a new window or reuse an
1250 existing one.
1251
1252 \(fn REV FILE)" t nil)
1253  (autoload 'magit-file-popup "magit" nil t)
1254
1255 (defvar global-magit-file-mode t "\
1256 Non-nil if Global Magit-File mode is enabled.
1257 See the `global-magit-file-mode' command
1258 for a description of this minor mode.
1259 Setting this variable directly does not take effect;
1260 either customize it (see the info node `Easy Customization')
1261 or call the function `global-magit-file-mode'.")
1262
1263 (custom-autoload 'global-magit-file-mode "magit-files" nil)
1264
1265 (autoload 'global-magit-file-mode "magit-files" "\
1266 Toggle Magit-File mode in all buffers.
1267 With prefix ARG, enable Global Magit-File mode if ARG is positive;
1268 otherwise, disable it.  If called from Lisp, enable the mode if
1269 ARG is omitted or nil.
1270
1271 Magit-File mode is enabled in all buffers where
1272 `magit-file-mode-turn-on' would do it.
1273 See `magit-file-mode' for more information on Magit-File mode.
1274
1275 \(fn &optional ARG)" t nil)
1276
1277 (autoload 'magit-file-checkout "magit-files" "\
1278 Checkout FILE from REV.
1279
1280 \(fn REV FILE)" t nil)
1281
1282 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-files" '("magit-")))
1283
1284 ;;;***
1285
1286 ;;;### (autoloads nil "magit-git" "magit-git.el" (0 0 0 0))
1287 ;;; Generated autoloads from magit-git.el
1288
1289 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-git" '("magit-")))
1290
1291 ;;;***
1292
1293 ;;;### (autoloads nil "magit-gitignore" "magit-gitignore.el" (0 0
1294 ;;;;;;  0 0))
1295 ;;; Generated autoloads from magit-gitignore.el
1296  (autoload 'magit-gitignore-popup "magit-gitignore" nil t)
1297
1298 (autoload 'magit-gitignore-globally "magit-gitignore" "\
1299 Instruct Git to globally ignore FILE-OR-PATTERN.
1300
1301 \(fn FILE-OR-PATTERN)" t nil)
1302
1303 (autoload 'magit-gitignore-locally "magit-gitignore" "\
1304 Instruct Git to locally ignore FILE-OR-PATTERN.
1305
1306 \(fn FILE-OR-PATTERN)" t nil)
1307
1308 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-gitignore" '("magit-")))
1309
1310 ;;;***
1311
1312 ;;;### (autoloads nil "magit-imenu" "magit-imenu.el" (0 0 0 0))
1313 ;;; Generated autoloads from magit-imenu.el
1314
1315 (autoload 'magit-imenu--log-prev-index-position-function "magit-imenu" "\
1316 Move point to previous line in current buffer.
1317 This function is used as a value for
1318 `imenu-prev-index-position-function'.
1319
1320 \(fn)" nil nil)
1321
1322 (autoload 'magit-imenu--log-extract-index-name-function "magit-imenu" "\
1323 Return imenu name for line at point.
1324 This function is used as a value for
1325 `imenu-extract-index-name-function'.  Point should be at the
1326 beginning of the line.
1327
1328 \(fn)" nil nil)
1329
1330 (autoload 'magit-imenu--diff-prev-index-position-function "magit-imenu" "\
1331 Move point to previous file line in current buffer.
1332 This function is used as a value for
1333 `imenu-prev-index-position-function'.
1334
1335 \(fn)" nil nil)
1336
1337 (autoload 'magit-imenu--diff-extract-index-name-function "magit-imenu" "\
1338 Return imenu name for line at point.
1339 This function is used as a value for
1340 `imenu-extract-index-name-function'.  Point should be at the
1341 beginning of the line.
1342
1343 \(fn)" nil nil)
1344
1345 (autoload 'magit-imenu--status-create-index-function "magit-imenu" "\
1346 Return an alist of all imenu entries in current buffer.
1347 This function is used as a value for
1348 `imenu-create-index-function'.
1349
1350 \(fn)" nil nil)
1351
1352 (autoload 'magit-imenu--refs-create-index-function "magit-imenu" "\
1353 Return an alist of all imenu entries in current buffer.
1354 This function is used as a value for
1355 `imenu-create-index-function'.
1356
1357 \(fn)" nil nil)
1358
1359 (autoload 'magit-imenu--cherry-create-index-function "magit-imenu" "\
1360 Return an alist of all imenu entries in current buffer.
1361 This function is used as a value for
1362 `imenu-create-index-function'.
1363
1364 \(fn)" nil nil)
1365
1366 (autoload 'magit-imenu--submodule-prev-index-position-function "magit-imenu" "\
1367 Move point to previous line in magit-submodule-list buffer.
1368 This function is used as a value for
1369 `imenu-prev-index-position-function'.
1370
1371 \(fn)" nil nil)
1372
1373 (autoload 'magit-imenu--submodule-extract-index-name-function "magit-imenu" "\
1374 Return imenu name for line at point.
1375 This function is used as a value for
1376 `imenu-extract-index-name-function'.  Point should be at the
1377 beginning of the line.
1378
1379 \(fn)" nil nil)
1380
1381 (autoload 'magit-imenu--repolist-prev-index-position-function "magit-imenu" "\
1382 Move point to previous line in magit-repolist buffer.
1383 This function is used as a value for
1384 `imenu-prev-index-position-function'.
1385
1386 \(fn)" nil nil)
1387
1388 (autoload 'magit-imenu--repolist-extract-index-name-function "magit-imenu" "\
1389 Return imenu name for line at point.
1390 This function is used as a value for
1391 `imenu-extract-index-name-function'.  Point should be at the
1392 beginning of the line.
1393
1394 \(fn)" nil nil)
1395
1396 (autoload 'magit-imenu--process-prev-index-position-function "magit-imenu" "\
1397 Move point to previous process in magit-process buffer.
1398 This function is used as a value for
1399 `imenu-prev-index-position-function'.
1400
1401 \(fn)" nil nil)
1402
1403 (autoload 'magit-imenu--process-extract-index-name-function "magit-imenu" "\
1404 Return imenu name for line at point.
1405 This function is used as a value for
1406 `imenu-extract-index-name-function'.  Point should be at the
1407 beginning of the line.
1408
1409 \(fn)" nil nil)
1410
1411 (autoload 'magit-imenu--rebase-prev-index-position-function "magit-imenu" "\
1412 Move point to previous commit in git-rebase buffer.
1413 This function is used as a value for
1414 `imenu-prev-index-position-function'.
1415
1416 \(fn)" nil nil)
1417
1418 (autoload 'magit-imenu--rebase-extract-index-name-function "magit-imenu" "\
1419 Return imenu name for line at point.
1420 This function is used as a value for
1421 `imenu-extract-index-name-function'.  Point should be at the
1422 beginning of the line.
1423
1424 \(fn)" nil nil)
1425
1426 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-imenu" '("magit-imenu--index-function")))
1427
1428 ;;;***
1429
1430 ;;;### (autoloads nil "magit-log" "magit-log.el" (0 0 0 0))
1431 ;;; Generated autoloads from magit-log.el
1432
1433 (autoload 'magit-log-buffer-file-popup "magit-log" "\
1434 Popup console for log commands.
1435
1436 This is a variant of `magit-log-popup' which shows the same popup
1437 but which limits the log to the file being visited in the current
1438 buffer.
1439
1440 \(fn)" t nil)
1441
1442 (autoload 'magit-log-current "magit-log" "\
1443 Show log for the current branch.
1444 When `HEAD' is detached or with a prefix argument show log for
1445 one or more revs read from the minibuffer.
1446
1447 \(fn REVS &optional ARGS FILES)" t nil)
1448
1449 (autoload 'magit-log-other "magit-log" "\
1450 Show log for one or more revs read from the minibuffer.
1451 The user can input any revision or revisions separated by a
1452 space, or even ranges, but only branches and tags, and a
1453 representation of the commit at point, are available as
1454 completion candidates.
1455
1456 \(fn REVS &optional ARGS FILES)" t nil)
1457
1458 (autoload 'magit-log-head "magit-log" "\
1459 Show log for `HEAD'.
1460
1461 \(fn &optional ARGS FILES)" t nil)
1462
1463 (autoload 'magit-log-branches "magit-log" "\
1464 Show log for all local branches and `HEAD'.
1465
1466 \(fn &optional ARGS FILES)" t nil)
1467
1468 (autoload 'magit-log-all-branches "magit-log" "\
1469 Show log for all local and remote branches and `HEAD'.
1470
1471 \(fn &optional ARGS FILES)" t nil)
1472
1473 (autoload 'magit-log-all "magit-log" "\
1474 Show log for all references and `HEAD'.
1475
1476 \(fn &optional ARGS FILES)" t nil)
1477
1478 (autoload 'magit-log-buffer-file "magit-log" "\
1479 Show log for the blob or file visited in the current buffer.
1480 With a prefix argument or when `--follow' is part of
1481 `magit-log-arguments', then follow renames.  When the region is
1482 active, restrict the log to the lines that the region touches.
1483
1484 \(fn &optional FOLLOW BEG END)" t nil)
1485
1486 (autoload 'magit-log-trace-definition "magit-log" "\
1487 Show log for the definition at point.
1488
1489 \(fn FILE FN REV)" t nil)
1490
1491 (autoload 'magit-log-merged "magit-log" "\
1492 Show log for the merge of COMMIT into BRANCH.
1493 More precisely, find merge commit M that brought COMMIT into
1494 BRANCH, and show the log of the range \"M^..M\".  This command
1495 requires git-when-merged, which is available from
1496 https://github.com/mhagger/git-when-merged.
1497
1498 \(fn COMMIT BRANCH &optional ARGS FILES)" t nil)
1499
1500 (autoload 'magit-reflog-current "magit-log" "\
1501 Display the reflog of the current branch.
1502
1503 \(fn ARGS)" t nil)
1504
1505 (autoload 'magit-reflog-other "magit-log" "\
1506 Display the reflog of a branch or another ref.
1507
1508 \(fn REF ARGS)" t nil)
1509
1510 (autoload 'magit-reflog-head "magit-log" "\
1511 Display the `HEAD' reflog.
1512
1513 \(fn ARGS)" t nil)
1514
1515 (autoload 'magit-log-move-to-parent "magit-log" "\
1516 Move to the Nth parent of the current commit.
1517
1518 \(fn &optional N)" t nil)
1519
1520 (autoload 'magit-cherry "magit-log" "\
1521 Show commits in a branch that are not merged in the upstream branch.
1522
1523 \(fn HEAD UPSTREAM)" t nil)
1524
1525 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-log" '("magit-")))
1526
1527 ;;;***
1528
1529 ;;;### (autoloads nil "magit-margin" "magit-margin.el" (0 0 0 0))
1530 ;;; Generated autoloads from magit-margin.el
1531
1532 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-margin" '("magit-")))
1533
1534 ;;;***
1535
1536 ;;;### (autoloads nil "magit-merge" "magit-merge.el" (0 0 0 0))
1537 ;;; Generated autoloads from magit-merge.el
1538  (autoload 'magit-merge-popup "magit" nil t)
1539
1540 (autoload 'magit-merge-plain "magit-merge" "\
1541 Merge commit REV into the current branch; using default message.
1542
1543 Unless there are conflicts or a prefix argument is used create a
1544 merge commit using a generic commit message and without letting
1545 the user inspect the result.  With a prefix argument pretend the
1546 merge failed to give the user the opportunity to inspect the
1547 merge.
1548
1549 \(git merge --no-edit|--no-commit [ARGS] REV)
1550
1551 \(fn REV &optional ARGS NOCOMMIT)" t nil)
1552
1553 (autoload 'magit-merge-editmsg "magit-merge" "\
1554 Merge commit REV into the current branch; and edit message.
1555 Perform the merge and prepare a commit message but let the user
1556 edit it.
1557
1558 \(git merge --edit --no-ff [ARGS] REV)
1559
1560 \(fn REV &optional ARGS)" t nil)
1561
1562 (autoload 'magit-merge-nocommit "magit-merge" "\
1563 Merge commit REV into the current branch; pretending it failed.
1564 Pretend the merge failed to give the user the opportunity to
1565 inspect the merge and change the commit message.
1566
1567 \(git merge --no-commit --no-ff [ARGS] REV)
1568
1569 \(fn REV &optional ARGS)" t nil)
1570
1571 (autoload 'magit-merge-into "magit-merge" "\
1572 Merge the current branch into BRANCH and remove the former.
1573
1574 Before merging, force push the source branch to its push-remote,
1575 provided the respective remote branch already exists, ensuring
1576 that the respective pull-request (if any) won't get stuck on some
1577 obsolete version of the commits that are being merged.  Finally
1578 if `magit-branch-pull-request' was used to create the merged
1579 branch, then also remove the respective remote branch.
1580
1581 \(fn BRANCH &optional ARGS)" t nil)
1582
1583 (autoload 'magit-merge-absorb "magit-merge" "\
1584 Merge BRANCH into the current branch and remove the former.
1585
1586 Before merging, force push the source branch to its push-remote,
1587 provided the respective remote branch already exists, ensuring
1588 that the respective pull-request (if any) won't get stuck on some
1589 obsolete version of the commits that are being merged.  Finally
1590 if `magit-branch-pull-request' was used to create the merged
1591 branch, then also remove the respective remote branch.
1592
1593 \(fn BRANCH &optional ARGS)" t nil)
1594
1595 (autoload 'magit-merge-squash "magit-merge" "\
1596 Squash commit REV into the current branch; don't create a commit.
1597
1598 \(git merge --squash REV)
1599
1600 \(fn REV)" t nil)
1601
1602 (autoload 'magit-merge-preview "magit-merge" "\
1603 Preview result of merging REV into the current branch.
1604
1605 \(fn REV)" t nil)
1606
1607 (autoload 'magit-merge-abort "magit-merge" "\
1608 Abort the current merge operation.
1609
1610 \(git merge --abort)
1611
1612 \(fn)" t nil)
1613
1614 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-merge" '("magit-")))
1615
1616 ;;;***
1617
1618 ;;;### (autoloads nil "magit-mode" "magit-mode.el" (0 0 0 0))
1619 ;;; Generated autoloads from magit-mode.el
1620
1621 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-mode" '("magit-" "disable-magit-save-buffers" "inhibit-magit-refresh")))
1622
1623 ;;;***
1624
1625 ;;;### (autoloads nil "magit-notes" "magit-notes.el" (0 0 0 0))
1626 ;;; Generated autoloads from magit-notes.el
1627  (autoload 'magit-notes-popup "magit" nil t)
1628
1629 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-notes" '("magit-")))
1630
1631 ;;;***
1632
1633 ;;;### (autoloads nil "magit-patch" "magit-patch.el" (0 0 0 0))
1634 ;;; Generated autoloads from magit-patch.el
1635  (autoload 'magit-patch-popup "magit-patch" nil t)
1636
1637 (autoload 'magit-format-patch "magit-patch" "\
1638 Create patches for the commits in RANGE.
1639 When a single commit is given for RANGE, create a patch for the
1640 changes introduced by that commit (unlike 'git format-patch'
1641 which creates patches for all commits that are reachable from
1642 `HEAD' but not from the specified commit).
1643
1644 \(fn RANGE ARGS FILES)" t nil)
1645
1646 (autoload 'magit-request-pull "magit-patch" "\
1647 Request upstream to pull from you public repository.
1648
1649 URL is the url of your publically accessible repository.
1650 START is a commit that already is in the upstream repository.
1651 END is the last commit, usually a branch name, which upstream
1652 is asked to pull.  START has to be reachable from that commit.
1653
1654 \(fn URL START END)" t nil)
1655  (autoload 'magit-patch-apply-popup "magit-patch" nil t)
1656
1657 (autoload 'magit-patch-apply "magit-patch" "\
1658 Apply the patch file FILE.
1659
1660 \(fn FILE &rest ARGS)" t nil)
1661
1662 (autoload 'magit-patch-save "magit-patch" "\
1663 Write current diff into patch FILE.
1664
1665 What arguments are used to create the patch depends on the value
1666 of `magit-patch-save-arguments' and whether a prefix argument is
1667 used.
1668
1669 If the value is the symbol `buffer', then use the same arguments
1670 as the buffer.  With a prefix argument use no arguments.
1671
1672 If the value is a list beginning with the symbol `exclude', then
1673 use the same arguments as the buffer except for those matched by
1674 entries in the cdr of the list.  The comparison is done using
1675 `string-prefix-p'.  With a prefix argument use the same arguments
1676 as the buffer.
1677
1678 If the value is a list of strings (including the empty list),
1679 then use those arguments.  With a prefix argument use the same
1680 arguments as the buffer.
1681
1682 Of course the arguments that are required to actually show the
1683 same differences as those shown in the buffer are always used.
1684
1685 \(fn FILE &optional ARG)" t nil)
1686
1687 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-patch" '("magit-patch-save-arguments")))
1688
1689 ;;;***
1690
1691 ;;;### (autoloads nil "magit-process" "magit-process.el" (0 0 0 0))
1692 ;;; Generated autoloads from magit-process.el
1693
1694 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-process" '("magit-" "tramp-sh-handle-")))
1695
1696 ;;;***
1697
1698 ;;;### (autoloads nil "magit-pull" "magit-pull.el" (0 0 0 0))
1699 ;;; Generated autoloads from magit-pull.el
1700  (autoload 'magit-pull-popup "magit-pull" nil t)
1701  (autoload 'magit-pull-and-fetch-popup "magit-pull" nil t)
1702
1703 (autoload 'magit-pull-from-pushremote "magit-pull" "\
1704 Pull from the push-remote of the current branch.
1705
1706 \(fn ARGS)" t nil)
1707
1708 (autoload 'magit-pull-from-upstream "magit-pull" "\
1709 Pull from the upstream of the current branch.
1710
1711 \(fn ARGS)" t nil)
1712
1713 (autoload 'magit-pull-branch "magit-pull" "\
1714 Pull from a branch read in the minibuffer.
1715
1716 \(fn SOURCE ARGS)" t nil)
1717
1718 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-pull" '("magit-")))
1719
1720 ;;;***
1721
1722 ;;;### (autoloads nil "magit-push" "magit-push.el" (0 0 0 0))
1723 ;;; Generated autoloads from magit-push.el
1724  (autoload 'magit-push-popup "magit-push" nil t)
1725
1726 (autoload 'magit-push-current-to-pushremote "magit-push" "\
1727 Push the current branch to `branch.<name>.pushRemote'.
1728 If that variable is unset, then push to `remote.pushDefault'.
1729
1730 When `magit-push-current-set-remote-if-missing' is non-nil and
1731 the push-remote is not configured, then read the push-remote from
1732 the user, set it, and then push to it.  With a prefix argument
1733 the push-remote can be changed before pushed to it.
1734
1735 \(fn ARGS &optional PUSH-REMOTE)" t nil)
1736
1737 (autoload 'magit-push-current-to-upstream "magit-push" "\
1738 Push the current branch to its upstream branch.
1739
1740 When `magit-push-current-set-remote-if-missing' is non-nil and
1741 the upstream is not configured, then read the upstream from the
1742 user, set it, and then push to it.  With a prefix argument the
1743 upstream can be changed before pushed to it.
1744
1745 \(fn ARGS &optional UPSTREAM)" t nil)
1746
1747 (autoload 'magit-push-current "magit-push" "\
1748 Push the current branch to a branch read in the minibuffer.
1749
1750 \(fn TARGET ARGS)" t nil)
1751
1752 (autoload 'magit-push-other "magit-push" "\
1753 Push an arbitrary branch or commit somewhere.
1754 Both the source and the target are read in the minibuffer.
1755
1756 \(fn SOURCE TARGET ARGS)" t nil)
1757
1758 (autoload 'magit-push-refspecs "magit-push" "\
1759 Push one or multiple REFSPECS to a REMOTE.
1760 Both the REMOTE and the REFSPECS are read in the minibuffer.  To
1761 use multiple REFSPECS, separate them with commas.  Completion is
1762 only available for the part before the colon, or when no colon
1763 is used.
1764
1765 \(fn REMOTE REFSPECS ARGS)" t nil)
1766
1767 (autoload 'magit-push-matching "magit-push" "\
1768 Push all matching branches to another repository.
1769 If multiple remotes exist, then read one from the user.
1770 If just one exists, use that without requiring confirmation.
1771
1772 \(fn REMOTE &optional ARGS)" t nil)
1773
1774 (autoload 'magit-push-tags "magit-push" "\
1775 Push all tags to another repository.
1776 If only one remote exists, then push to that.  Otherwise prompt
1777 for a remote, offering the remote configured for the current
1778 branch as default.
1779
1780 \(fn REMOTE &optional ARGS)" t nil)
1781
1782 (autoload 'magit-push-tag "magit-push" "\
1783 Push a tag to another repository.
1784
1785 \(fn TAG REMOTE &optional ARGS)" t nil)
1786
1787 (autoload 'magit-push-implicitly "magit-push" "\
1788 Push somewhere without using an explicit refspec.
1789
1790 This command simply runs \"git push -v [ARGS]\".  ARGS are the
1791 arguments specified in the popup buffer.  No explicit refspec
1792 arguments are used.  Instead the behavior depends on at least
1793 these Git variables: `push.default', `remote.pushDefault',
1794 `branch.<branch>.pushRemote', `branch.<branch>.remote',
1795 `branch.<branch>.merge', and `remote.<remote>.push'.
1796
1797 To add this command to the push popup add this to your init file:
1798
1799   (with-eval-after-load \\='magit-remote
1800     (magit-define-popup-action \\='magit-push-popup ?P
1801       \\='magit-push-implicitly--desc
1802       \\='magit-push-implicitly ?p t))
1803
1804 The function `magit-push-implicitly--desc' attempts to predict
1805 what this command will do.  The value it returns is displayed in
1806 the popup buffer.
1807
1808 \(fn ARGS)" t nil)
1809
1810 (autoload 'magit-push-to-remote "magit-push" "\
1811 Push to REMOTE without using an explicit refspec.
1812 The REMOTE is read in the minibuffer.
1813
1814 This command simply runs \"git push -v [ARGS] REMOTE\".  ARGS
1815 are the arguments specified in the popup buffer.  No refspec
1816 arguments are used.  Instead the behavior depends on at least
1817 these Git variables: `push.default', `remote.pushDefault',
1818 `branch.<branch>.pushRemote', `branch.<branch>.remote',
1819 `branch.<branch>.merge', and `remote.<remote>.push'.
1820
1821 To add this command to the push popup add this to your init file:
1822
1823   (with-eval-after-load \\='magit-remote
1824     (magit-define-popup-action \\='magit-push-popup ?r
1825       \\='magit-push-to-remote--desc
1826       \\='magit-push-to-remote ?p t))
1827
1828 \(fn REMOTE ARGS)" t nil)
1829
1830 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-push" '("magit-")))
1831
1832 ;;;***
1833
1834 ;;;### (autoloads nil "magit-refs" "magit-refs.el" (0 0 0 0))
1835 ;;; Generated autoloads from magit-refs.el
1836
1837 (autoload 'magit-show-refs-popup "magit-refs" "\
1838 Popup console for `magit-show-refs'.
1839
1840 \(fn &optional ARG)" t nil)
1841
1842 (autoload 'magit-show-refs-head "magit-refs" "\
1843 List and compare references in a dedicated buffer.
1844 Refs are compared with `HEAD'.
1845
1846 \(fn &optional ARGS)" t nil)
1847
1848 (autoload 'magit-show-refs-current "magit-refs" "\
1849 List and compare references in a dedicated buffer.
1850 Refs are compared with the current branch or `HEAD' if
1851 it is detached.
1852
1853 \(fn &optional ARGS)" t nil)
1854
1855 (autoload 'magit-show-refs "magit-refs" "\
1856 List and compare references in a dedicated buffer.
1857 Refs are compared with a branch read from the user.
1858
1859 \(fn &optional REF ARGS)" t nil)
1860
1861 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-refs" '("magit-")))
1862
1863 ;;;***
1864
1865 ;;;### (autoloads nil "magit-remote" "magit-remote.el" (0 0 0 0))
1866 ;;; Generated autoloads from magit-remote.el
1867  (autoload 'magit-remote-popup "magit-remote" nil t)
1868
1869 (autoload 'magit-remote-add "magit-remote" "\
1870 Add a remote named REMOTE and fetch it.
1871
1872 \(fn REMOTE URL &optional ARGS)" t nil)
1873
1874 (autoload 'magit-remote-rename "magit-remote" "\
1875 Rename the remote named OLD to NEW.
1876
1877 \(fn OLD NEW)" t nil)
1878
1879 (autoload 'magit-remote-remove "magit-remote" "\
1880 Delete the remote named REMOTE.
1881
1882 \(fn REMOTE)" t nil)
1883
1884 (autoload 'magit-remote-prune "magit-remote" "\
1885 Remove stale remote-tracking branches for REMOTE.
1886
1887 \(fn REMOTE)" t nil)
1888
1889 (autoload 'magit-remote-prune-refspecs "magit-remote" "\
1890 Remove stale refspecs for REMOTE.
1891
1892 A refspec is stale if there no longer exists at least one branch
1893 on the remote that would be fetched due to that refspec.  A stale
1894 refspec is problematic because its existence causes Git to refuse
1895 to fetch according to the remaining non-stale refspecs.
1896
1897 If only stale refspecs remain, then offer to either delete the
1898 remote or to replace the stale refspecs with the default refspec.
1899
1900 Also remove the remote-tracking branches that were created due to
1901 the now stale refspecs.  Other stale branches are not removed.
1902
1903 \(fn REMOTE)" t nil)
1904
1905 (autoload 'magit-remote-set-head "magit-remote" "\
1906 Set the local representation of REMOTE's default branch.
1907 Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
1908 accordingly.  With a prefix argument query for the branch to be
1909 used, which allows you to select an incorrect value if you fancy
1910 doing that.
1911
1912 \(fn REMOTE &optional BRANCH)" t nil)
1913
1914 (autoload 'magit-remote-unset-head "magit-remote" "\
1915 Unset the local representation of REMOTE's default branch.
1916 Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\".
1917
1918 \(fn REMOTE)" t nil)
1919
1920 (autoload 'magit-remote-config-popup "magit-remote" "\
1921 Popup console for setting remote variables.
1922
1923 \(fn REMOTE)" t nil)
1924
1925 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-remote" '("magit-")))
1926
1927 ;;;***
1928
1929 ;;;### (autoloads nil "magit-repos" "magit-repos.el" (0 0 0 0))
1930 ;;; Generated autoloads from magit-repos.el
1931
1932 (autoload 'magit-list-repositories "magit-repos" "\
1933 Display a list of repositories.
1934
1935 Use the options `magit-repository-directories' to control which
1936 repositories are displayed.
1937
1938 \(fn)" t nil)
1939
1940 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-repos" '("magit-")))
1941
1942 ;;;***
1943
1944 ;;;### (autoloads nil "magit-reset" "magit-reset.el" (0 0 0 0))
1945 ;;; Generated autoloads from magit-reset.el
1946  (autoload 'magit-reset-popup "magit" nil t)
1947
1948 (autoload 'magit-reset-mixed "magit-reset" "\
1949 Reset the `HEAD' and index to COMMIT, but not the working tree.
1950
1951 \(git reset --mixed COMMIT)
1952
1953 \(fn COMMIT)" t nil)
1954
1955 (autoload 'magit-reset-soft "magit-reset" "\
1956 Reset the `HEAD' to COMMIT, but not the index and working tree.
1957
1958 \(git reset --soft REVISION)
1959
1960 \(fn COMMIT)" t nil)
1961
1962 (autoload 'magit-reset-hard "magit-reset" "\
1963 Reset the `HEAD', index, and working tree to COMMIT.
1964
1965 \(git reset --hard REVISION)
1966
1967 \(fn COMMIT)" t nil)
1968
1969 (autoload 'magit-reset-index "magit-reset" "\
1970 Reset the index to COMMIT.
1971 Keep the `HEAD' and working tree as-is, so if COMMIT refers to the
1972 head this effectively unstages all changes.
1973
1974 \(git reset COMMIT .)
1975
1976 \(fn COMMIT)" t nil)
1977
1978 (autoload 'magit-reset-worktree "magit-reset" "\
1979 Reset the worktree to COMMIT.
1980 Keep the `HEAD' and index as-is.
1981
1982 \(fn COMMIT)" t nil)
1983
1984 (autoload 'magit-reset-quickly "magit-reset" "\
1985 Reset the `HEAD' and index to COMMIT, and possibly the working tree.
1986 With a prefix argument reset the working tree otherwise don't.
1987
1988 \(git reset --mixed|--hard COMMIT)
1989
1990 \(fn COMMIT &optional HARD)" t nil)
1991
1992 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-reset" '("magit-reset-")))
1993
1994 ;;;***
1995
1996 ;;;### (autoloads nil "magit-section" "magit-section.el" (0 0 0 0))
1997 ;;; Generated autoloads from magit-section.el
1998
1999 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-section" '("magit-")))
2000
2001 ;;;***
2002
2003 ;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (0 0 0
2004 ;;;;;;  0))
2005 ;;; Generated autoloads from magit-sequence.el
2006
2007 (autoload 'magit-sequencer-continue "magit-sequence" "\
2008 Resume the current cherry-pick or revert sequence.
2009
2010 \(fn)" t nil)
2011
2012 (autoload 'magit-sequencer-skip "magit-sequence" "\
2013 Skip the stopped at commit during a cherry-pick or revert sequence.
2014
2015 \(fn)" t nil)
2016
2017 (autoload 'magit-sequencer-abort "magit-sequence" "\
2018 Abort the current cherry-pick or revert sequence.
2019 This discards all changes made since the sequence started.
2020
2021 \(fn)" t nil)
2022  (autoload 'magit-cherry-pick-popup "magit-sequence" nil t)
2023
2024 (autoload 'magit-cherry-copy "magit-sequence" "\
2025 Copy COMMITS from another branch onto the current branch.
2026 Prompt for a commit, defaulting to the commit at point.  If
2027 the region selects multiple commits, then pick all of them,
2028 without prompting.
2029
2030 \(fn COMMITS &optional ARGS)" t nil)
2031
2032 (autoload 'magit-cherry-apply "magit-sequence" "\
2033 Apply the changes in COMMITS but do not commit them.
2034 Prompt for a commit, defaulting to the commit at point.  If
2035 the region selects multiple commits, then apply all of them,
2036 without prompting.
2037
2038 \(fn COMMITS &optional ARGS)" t nil)
2039
2040 (autoload 'magit-cherry-harvest "magit-sequence" "\
2041 Move COMMITS from another BRANCH onto the current branch.
2042 Remove the COMMITS from BRANCH and stay on the current branch.
2043 If a conflict occurs, then you have to fix that and finish the
2044 process manually.
2045
2046 \(fn COMMITS BRANCH &optional ARGS)" t nil)
2047
2048 (autoload 'magit-cherry-donate "magit-sequence" "\
2049 Move COMMITS from the current branch onto another existing BRANCH.
2050 Remove COMMITS from the current branch and stay on that branch.
2051 If a conflict occurs, then you have to fix that and finish the
2052 process manually.
2053
2054 \(fn COMMITS BRANCH &optional ARGS)" t nil)
2055
2056 (autoload 'magit-cherry-spinout "magit-sequence" "\
2057 Move COMMITS from the current branch onto a new BRANCH.
2058 Remove COMMITS from the current branch and stay on that branch.
2059 If a conflict occurs, then you have to fix that and finish the
2060 process manually.
2061
2062 \(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
2063
2064 (autoload 'magit-cherry-spinoff "magit-sequence" "\
2065 Move COMMITS from the current branch onto a new BRANCH.
2066 Remove COMMITS from the current branch and checkout BRANCH.
2067 If a conflict occurs, then you have to fix that and finish
2068 the process manually.
2069
2070 \(fn COMMITS BRANCH START-POINT &optional ARGS)" t nil)
2071  (autoload 'magit-revert-popup "magit-sequence" nil t)
2072
2073 (autoload 'magit-revert-and-commit "magit-sequence" "\
2074 Revert COMMIT by creating a new commit.
2075 Prompt for a commit, defaulting to the commit at point.  If
2076 the region selects multiple commits, then revert all of them,
2077 without prompting.
2078
2079 \(fn COMMIT &optional ARGS)" t nil)
2080
2081 (autoload 'magit-revert-no-commit "magit-sequence" "\
2082 Revert COMMIT by applying it in reverse to the worktree.
2083 Prompt for a commit, defaulting to the commit at point.  If
2084 the region selects multiple commits, then revert all of them,
2085 without prompting.
2086
2087 \(fn COMMIT &optional ARGS)" t nil)
2088  (autoload 'magit-am-popup "magit-sequence" nil t)
2089
2090 (autoload 'magit-am-apply-patches "magit-sequence" "\
2091 Apply the patches FILES.
2092
2093 \(fn &optional FILES ARGS)" t nil)
2094
2095 (autoload 'magit-am-apply-maildir "magit-sequence" "\
2096 Apply the patches from MAILDIR.
2097
2098 \(fn &optional MAILDIR ARGS)" t nil)
2099
2100 (autoload 'magit-am-continue "magit-sequence" "\
2101 Resume the current patch applying sequence.
2102
2103 \(fn)" t nil)
2104
2105 (autoload 'magit-am-skip "magit-sequence" "\
2106 Skip the stopped at patch during a patch applying sequence.
2107
2108 \(fn)" t nil)
2109
2110 (autoload 'magit-am-abort "magit-sequence" "\
2111 Abort the current patch applying sequence.
2112 This discards all changes made since the sequence started.
2113
2114 \(fn)" t nil)
2115  (autoload 'magit-rebase-popup "magit-sequence" nil t)
2116
2117 (autoload 'magit-rebase-onto-pushremote "magit-sequence" "\
2118 Rebase the current branch onto `branch.<name>.pushRemote'.
2119 If that variable is unset, then rebase onto `remote.pushDefault'.
2120
2121 \(fn ARGS)" t nil)
2122
2123 (autoload 'magit-rebase-onto-upstream "magit-sequence" "\
2124 Rebase the current branch onto its upstream branch.
2125
2126 \(fn ARGS)" t nil)
2127
2128 (autoload 'magit-rebase-branch "magit-sequence" "\
2129 Rebase the current branch onto a branch read in the minibuffer.
2130 All commits that are reachable from `HEAD' but not from the
2131 selected branch TARGET are being rebased.
2132
2133 \(fn TARGET ARGS)" t nil)
2134
2135 (autoload 'magit-rebase-subset "magit-sequence" "\
2136 Rebase a subset of the current branch's history onto a new base.
2137 Rebase commits from START to `HEAD' onto NEWBASE.
2138 START has to be selected from a list of recent commits.
2139
2140 \(fn NEWBASE START ARGS)" t nil)
2141
2142 (autoload 'magit-rebase-interactive "magit-sequence" "\
2143 Start an interactive rebase sequence.
2144
2145 \(fn COMMIT ARGS)" t nil)
2146
2147 (autoload 'magit-rebase-autosquash "magit-sequence" "\
2148 Combine squash and fixup commits with their intended targets.
2149
2150 \(fn ARGS)" t nil)
2151
2152 (autoload 'magit-rebase-edit-commit "magit-sequence" "\
2153 Edit a single older commit using rebase.
2154
2155 \(fn COMMIT ARGS)" t nil)
2156
2157 (autoload 'magit-rebase-reword-commit "magit-sequence" "\
2158 Reword a single older commit using rebase.
2159
2160 \(fn COMMIT ARGS)" t nil)
2161
2162 (autoload 'magit-rebase-remove-commit "magit-sequence" "\
2163 Remove a single older commit using rebase.
2164
2165 \(fn COMMIT ARGS)" t nil)
2166
2167 (autoload 'magit-rebase-continue "magit-sequence" "\
2168 Restart the current rebasing operation.
2169 In some cases this pops up a commit message buffer for you do
2170 edit.  With a prefix argument the old message is reused as-is.
2171
2172 \(fn &optional NOEDIT)" t nil)
2173
2174 (autoload 'magit-rebase-skip "magit-sequence" "\
2175 Skip the current commit and restart the current rebase operation.
2176
2177 \(fn)" t nil)
2178
2179 (autoload 'magit-rebase-edit "magit-sequence" "\
2180 Edit the todo list of the current rebase operation.
2181
2182 \(fn)" t nil)
2183
2184 (autoload 'magit-rebase-abort "magit-sequence" "\
2185 Abort the current rebase operation, restoring the original branch.
2186
2187 \(fn)" t nil)
2188
2189 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-sequence" '("magit-")))
2190
2191 ;;;***
2192
2193 ;;;### (autoloads nil "magit-stash" "magit-stash.el" (0 0 0 0))
2194 ;;; Generated autoloads from magit-stash.el
2195  (autoload 'magit-stash-popup "magit-stash" nil t)
2196
2197 (autoload 'magit-stash-both "magit-stash" "\
2198 Create a stash of the index and working tree.
2199 Untracked files are included according to popup arguments.
2200 One prefix argument is equivalent to `--include-untracked'
2201 while two prefix arguments are equivalent to `--all'.
2202
2203 \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
2204
2205 (autoload 'magit-stash-index "magit-stash" "\
2206 Create a stash of the index only.
2207 Unstaged and untracked changes are not stashed.  The stashed
2208 changes are applied in reverse to both the index and the
2209 worktree.  This command can fail when the worktree is not clean.
2210 Applying the resulting stash has the inverse effect.
2211
2212 \(fn MESSAGE)" t nil)
2213
2214 (autoload 'magit-stash-worktree "magit-stash" "\
2215 Create a stash of unstaged changes in the working tree.
2216 Untracked files are included according to popup arguments.
2217 One prefix argument is equivalent to `--include-untracked'
2218 while two prefix arguments are equivalent to `--all'.
2219
2220 \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
2221
2222 (autoload 'magit-stash-keep-index "magit-stash" "\
2223 Create a stash of the index and working tree, keeping index intact.
2224 Untracked files are included according to popup arguments.
2225 One prefix argument is equivalent to `--include-untracked'
2226 while two prefix arguments are equivalent to `--all'.
2227
2228 \(fn MESSAGE &optional INCLUDE-UNTRACKED)" t nil)
2229
2230 (autoload 'magit-snapshot-both "magit-stash" "\
2231 Create a snapshot of the index and working tree.
2232 Untracked files are included according to popup arguments.
2233 One prefix argument is equivalent to `--include-untracked'
2234 while two prefix arguments are equivalent to `--all'.
2235
2236 \(fn &optional INCLUDE-UNTRACKED)" t nil)
2237
2238 (autoload 'magit-snapshot-index "magit-stash" "\
2239 Create a snapshot of the index only.
2240 Unstaged and untracked changes are not stashed.
2241
2242 \(fn)" t nil)
2243
2244 (autoload 'magit-snapshot-worktree "magit-stash" "\
2245 Create a snapshot of unstaged changes in the working tree.
2246 Untracked files are included according to popup arguments.
2247 One prefix argument is equivalent to `--include-untracked'
2248 while two prefix arguments are equivalent to `--all'.
2249
2250 \(fn &optional INCLUDE-UNTRACKED)" t nil)
2251
2252 (autoload 'magit-stash-apply "magit-stash" "\
2253 Apply a stash to the working tree.
2254 Try to preserve the stash index.  If that fails because there
2255 are staged changes, apply without preserving the stash index.
2256
2257 \(fn STASH)" t nil)
2258
2259 (autoload 'magit-stash-drop "magit-stash" "\
2260 Remove a stash from the stash list.
2261 When the region is active offer to drop all contained stashes.
2262
2263 \(fn STASH)" t nil)
2264
2265 (autoload 'magit-stash-clear "magit-stash" "\
2266 Remove all stashes saved in REF's reflog by deleting REF.
2267
2268 \(fn REF)" t nil)
2269
2270 (autoload 'magit-stash-branch "magit-stash" "\
2271 Create and checkout a new BRANCH from STASH.
2272
2273 \(fn STASH BRANCH)" t nil)
2274
2275 (autoload 'magit-stash-branch-here "magit-stash" "\
2276 Create and checkout a new BRANCH and apply STASH.
2277 The branch is created using `magit-branch', using the current
2278 branch or `HEAD' as the string-point.
2279
2280 \(fn STASH BRANCH)" t nil)
2281
2282 (autoload 'magit-stash-format-patch "magit-stash" "\
2283 Create a patch from STASH
2284
2285 \(fn STASH)" t nil)
2286
2287 (autoload 'magit-stash-list "magit-stash" "\
2288 List all stashes in a buffer.
2289
2290 \(fn)" t nil)
2291
2292 (autoload 'magit-stash-show "magit-stash" "\
2293 Show all diffs of a stash in a buffer.
2294
2295 \(fn STASH &optional ARGS FILES)" t nil)
2296
2297 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-stash" '("magit-")))
2298
2299 ;;;***
2300
2301 ;;;### (autoloads nil "magit-status" "magit-status.el" (0 0 0 0))
2302 ;;; Generated autoloads from magit-status.el
2303
2304 (autoload 'magit-init "magit-status" "\
2305 Initialize a Git repository, then show its status.
2306
2307 If the directory is below an existing repository, then the user
2308 has to confirm that a new one should be created inside.  If the
2309 directory is the root of the existing repository, then the user
2310 has to confirm that it should be reinitialized.
2311
2312 Non-interactively DIRECTORY is (re-)initialized unconditionally.
2313
2314 \(fn DIRECTORY)" t nil)
2315
2316 (autoload 'magit-status "magit-status" "\
2317 Show the status of the current Git repository in a buffer.
2318 With a prefix argument prompt for a repository to be shown.
2319 With two prefix arguments prompt for an arbitrary directory.
2320 If that directory isn't the root of an existing repository,
2321 then offer to initialize it as a new repository.
2322
2323 \(fn &optional DIRECTORY CACHE)" t nil)
2324
2325 (autoload 'magit-status-internal "magit-status" "\
2326
2327
2328 \(fn DIRECTORY)" nil nil)
2329
2330 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-status" '("magit")))
2331
2332 ;;;***
2333
2334 ;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (0 0
2335 ;;;;;;  0 0))
2336 ;;; Generated autoloads from magit-submodule.el
2337  (autoload 'magit-submodule-popup "magit-submodule" nil t)
2338
2339 (autoload 'magit-submodule-add "magit-submodule" "\
2340 Add the repository at URL as a module.
2341
2342 Optional PATH is the path to the module relative to the root of
2343 the superproject.  If it is nil, then the path is determined
2344 based on the URL.  Optional NAME is the name of the module.  If
2345 it is nil, then PATH also becomes the name.
2346
2347 \(fn URL &optional PATH NAME ARGS)" t nil)
2348
2349 (autoload 'magit-submodule-read-name-for-path "magit-submodule" "\
2350
2351
2352 \(fn PATH &optional PREFER-SHORT)" nil nil)
2353
2354 (autoload 'magit-submodule-register "magit-submodule" "\
2355 Register MODULES.
2356
2357 With a prefix argument act on all suitable modules.  Otherwise,
2358 if the region selects modules, then act on those.  Otherwise, if
2359 there is a module at point, then act on that.  Otherwise read a
2360 single module from the user.
2361
2362 \(fn MODULES)" t nil)
2363
2364 (autoload 'magit-submodule-populate "magit-submodule" "\
2365 Create MODULES working directories, checking out the recorded commits.
2366
2367 With a prefix argument act on all suitable modules.  Otherwise,
2368 if the region selects modules, then act on those.  Otherwise, if
2369 there is a module at point, then act on that.  Otherwise read a
2370 single module from the user.
2371
2372 \(fn MODULES)" t nil)
2373
2374 (autoload 'magit-submodule-update "magit-submodule" "\
2375 Update MODULES by checking out the recorded commits.
2376
2377 With a prefix argument act on all suitable modules.  Otherwise,
2378 if the region selects modules, then act on those.  Otherwise, if
2379 there is a module at point, then act on that.  Otherwise read a
2380 single module from the user.
2381
2382 \(fn MODULES ARGS)" t nil)
2383
2384 (autoload 'magit-submodule-synchronize "magit-submodule" "\
2385 Synchronize url configuration of MODULES.
2386
2387 With a prefix argument act on all suitable modules.  Otherwise,
2388 if the region selects modules, then act on those.  Otherwise, if
2389 there is a module at point, then act on that.  Otherwise read a
2390 single module from the user.
2391
2392 \(fn MODULES ARGS)" t nil)
2393
2394 (autoload 'magit-submodule-unpopulate "magit-submodule" "\
2395 Remove working directories of MODULES.
2396
2397 With a prefix argument act on all suitable modules.  Otherwise,
2398 if the region selects modules, then act on those.  Otherwise, if
2399 there is a module at point, then act on that.  Otherwise read a
2400 single module from the user.
2401
2402 \(fn MODULES ARGS)" t nil)
2403
2404 (autoload 'magit-submodule-remove "magit-submodule" "\
2405 Unregister MODULES and remove their working directories.
2406
2407 For safety reasons, do not remove the gitdirs and if a module has
2408 uncomitted changes, then do not remove it at all.  If a module's
2409 gitdir is located inside the working directory, then move it into
2410 the gitdir of the superproject first.
2411
2412 With the \"--force\" argument offer to remove dirty working
2413 directories and with a prefix argument offer to delete gitdirs.
2414 Both actions are very dangerous and have to be confirmed.  There
2415 are additional safety precautions in place, so you might be able
2416 to recover from making a mistake here, but don't count on it.
2417
2418 \(fn MODULES ARGS TRASH-GITDIRS)" t nil)
2419
2420 (autoload 'magit-insert-modules "magit-submodule" "\
2421 Insert submodule sections.
2422 Hook `magit-module-sections-hook' controls which module sections
2423 are inserted, and option `magit-module-sections-nested' controls
2424 whether they are wrapped in an additional section.
2425
2426 \(fn)" nil nil)
2427
2428 (autoload 'magit-insert-modules-overview "magit-submodule" "\
2429 Insert sections for all modules.
2430 For each section insert the path and the output of `git describe --tags',
2431 or, failing that, the abbreviated HEAD commit hash.
2432
2433 \(fn)" nil nil)
2434
2435 (autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\
2436 Insert sections for modules that haven't been pulled from the upstream.
2437 These sections can be expanded to show the respective commits.
2438
2439 \(fn)" nil nil)
2440
2441 (autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\
2442 Insert sections for modules that haven't been pulled from the push-remote.
2443 These sections can be expanded to show the respective commits.
2444
2445 \(fn)" nil nil)
2446
2447 (autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\
2448 Insert sections for modules that haven't been pushed to the upstream.
2449 These sections can be expanded to show the respective commits.
2450
2451 \(fn)" nil nil)
2452
2453 (autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\
2454 Insert sections for modules that haven't been pushed to the push-remote.
2455 These sections can be expanded to show the respective commits.
2456
2457 \(fn)" nil nil)
2458
2459 (autoload 'magit-list-submodules "magit-submodule" "\
2460 Display a list of the current repository's submodules.
2461
2462 \(fn)" t nil)
2463
2464 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-submodule" '("magit-")))
2465
2466 ;;;***
2467
2468 ;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (0 0 0 0))
2469 ;;; Generated autoloads from magit-subtree.el
2470  (autoload 'magit-subtree-popup "magit-subtree" nil t)
2471
2472 (autoload 'magit-subtree-add "magit-subtree" "\
2473 Add REF from REPOSITORY as a new subtree at PREFIX.
2474
2475 \(fn PREFIX REPOSITORY REF ARGS)" t nil)
2476
2477 (autoload 'magit-subtree-add-commit "magit-subtree" "\
2478 Add COMMIT as a new subtree at PREFIX.
2479
2480 \(fn PREFIX COMMIT ARGS)" t nil)
2481
2482 (autoload 'magit-subtree-merge "magit-subtree" "\
2483 Merge COMMIT into the PREFIX subtree.
2484
2485 \(fn PREFIX COMMIT ARGS)" t nil)
2486
2487 (autoload 'magit-subtree-pull "magit-subtree" "\
2488 Pull REF from REPOSITORY into the PREFIX subtree.
2489
2490 \(fn PREFIX REPOSITORY REF ARGS)" t nil)
2491
2492 (autoload 'magit-subtree-push "magit-subtree" "\
2493 Extract the history of the subtree PREFIX and push it to REF on REPOSITORY.
2494
2495 \(fn PREFIX REPOSITORY REF ARGS)" t nil)
2496
2497 (autoload 'magit-subtree-split "magit-subtree" "\
2498 Extract the history of the subtree PREFIX.
2499
2500 \(fn PREFIX COMMIT ARGS)" t nil)
2501
2502 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-subtree" '("magit-")))
2503
2504 ;;;***
2505
2506 ;;;### (autoloads nil "magit-tag" "magit-tag.el" (0 0 0 0))
2507 ;;; Generated autoloads from magit-tag.el
2508  (autoload 'magit-tag-popup "magit" nil t)
2509
2510 (autoload 'magit-tag-create "magit-tag" "\
2511 Create a new tag with the given NAME at REV.
2512 With a prefix argument annotate the tag.
2513
2514 \(git tag [--annotate] NAME REV)
2515
2516 \(fn NAME REV &optional ARGS)" t nil)
2517
2518 (autoload 'magit-tag-delete "magit-tag" "\
2519 Delete one or more tags.
2520 If the region marks multiple tags (and nothing else), then offer
2521 to delete those, otherwise prompt for a single tag to be deleted,
2522 defaulting to the tag at point.
2523
2524 \(git tag -d TAGS)
2525
2526 \(fn TAGS)" t nil)
2527
2528 (autoload 'magit-tag-prune "magit-tag" "\
2529 Offer to delete tags missing locally from REMOTE, and vice versa.
2530
2531 \(fn TAGS REMOTE-TAGS REMOTE)" t nil)
2532
2533 (autoload 'magit-tag-release "magit-tag" "\
2534 Create an opinionated release tag.
2535
2536 Assume version tags that match \"\\\\`v?[0-9]\\\\(\\\\.[0-9]\\\\)*\\\\'\".
2537 Prompt for the name of the new tag using the highest existing tag
2538 as initial input and call \"git tag --annotate --sign -m MSG\" TAG,
2539 regardless of whether these arguments are enabled in the popup.
2540 Given a TAG \"v1.2.3\" and a repository \"/path/to/foo-bar\", the
2541 MESSAGE would be \"Foo-Bar 1.2.3\".
2542
2543 Because it is so opinionated, this command is not available from
2544 the tag popup by default.
2545
2546 \(fn TAG)" t nil)
2547
2548 ;;;***
2549
2550 ;;;### (autoloads nil "magit-utils" "magit-utils.el" (0 0 0 0))
2551 ;;; Generated autoloads from magit-utils.el
2552
2553 (autoload 'magit-emacs-Q-command "magit-utils" "\
2554 Show a shell command that runs an uncustomized Emacs with only Magit loaded.
2555 See info node `(magit)Debugging Tools' for more information.
2556
2557 \(fn)" t nil)
2558
2559 (autoload 'Info-follow-nearest-node--magit-gitman "magit-utils" "\
2560
2561
2562 \(fn FN &optional FORK)" nil nil)
2563
2564 (advice-add 'Info-follow-nearest-node :around 'Info-follow-nearest-node--magit-gitman)
2565
2566 (autoload 'org-man-export--magit-gitman "magit-utils" "\
2567
2568
2569 \(fn FN LINK DESCRIPTION FORMAT)" nil nil)
2570
2571 (advice-add 'org-man-export :around 'org-man-export--magit-gitman)
2572
2573 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-utils" '("magit-" "whitespace-dont-turn-on-in-magit-mode")))
2574
2575 ;;;***
2576
2577 ;;;### (autoloads nil "magit-wip" "magit-wip.el" (0 0 0 0))
2578 ;;; Generated autoloads from magit-wip.el
2579
2580 (defvar magit-wip-after-save-mode nil "\
2581 Non-nil if Magit-Wip-After-Save mode is enabled.
2582 See the `magit-wip-after-save-mode' command
2583 for a description of this minor mode.
2584 Setting this variable directly does not take effect;
2585 either customize it (see the info node `Easy Customization')
2586 or call the function `magit-wip-after-save-mode'.")
2587
2588 (custom-autoload 'magit-wip-after-save-mode "magit-wip" nil)
2589
2590 (autoload 'magit-wip-after-save-mode "magit-wip" "\
2591 Toggle Magit-Wip-After-Save-Local mode in all buffers.
2592 With prefix ARG, enable Magit-Wip-After-Save mode if ARG is positive;
2593 otherwise, disable it.  If called from Lisp, enable the mode if
2594 ARG is omitted or nil.
2595
2596 Magit-Wip-After-Save-Local mode is enabled in all buffers where
2597 `magit-wip-after-save-local-mode-turn-on' would do it.
2598 See `magit-wip-after-save-local-mode' for more information on Magit-Wip-After-Save-Local mode.
2599
2600 \(fn &optional ARG)" t nil)
2601
2602 (defvar magit-wip-after-apply-mode nil "\
2603 Non-nil if Magit-Wip-After-Apply mode is enabled.
2604 See the `magit-wip-after-apply-mode' command
2605 for a description of this minor mode.")
2606
2607 (custom-autoload 'magit-wip-after-apply-mode "magit-wip" nil)
2608
2609 (autoload 'magit-wip-after-apply-mode "magit-wip" "\
2610 Commit to work-in-progress refs.
2611
2612 After applying a change using any \"apply variant\"
2613 command (apply, stage, unstage, discard, and reverse) commit the
2614 affected files to the current wip refs.  For each branch there
2615 may be two wip refs; one contains snapshots of the files as found
2616 in the worktree and the other contains snapshots of the entries
2617 in the index.
2618
2619 \(fn &optional ARG)" t nil)
2620
2621 (defvar magit-wip-before-change-mode nil "\
2622 Non-nil if Magit-Wip-Before-Change mode is enabled.
2623 See the `magit-wip-before-change-mode' command
2624 for a description of this minor mode.")
2625
2626 (custom-autoload 'magit-wip-before-change-mode "magit-wip" nil)
2627
2628 (autoload 'magit-wip-before-change-mode "magit-wip" "\
2629 Commit to work-in-progress refs before certain destructive changes.
2630
2631 Before invoking a revert command or an \"apply variant\"
2632 command (apply, stage, unstage, discard, and reverse) commit the
2633 affected tracked files to the current wip refs.  For each branch
2634 there may be two wip refs; one contains snapshots of the files
2635 as found in the worktree and the other contains snapshots of the
2636 entries in the index.
2637
2638 Only changes to files which could potentially be affected by the
2639 command which is about to be called are committed.
2640
2641 \(fn &optional ARG)" t nil)
2642
2643 (autoload 'magit-wip-commit-initial-backup "magit-wip" "\
2644 Before saving, commit current file to a worktree wip ref.
2645
2646 The user has to add this function to `before-save-hook'.
2647
2648 Commit the current state of the visited file before saving the
2649 current buffer to that file.  This backs up the same version of
2650 the file as `backup-buffer' would, but stores the backup in the
2651 worktree wip ref, which is also used by the various Magit Wip
2652 modes, instead of in a backup file as `backup-buffer' would.
2653
2654 This function ignores the variables that affect `backup-buffer'
2655 and can be used along-side that function, which is recommended
2656 because this function only backs up files that are tracked in
2657 a Git repository.
2658
2659 \(fn)" nil nil)
2660
2661 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-wip" '("magit-")))
2662
2663 ;;;***
2664
2665 ;;;### (autoloads nil "magit-worktree" "magit-worktree.el" (0 0 0
2666 ;;;;;;  0))
2667 ;;; Generated autoloads from magit-worktree.el
2668  (autoload 'magit-worktree-popup "magit-worktree" nil t)
2669
2670 (autoload 'magit-worktree-checkout "magit-worktree" "\
2671 Checkout BRANCH in a new worktree at PATH.
2672
2673 \(fn PATH BRANCH)" t nil)
2674
2675 (autoload 'magit-worktree-branch "magit-worktree" "\
2676 Create a new BRANCH and check it out in a new worktree at PATH.
2677
2678 \(fn PATH BRANCH START-POINT &optional FORCE)" t nil)
2679
2680 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "magit-worktree" '("magit-")))
2681
2682 ;;;***
2683
2684 ;;;### (autoloads nil nil ("magit-core.el" "magit-obsolete.el" "magit-pkg.el")
2685 ;;;;;;  (0 0 0 0))
2686
2687 ;;;***
2688
2689 ;; Local Variables:
2690 ;; version-control: never
2691 ;; no-byte-compile: t
2692 ;; no-update-autoloads: t
2693 ;; coding: utf-8
2694 ;; End:
2695 ;;; magit-autoloads.el ends here