.emacs.d.git - Gitblit

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.
 
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
 
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
(byte-code "\300\301!\210\302\303\304\305\306\307%\210\310\311\312\313\314DD\315\306\303\316\317\320\321&    \207" [require magit custom-declare-group magit-extras nil "Additional functionality for Magit." :group magit-extensions custom-declare-variable magit-gitk-executable funcall function #[0 "\301=\203\302\303\304\305\306$\211\205\307!\205\211\262\206#\310\311!\206#\311\207" [system-type windows-nt magit-git-string "-c" "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x" "X" "gitk.exe" file-executable-p executable-find "gitk"] 5] "The Gitk executable." :set-after (magit-git-executable) :type string] 10)
#@47 Run `git gui' for the current git repository.
(defalias 'magit-run-git-gui #[0 "\302 \211\203\211\303    \304\305\304\306%)\202\307 \207" [default-directory magit-git-executable magit-toplevel magit-process-file nil 0 "gui" magit--not-inside-repository-error] 7 (#$ . 1031) nil])
#@334 Run `git gui blame' on the given FILENAME and COMMIT.
Interactively run it for the current file and the `HEAD', with a
prefix or when the current file cannot be determined let the user
choose.  When the current buffer is visiting FILENAME instruct
blame to center around the line point is on.
 
(fn COMMIT FILENAME &optional LINENUM)
(defalias 'magit-run-git-gui-blame #[770 "\302 \211\203(\211\303\304    \305\306\305\307\310\311\n\205\312\313\f\"C  D\"&)\202*\314 \207" [default-directory magit-git-executable magit-toplevel apply magit-process-file nil 0 "gui" "blame" append format "--line=%d" magit--not-inside-repository-error] 16 (#$ . 1320) (byte-code "\302\211\204\303\262\304\302\305\"\211\262\204\306\307!\262\310\311\"\262\211\3121,\304    !0\202.\210\302\232\2054\313 E\207" [current-prefix-arg buffer-file-name nil "HEAD" magit-file-relative-name tracked magit-read-branch-or-commit "Blame from revision" magit-read-file-from-rev "Blame file" (error) line-number-at-pos] 7)])
#@39 Run `gitk' in the current repository.
(defalias 'magit-run-gitk #[0 "\301\302\303#\207" [magit-gitk-executable magit-process-file nil 0] 4 (#$ . 2334) nil])
#@50 Run `gitk --branches' in the current repository.
(defalias 'magit-run-gitk-branches #[0 "\301\302\303\302\304%\207" [magit-gitk-executable magit-process-file nil 0 "--branches"] 6 (#$ . 2498) nil])
#@45 Run `gitk --all' in the current repository.
(defalias 'magit-run-gitk-all #[0 "\301\302\303\302\304%\207" [magit-gitk-executable magit-process-file nil 0 "--all"] 6 (#$ . 2703) nil])
#@693 Drop into `magit-status' from file switching.
 
This command does not work in Emacs 26.  It does work in Emacs 25
and Emacs 27.  See https://github.com/magit/magit/issues/3634 and
https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.
 
To make this command available use something like:
 
  (add-hook \='ido-setup-hook
            (lambda ()
              (define-key ido-completion-map
                (kbd "C-x g") \='ido-enter-magit-status)))
 
Starting with Emacs 25.1 the Ido keymaps are defined just once
instead of every time Ido is invoked, so now you can modify it
like pretty much every other keymap:
 
  (define-key ido-common-completion-map
    (kbd "C-x g") \='ido-enter-magit-status)
(defalias 'ido-enter-magit-status #[0 "\301\303\211\304 \207" [ido-exit fallback ido-fallback magit-status exit-minibuffer] 3 (#$ . 2894) nil])
#@183 Visit file at point using Dired.
With a prefix argument, visit in another window.  If there
is no file at point, then instead visit `default-directory'.
 
(fn &optional OTHER-WINDOW)
(defalias 'magit-dired-jump #[256 "\300\301 \211\205\302\303!\203\304!\202!\262\"\207" [dired-jump magit-file-at-point expand-file-name file-directory-p file-name-as-directory] 7 (#$ . 3740) "P"])
#@76 Show log for all marked files, or the current file.
 
(fn &optional FOLLOW)
(defalias 'magit-dired-log #[256 "\302!\211\203F\303 @\304\305\211\306#\211\204\307\310!\210\203+\311\235\204+\211A\204+\311B\262\312\313\314 \2063\315C\316\317\")E    #\266\202\202H\320 \207" [default-directory magit-log-buffer-file-locked magit-toplevel magit-log-arguments dired-get-marked-files nil magit-file-tracked-p user-error "No marked file is being tracked by Git" "--follow" magit-mode-setup-internal magit-log-mode magit-get-current-branch "HEAD" mapcar file-relative-name magit--not-inside-repository-error] 11 (#$ . 4136) "P"])
#@98 Open FILE with `dired-do-async-shell-command'.
Interactively, open the file at point.
 
(fn FILE)
(defalias 'magit-do-async-shell-command #[257 "\301\302!\210\303\304\305C#\306C#\207" [current-prefix-arg require dired-aux dired-do-async-shell-command dired-read-shell-command "& on %s: " nil] 6 (#$ . 4776) (byte-code "\300 \206\n\301\302\303 \"C\207" [magit-file-at-point completing-read "Act on file: " magit-list-files] 3)])
(defalias 'magit--turn-on-shift-select-mode-p #[0 "\205    \205\n?\205\242\304=?\207" [shift-select-mode this-command-keys-shift-translated mark-active transient-mark-mode only] 2])
#@511 Like `previous-line' but with Magit-specific shift-selection.
 
Magit's selection mechanism is based on the region but selects an
area that is larger than the region.  This causes `previous-line'
when invoked while holding the shift key to move up one line and
thereby select two lines.  When invoked inside a hunk body this
command does not move point on the first invocation and thereby
it only selects a single line.  Which inconsistency you prefer
is a matter of preference.
 
(fn &optional ARG TRY-VSCROLL)
(defalias 'magit-previous-line #[512 "\204\300\262\301 \206\302 \211\203%\300U\203%\303 \203%\304\305\211\306#\2027\307 \210\310\2034S\300]\2025\"\207" [1 magit-diff-inside-hunk-body-p magit-section-position-in-heading-p magit--turn-on-shift-select-mode-p push-mark nil t handle-shift-selection previous-line] 7 (#$ . 5401) "p\np"])
(byte-code "\300\301\302\303#\300\207" [function-put magit-previous-line interactive-only "use `forward-line' with negative argument instead."] 4)
#@505 Like `next-line' but with Magit-specific shift-selection.
 
Magit's selection mechanism is based on the region but selects
an area that is larger than the region.  This causes `next-line'
when invoked while holding the shift key to move down one line
and thereby select two lines.  When invoked inside a hunk body
this command does not move point on the first invocation and
thereby it only selects a single line.  Which inconsistency you
prefer is a matter of preference.
 
(fn &optional ARG TRY-VSCROLL)
(defalias 'magit-next-line #[512 "\204\300\262\301 \206\302 \211\203%\300U\203%\303 \203%\304\305\211\306#\2027\307 \210\310\2034S\300]\2025\"\207" [1 magit-diff-inside-hunk-body-p magit-section-position-in-heading-p magit--turn-on-shift-select-mode-p push-mark nil t handle-shift-selection next-line] 7 (#$ . 6415) "p\np"])
(byte-code "\300\301\302\303#\300\207" [function-put magit-next-line interactive-only forward-line] 4)
#@197 Remove untracked files from the working tree.
With a prefix argument also remove ignored files,
with two prefix arguments remove ignored files only.
 
(git clean -f -d [-x|-X])
 
(fn &optional ARG)
(defalias 'magit-clean #[256 "\300\301\302\303\267\202\304\202\305\202\306\"!\205.\307 \210\310\311\312\313\314\267\202,\315\202-\316\202-\317$\207" [yes-or-no-p format "Remove %s files? " #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 9 4 13)) "untracked" "untracked and ignored" "ignored" magit-wip-commit-before-change magit-run-git "clean" "-f" "-d" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (4 36 16 40)) "-x" "-X" nil] 7 (#$ . 7371) "p"])
(put 'magit-clean 'disabled t)
#@275 Find change log file and add date entry and item for current change.
This differs from `add-change-log-entry' (which see) in that
it acts on the current hunk in a Magit buffer instead of on
a position in a file-visiting buffer.
 
(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)
(defalias 'magit-add-change-log-entry #[768 "\300\211\301 \302\303\304\305\306!\307\"\310$\216\311\312!\210p\262`\262)\210\212rq\210\211b\210\313#*\207" [nil current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 call-interactively magit-diff-visit-file add-change-log-entry] 12 (#$ . 8146) (byte-code "\301 D\207" [current-prefix-arg prompt-for-change-log-name] 2)])
#@267 Find change log file in other window and add entry and item.
This differs from `add-change-log-entry-other-window' (which see)
in that it acts on the current hunk in a Magit buffer instead of
on a position in a file-visiting buffer.
 
(fn &optional WHOAMI FILE-NAME)
(defalias 'magit-add-change-log-entry-other-window #[512 "\300\301#\207" [magit-add-change-log-entry t] 6 (#$ . 8854) (byte-code "\205\301 D\207" [current-prefix-arg prompt-for-change-log-name] 2)])
#@338 Edit the commit that added the current line.
 
With a prefix argument edit the commit that removes the line,
if any.  The commit is determined using `git blame' and made
editable using `git rebase --interactive' if it is reachable
from `HEAD', or by checking out the commit (or a branch that
points at it) otherwise.
 
(fn &optional TYPE)
(defalias 'magit-edit-line-commit #[256 "\305\206\306!\307\310\"\211\311\232\203\312\313!\202y\314\315\"\316\307\317\"\320 \"\2033\321\322\323 \"\210)\202=\324\325!\206;!\210    \205E\326    \"?\205w\n\205N\203g\327\f\330\331\332\333\334\"\335\"\336\337%\"\202u\340!\210\211\205u\341!\210\342 \262\266\202\207" [magit--rebase-published-symbol buffer-file-name magit-blame-mode magit-blame-type magit-this-process magit-current-blame-chunk addition eieio-oref orig-rev "0000000000000000000000000000000000000000" message "This line has not been committed yet" magit-rev-ancestor-p "HEAD" expand-file-name orig-file magit-toplevel edit-published magit-rebase-edit-commit magit-rebase-arguments magit-checkout magit-rev-branch file-equal-p set-process-sentinel make-byte-code 514 "\302\"\210\303!\304=\205\305\300!\210\301\205\306\301!\210\307 \207" vconcat vector [magit-sequencer-process-sentinel process-status exit find-file magit-blame--pre-blame-setup magit-blame--run] 5 "\n\n(fn PROCESS EVENT)" find-file magit-blame--pre-blame-setup magit-blame--run] 15 (#$ . 9332) (byte-code "\205\301C\207" [current-prefix-arg removal] 1)])
(put 'magit-edit-line-commit 'disabled t)
#@767 From a hunk, edit the respective commit and visit the file.
 
First visit the file being modified by the hunk at the correct
location using `magit-diff-visit-file'.  This actually visits a
blob.  When point is on a diff header, not within an individual
hunk, then this visits the blob the first hunk is about.
 
Then invoke `magit-edit-line-commit', which uses an interactive
rebase to make the commit editable, or if that is not possible
because the commit is not reachable from `HEAD' by checking out
that commit directly.  This also causes the actual worktree file
to be visited.
 
Neither the blob nor the file buffer are killed when finishing
the rebase.  If that is undesirable, then it might be better to
use `magit-rebase-edit-command' instead of this command.
(defalias 'magit-diff-edit-hunk-commit #[0 "\301\302\303 \211\203\304!\202\305\306!\262\301\307#\210)\310 \207" [magit-diff-visit-previous-blob nil magit-diff-visit-file magit-file-at-point expand-file-name user-error "No file at point" switch-to-buffer magit-edit-line-commit] 4 (#$ . 10887) nil])
(put 'magit-diff-edit-hunk-commit 'disabled t)
#@455 Change the author and committer dates of the commits since REV.
 
Ask the user for the first reachable commit whose dates should
be changed.  The read the new date for that commit.  The initial
minibuffer input and the previous history element offer good
values.  The next commit will be created one minute later and so
on.
 
This command is only intended for interactive use and should only
be used on highly rearranged and unpublished history.
 
(fn REV)
(defalias 'magit-reshelve-since #[257 "\211\204\303\304 P\305!\203\306\307\"\204\310\311!\210\210\312\313\314\"\207\315\316P\211\317\304 Q\320\321\322\323\"!!\324\"\320 \321\325\326\327#![\"B\330\320\331\332\333\300#!!!C\334 \211\203\204\211\335\336\337\340\341\342\343\344\345\346\347\350 !\351\"\352\353%\354\326\355#\356#\"    \357&\210\360\n\361\")\202\206\362 \262\262\266\204\207" [magit--reshelve-history default-directory magit-this-process "refs/original/refs/heads/" magit-get-current-branch magit-ref-p magit-y-or-n-p "Backup ref %s already exists.  Override? " user-error "Abort" magit-log-select magit-reshelve-since "Type %p on a commit to reshelve it and the commits above it," #[514 "\300\301\302\303!\304_\305!@[#\"\207" [format-time-string "%F %T %z" + floor 60 decode-time] 9 "\n\n(fn TIME OFFSET)"] "^" ".." float-time string-to-number magit-rev-format "%at" 1 magit-git-string "rev-list" "--count" floor date-to-time read-string "Date for first commit: " magit-toplevel magit-run-git-async "filter-branch" "--force" "--env-filter" format "case $GIT_COMMIT in %s\nesac" mapconcat make-byte-code 257 "\301\302\300\242\300\242$\300\211\242\303\\\240\210\207" vconcat vector [format "%s) export GIT_AUTHOR_DATE=\"%s\"; export GIT_COMMITTER_DATE=\"%s\";;" 60] 6 "\n\n(fn REV)" magit-git-lines "--reverse" " " "--" set-process-sentinel #[514 "\300!\301>\205(\302!\303V\203\304\"\207\305\306\307#\210\304\"\210\310\311\312\313\314 P#\207" [process-status (exit signal) process-exit-status 0 magit-process-sentinel process-put inhibit-refresh t magit-run-git "update-ref" "-d" "refs/original/refs/heads/" magit-get-current-branch] 7 "\n\n(fn PROCESS EVENT)"] magit--not-inside-repository-error] 21 (#$ . 12013) (list nil)])
(defvar magit-revision-stack nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&    \207" [custom-declare-variable magit-pop-revision-stack-format funcall function #[0 "\300\207" [("[%N: %h] " "%N: %H\n   %s\n" "\\[\\([0-9]+\\)[]:]")] 1] "Control how `magit-pop-revision-stack' inserts a revision.\n\nThe command `magit-pop-revision-stack' inserts a representation\nof the revision last pushed to the `magit-revision-stack' into\nthe current buffer.  It inserts text at point and/or near the end\nof the buffer, and removes the consumed revision from the stack.\n\nThe entries on the stack have the format (HASH TOPLEVEL) and this\noption has the format (POINT-FORMAT EOB-FORMAT INDEX-REGEXP), all\nof which may be nil or a string (though either one of EOB-FORMAT\nor POINT-FORMAT should be a string, and if INDEX-REGEXP is\nnon-nil, then the two formats should be too).\n\nFirst INDEX-REGEXP is used to find the previously inserted entry,\nby searching backward from point.  The first submatch must match\nthe index number.  That number is incremented by one, and becomes\nthe index number of the entry to be inserted.  If you don't want\nto number the inserted revisions, then use nil for INDEX-REGEXP.\n\nIf INDEX-REGEXP is non-nil, then both POINT-FORMAT and EOB-FORMAT\nshould contain \"%N\", which is replaced with the number that was\ndetermined in the previous step.\n\nBoth formats, if non-nil and after removing %N, are then expanded\nusing `git show --format=FORMAT ...' inside TOPLEVEL.\n\nThe expansion of POINT-FORMAT is inserted at point, and the\nexpansion of EOB-FORMAT is inserted at the end of the buffer (if\nthe buffer ends with a comment, then it is inserted right before\nthat)." :package-version (magit . "2.3.0") :group magit-commands :type (list (choice (string :tag "Insert at point format") (cons (string :tag "Insert at point format") (repeat (string :tag "Argument to git show"))) (const :tag "Don't insert at point" nil)) (choice (string :tag "Insert at eob format") (cons (string :tag "Insert at eob format") (repeat (string :tag "Argument to git show"))) (const :tag "Don't insert at eob" nil)) (choice (regexp :tag "Find index regexp") (const :tag "Don't number entries" nil)))] 10)
#@1112 Insert a representation of a revision into the current buffer.
 
Pop a revision from the `magit-revision-stack' and insert it into
the current buffer according to `magit-pop-revision-stack-format'.
Revisions can be put on the stack using `magit-copy-section-value'
and `magit-copy-buffer-revision'.
 
If the stack is empty or with a prefix argument, instead read a
revision in the minibuffer.  By using the minibuffer history this
allows selecting an item which was popped earlier or to insert an
arbitrary reference or revision without first pushing it onto the
stack.
 
When reading the revision from the minibuffer, then it might not
be possible to guess the correct repository.  When this command
is called inside a repository (e.g. while composing a commit
message), then that repository is used.  Otherwise (e.g. while
composing an email) then the repository recorded for the top
element of the stack is used (even though we insert another
revision).  If not called inside a repository and with an empty
stack, or with two prefix arguments, then read the repository in
the minibuffer too.
 
(fn REV TOPLEVEL)
(defalias 'magit-pop-revision-stack #[514 "\203\301@A\211@A\211@A    \2050\212\303\304\305#\203.\306\307\310\311!!T!\202/\312)\304\211<\203AA\262@\262<\203NA\262@\262\203l\203a\313\314\305\211%\262\315#\210\316\311!\210\205\273\203\313\314\305\211%\262\212db\210\317\320!\210\321 \210\n\203\240\322\n!\203\240\322\n!\203\254\323y\210\202\224\304y\210i\324U\204\254\325c\210\325c\210\315#\210\316\311!))\266\204\266\203\207\326\327!\207" [magit-pop-revision-stack-format default-directory comment-start re-search-backward nil t number-to-string string-to-number match-string 1 "1" replace-regexp-in-string "%N" magit-rev-insert-format backward-delete-char skip-syntax-backward ">s-" beginning-of-line looking-at -1 0 10 user-error "Revision stack is empty"] 21 (#$ . 16484) (byte-code "\204    \204&\304!\305U\204\306 \206    @A@\206\307 \310\311!\n)D\207    @@B    \211A\242\207" [current-prefix-arg magit-revision-stack default-directory magit-revision-history prefix-numeric-value 16 magit-toplevel magit-read-repository magit-read-branch-or-commit "Insert revision"] 2)])
(define-key git-commit-mode-map "" 'magit-pop-revision-stack)
#@571 Save the value of the current section for later use.
 
Save the section value to the `kill-ring', and, provided that
the current section is a commit, branch, or tag section, push
the (referenced) revision to the `magit-revision-stack' for use
with `magit-pop-revision-stack'.
 
When the current section is a branch or a tag, and a prefix
argument is used, then save the revision at its tip to the
`kill-ring' instead of the reference name.
 
When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.
(defalias 'magit-copy-section-value #[0 "\303 \203\304\305\211\306#\207\307 \211\205\310\311\"\211\205|\307 \211\203t\312\313\"\203t\305\307 \211\203=\312\314\"\203=\262\202S\211\203S\312\315\"\203S\316\317\320!\321 \"!\210\322!\262D    B\323\324\325\n\203j\206l\"!)\266\202\202z\323\324\325\"!\262\207" [default-directory magit-revision-stack current-prefix-arg use-region-p copy-region-as-kill nil region magit-current-section eieio-oref value magit-section-match-1 (branch commit module-commit tag) (branch tag) module-commit file-name-as-directory expand-file-name magit-section-parent-value magit-toplevel magit-rev-parse kill-new message "%s"] 10 (#$ . 18804) nil])
#@800 Save the revision of the current buffer for later use.
 
Save the revision shown in the current buffer to the `kill-ring'
and push it to the `magit-revision-stack'.
 
This command is mainly intended for use in `magit-revision-mode'
buffers, the only buffers where it is always unambiguous exactly
which revision should be saved.
 
Most other Magit buffers usually show more than one revision, in
some way or another, so this command has to select one of them,
and that choice might not always be the one you think would have
been the best pick.
 
In such buffers it is often more useful to save the value of
the current section instead, using `magit-copy-section-value'.
 
When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.
(defalias 'magit-copy-buffer-revision #[0 "\304 \203\305\306\211\307#\207\310>\203    @\202:\311>\2033    @@\312\313\"\203-\314\315\"\202.\211\262\202:\316=\205:\317\211\205U\320!\205U\321!\262\211\nDB\322\323\324\"!\207" [major-mode magit-refresh-args default-directory magit-revision-stack use-region-p copy-region-as-kill nil region (magit-cherry-mode magit-log-select-mode magit-reflog-mode magit-refs-mode magit-revision-mode magit-stash-mode magit-stashes-mode) (magit-diff-mode magit-log-mode) string-match "\\.\\.\\.?\\(.+\\)" match-string 1 magit-status-mode "HEAD" magit-rev-verify-commit magit-rev-parse kill-new message "%s"] 5 (#$ . 20087) nil])
#@146 Abort current operation.
Depending on the context, this will abort a merge, a rebase, a
patch application, a cherry-pick, a revert, or a bisect.
(defalias 'magit-abort-dwim #[0 "\300 \203\301 \207\302 \203\303 \207\304 \203\305 \207\306 \203 \307 \207\310 \205'\311 \207" [magit-merge-in-progress-p magit-merge-abort magit-rebase-in-progress-p magit-rebase-abort magit-am-in-progress-p magit-am-abort magit-sequencer-in-progress-p magit-sequencer-abort magit-bisect-in-progress-p magit-bisect-reset] 1 (#$ . 21570) nil])
(provide 'magit-extras)