;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\300\302!\210\300\303!\210\300\304!\207" [require cl-lib dash magit-utils magit-section] 2)
|
(defvar magit-tramp-process-environment nil)
|
(custom-declare-group 'magit-process nil "Git and other external processes used by Magit." :group 'magit)
|
#@55 Prepended to `process-environment' while running git.
|
(defvar magit-git-environment (byte-code "\301\302\"C\207" [emacs-version format "INSIDE_EMACS=%s,magit"] 3) (#$ . 676))
|
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable magit-git-output-coding-system funcall function #[0 "\301=\205 \302\207" [system-type windows-nt utf-8] 2] "Coding system for receiving output from Git.\n\nIf non-nil, the Git config value `i18n.logOutputEncoding' should\nbe set via `magit-git-global-arguments' to value consistent with\nthis." :package-version (magit . "2.9.0") :group magit-process :type (choice (coding-system :tag "Coding system to decode Git output") (const :tag "Use system default" nil))] 10)
|
#@174 Alist of (EXE . (PATHENTRY)).
|
This specifies what additional PATH setting needs to be added to
|
the environment in order to run the non-wrapper git executables
|
successfully.
|
(defvar magit-git-w32-path-hack nil (#$ . 1423))
|
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\315\316\306\317\306\307\310\320& \207" [custom-declare-variable magit-git-executable funcall function #[0 "\302=\203F \303\304!\211\205A \3051? \306\307\310\311\304%@\312 \"\313\306\307\314\315$@PC\2032 \241\210\2028 B B\266\2030\202A \210\316\262\206G \304\207" [system-type magit-git-w32-path-hack windows-nt executable-find "git" (error) process-lines "-c" "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x" "X" assoc "PATH=" "alias.P=!cygpath -wp \"$PATH\"" "P" nil] 9] "The Git executable used by Magit." :group magit-process :type string magit-git-global-arguments #[0 "\301\302\303\304\303\305\306=\205 \303\307DBBBBBB\207" [system-type "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "log.showSignature=false" windows-nt "i18n.logOutputEncoding=UTF-8"] 8] "Global Git arguments.\n\nThe arguments set here are used every time the git executable is\nrun as a subprocess. They are placed right after the executable\nitself and before the git command - as in `git HERE... COMMAND\nREST'. See the manpage `git(1)' for valid arguments.\n\nBe careful what you add here, especially if you are using Tramp\nto connect to servers with ancient Git versions. Never remove\nanything that is part of the default value, unless you really\nknow what you are doing. And think very hard before adding\nsomething; it will be used every time Magit runs Git for any\npurpose." :package-version (magit . "2.9.0") magit-git-arguments (repeat string)] 12)
|
#@719 Whether to enable additional reporting of git errors.
|
|
Magit basically calls git for one of these two reasons: for
|
side-effects or to do something with its standard output.
|
|
When git is run for side-effects then its output, including error
|
messages, go into the process buffer which is shown when using \<magit-status-mode-map>\[magit-process].
|
|
When git's output is consumed in some way, then it would be too
|
expensive to also insert it into this buffer, but when this
|
option is non-nil and git returns with a non-zero exit status,
|
then at least its standard error is inserted into this buffer.
|
|
This is only intended for debugging purposes. Do not enable this
|
permanently, that would negatively affect performance.
|
(defvar magit-git-debug nil (#$ . 3215))
|
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \210\300\314\302\303\315DD\316\306\317\310\320\312\321& \207" [custom-declare-variable magit-prefer-remote-upstream funcall function #[0 "\300\207" [nil] 1] "Whether to favor remote branches when reading the upstream branch.\n\nThis controls whether commands that read a branch from the user\nand then set it as the upstream branch, offer a local or a remote\nbranch as default completion candidate, when they have the choice.\n\nThis affects all commands that use `magit-read-upstream-branch'\nor `magit-read-starting-point', which includes all commands that\nchange the upstream and many which create new branches." :package-version (magit . "2.4.2") :group magit-commands :type boolean magit-list-refs-sortby #[0 "\300\207" [nil] 1] "How to sort the ref collection in the prompt.\n\nThis affects commands that read a ref. More specifically, it\ncontrols the order of refs returned by `magit-list-refs', which\nis called by functions like `magit-list-branch-names' to generate\nthe collection of refs. By default, refs are sorted according to\ntheir full refname (i.e., 'refs/...').\n\nAny value accepted by the `--sort' flag of `git for-each-ref' can\nbe used. For example, \"-creatordate\" places refs with more\nrecent committer or tagger dates earlier in the list. A list of\nstrings can also be given in order to pass multiple sort keys to\n`git for-each-ref'.\n\nNote that, depending on the completion framework you use, this\nmay not be sufficient to change the order in which the refs are\ndisplayed. It only controls the order of the collection passed\nto `magit-completing-read' or, for commands that support reading\nmultiple strings, `read-from-minibuffer'. The completion\nframework ultimately determines how the collection is displayed." (magit . "2.11.0") magit-miscellanous (choice string (repeat string))] 10)
|
(defvar magit--refresh-cache nil)
|
#@23
|
|
(fn KEY &rest BODY)
|
(defalias 'magit--with-refresh-cache '(macro . #[385 "\300 \301\302\303DC\304\305\306BB\307\310\303\311\312\f!DC\313\314\f\315BB\316BB\317BBB\257EBBB\207" [cl-gensym if magit--refresh-cache let --if-let assoc ((cdr magit--refresh-cache)) (progn (cl-incf (caar magit--refresh-cache)) (cdr it)) (cl-incf (cdar magit--refresh-cache)) value macroexp-progn push cons (value) ((cdr magit--refresh-cache)) (value)] 17 (#$ . 5913)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit--with-refresh-cache lisp-indent-function 1 put edebug-form-spec (form body)] 5)
|
#@199 The environment variable exported by `magit-with-editor'.
|
Set this to "GIT_SEQUENCE_EDITOR" if you do not want to use
|
Emacs to edit commit messages but would like to do so to edit
|
rebase sequences.
|
(defvar magit-with-editor-envvar "GIT_EDITOR" (#$ . 6529))
|
#@125 Like `with-editor' but let-bind some more variables.
|
Also respect the value of `magit-with-editor-envvar'.
|
|
(fn &rest BODY)
|
(defalias 'magit-with-editor '(macro . #[128 "\300\301\302\303BBE\207" [let ((magit-process-popup-time -1) (shell-file-name (if (and (eq system-type 'windows-nt) (not magit-cygwin-mount-points)) "cmdproxy" shell-file-name))) with-editor* magit-with-editor-envvar] 6 (#$ . 6793)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-editor lisp-indent-function 0 put edebug-form-spec (body)] 5)
|
#@347 Prepare ARGS for a function that invokes Git.
|
|
Magit has many specialized functions for running Git; they all
|
pass arguments through this function before handing them to Git,
|
to do the following.
|
|
* Flatten ARGS, removing nil arguments.
|
* Prepend `magit-git-global-arguments' to ARGS.
|
* On w32 systems, encode to `w32-ansi-code-page'.
|
|
(fn ARGS)
|
(defalias 'magit-process-git-arguments #[257 "\302\303!\"\262 \304=\203 \305\306!\203 \307\310\"\207\207" [magit-git-global-arguments system-type append -flatten windows-nt boundp w32-ansi-code-page mapcar #[257 "\301\302\303\304\"!\"\207" [w32-ansi-code-page encode-coding-string intern format "cp%d"] 7 "\n\n(fn ARG)"]] 5 (#$ . 7345)])
|
#@66 Execute Git with ARGS, returning its exit code.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-exit-code #[128 "\301\302\303\211\211\304!&\207" [magit-git-executable apply magit-process-file nil magit-process-git-arguments] 9 (#$ . 8043)])
|
#@76 Execute Git with ARGS, returning t if its exit code is 0.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-success #[128 "\300!\301U\207" [magit-git-exit-code 0] 3 (#$ . 8284)])
|
#@76 Execute Git with ARGS, returning t if its exit code is 1.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-failure #[128 "\300!\301U\207" [magit-git-exit-code 1] 3 (#$ . 8458)])
|
#@233 Execute Git with ARGS, returning the first line of its output.
|
If there is no output, return nil. If the output begins with a
|
newline, return an empty string. Like `magit-git-string' but
|
ignore `magit-git-debug'.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-str #[128 "\303!\262\203r B\304A\"\211\203$ \211@@@T\240\266\211A\202o \211@@AT\241\266\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317\n\320\321\320D\320\322\n!&\210o?\205] eb\210\323`\324 \"*\262B\211AB\241\266\211\262\262\207\305\306!r\211q\210\307\310\311\312\313!\325\"\315$\216\316\317\n\320\321\320D\320\322!&\210o?\205\241 eb\210\323`\324 \"*\207" [magit--refresh-cache default-directory magit-git-executable -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-process-file nil t magit-process-git-arguments buffer-substring-no-properties line-end-position [buffer-name kill-buffer]] 12 (#$ . 8633)])
|
#@63 Execute Git with ARGS, returning its output.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-output #[128 "\303!\262\203i B\304A\"\211\203$ \211@@@T\240\266\211A\202f \211@@AT\241\266\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317\n\320\321\320D\320\322\n!&\210\323ed\"*\262B\211AB\241\266\211\262\262\207\305\306!r\211q\210\307\310\311\312\313!\324\"\315$\216\316\317\n\320\321\320D\320\322!&\210\323ed\"*\207" [magit--refresh-cache default-directory magit-git-executable -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-process-file nil t magit-process-git-arguments buffer-substring-no-properties [buffer-name kill-buffer]] 12 (#$ . 9641)])
|
(define-error 'magit-invalid-git-boolean "Not a Git boolean")
|
#@171 Execute Git with ARGS, returning t if it prints "true".
|
If it prints "false", then return nil. For any other output
|
signal `magit-invalid-git-boolean'.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-true #[128 "\300!\211\301\235\203 \302\202 \211\303\235\203 \304\202 \211\305\306\"\262\207" [magit-git-output ("true\n" "true") t ("false\n" "false") nil signal magit-invalid-git-boolean] 6 (#$ . 10488)])
|
#@171 Execute Git with ARGS, returning t if it prints "false".
|
If it prints "true", then return nil. For any other output
|
signal `magit-invalid-git-boolean'.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-false #[128 "\300!\211\301\235\203 \302\202 \211\303\235\203 \304\202 \211\305\306\"\262\207" [magit-git-output ("true\n" "true") nil ("false\n" "false") t signal magit-invalid-git-boolean] 6 (#$ . 10899)])
|
#@186 Execute Git with ARGS, inserting its output at point.
|
If Git exits with a non-zero exit status, then show a message and
|
add a section in the respective process buffer.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-insert #[128 "\303!\262\203\223 \304C\305\306\307\310\311!\312\"\313$\216\211\314\315!\240\210\316\242!\210\317\320 \304\321\242D\304&\211\306V\203\216 \322\323\242!\203\210 \324\325!r\211q\210\305\306\326\310\311!\327\"\313$\216\330\242!\210db\210\331!\203e \332 !\202o \333\334\335\"\205o \336\337!*\262\262\304r\340\321!q\210\341\n \242%\210*\342\343\"\266\211\262)\207\317\320 \304\321\304D\304&\207" [magit-git-debug magit-git-executable default-directory magit-process-git-arguments nil make-byte-code 0 "\3011\n \302\300\242!0\207\210\303\207" vconcat vector [(error) delete-file nil] 2 make-temp-file "magit-stderr" delete-file apply magit-process-file t "Git failed" file-exists-p generate-new-buffer " *temp*" "\301\300!\205 \302\300!\207" [buffer-name kill-buffer] insert-file-contents functionp buffer-string run-hook-wrapped magit-process-error-message-regexps #[257 "\300\301\302#\207" [re-search-backward nil t] 5 "\n\n(fn RE)"] match-string-no-properties 1 magit-process-buffer magit-process-insert-section message "%s"] 11 (#$ . 11311)])
|
#@178 Execute Git with ARGS, returning the first line of its output.
|
If there is no output, return nil. If the output begins with a
|
newline, return an empty string.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-string #[128 "\302!\262\203h B\303A\"\211\203$ \211@@@T\240\266\211A\202e \211@@AT\241\266\304\305!r\211q\210\306\307\310\311\312!\313\"\314$\216\315\316\"\210o?\205S eb\210\317`\320 \"*\262B\211AB\241\266\211\262\262\207\304\305!r\211q\210\306\307\310\311\312!\321\"\314$\216\315\316\"\210o?\205\215 eb\210\317`\320 \"*\207" [magit--refresh-cache default-directory -flatten assoc generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert buffer-substring-no-properties line-end-position [buffer-name kill-buffer]] 10 (#$ . 12609)])
|
#@252 Execute Git with ARGS, returning its output as a list of lines.
|
Empty lines anywhere in the output are omitted.
|
|
If Git exits with a non-zero exit status, then report show a
|
message and add a section in the respective process buffer.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-lines #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311\312\"\210\313\314 \315\316#*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert split-string buffer-string "\n" t] 8 (#$ . 13459)])
|
#@258 Execute Git with ARGS, returning its null-separated output as a list.
|
Empty items anywhere in the output are omitted.
|
|
If Git exits with a non-zero exit status, then report show a
|
message and add a section in the respective process buffer.
|
|
(fn &rest ARGS)
|
(defalias 'magit-git-items #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311\312\"\210\313\314 \315\316#*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply magit-git-insert split-string buffer-string " " t] 8 (#$ . 14044)])
|
#@330 Execute Git with ARGS, inserting washed output at point.
|
Actually first insert the raw output at point. If there is no
|
output, call `magit-cancel-section'. Otherwise temporarily narrow
|
the buffer to the inserted text, move to its beginning, and then
|
call function WASHER with ARGS as its sole argument.
|
|
(fn WASHER &rest ARGS)
|
(defalias 'magit-git-wash #[385 "`\300!\262\301!\210`U\203 \302 \202; n\204 \303c\210\214\211`}\210\211b\210!\210)`U\2046 `TU\2039 \302 \210\304 \207" [-flatten magit-git-insert magit-cancel-section "\n" magit-maybe-make-margin-overlay] 5 (#$ . 14634)])
|
(byte-code "\300\301\302\303#\300\207" [function-put magit-git-wash lisp-indent-function 1] 4)
|
#@22
|
|
(fn &optional RAW)
|
(defalias 'magit-git-version #[256 "\301\3021 \303\304!\305\301O0\202 \210\301)\211\205* \203 \211\202* \306\307\"\205* \310\311\"\207" [magit-git-global-arguments nil (error) magit-git-string "version" 12 string-match "^\\([0-9]+\\.[0-9]+\\.[0-9]+\\)" match-string 1] 5 (#$ . 15328)])
|
#@12
|
|
(fn KEY)
|
(defalias 'magit-config-get-from-cached-list #[257 "\301\302\303\304\305\211%\302\306\304\305\211%\262\262\203\222 \307 \310B\311A\"\211\2034 \211@@@T\240\266\211A\202\213 \211@@AT\241\266\312\313\314\"\315\316\317\320#\211\203x \211@\321\322\"\323O\203a T\324O\202b \325\326\301 \"C\244#\266A\266\202\202G \210\211\262B\211AB\241\266\211\262\262\262\202\320 \312\313\314\"\315\316\317\320#\211\203\314 \211@\321\322\"\323O\203\265 T\324O\202\266 \325\326\301 \"C\244#\266A\266\202\202\233 \210\211\262\"\207" [magit--refresh-cache gethash replace-regexp-in-string "\\`[^.]+" downcase t "[^.]+\\'" magit-toplevel config assoc make-hash-table :test equal magit-git-items "config" "--list" "-z" cl-position 10 0 nil "" puthash] 16 (#$ . 15648)])
|
#@74 Return the value of the Git variable specified by KEYS.
|
|
(fn &rest KEYS)
|
(defalias 'magit-get #[128 "\300\301\302\"!@\207" [last apply magit-get-all] 5 (#$ . 16462)])
|
#@75 Return all values of the Git variable specified by KEYS.
|
|
(fn &rest KEYS)
|
(defalias 'magit-get-all #[128 "\302@\203 \303\304@\"\205 \211A\262\242\305\306\307# \203) \204) \310!\2020 \311\312\313\314%)\207" [magit-git-debug magit--refresh-cache nil string-prefix-p "--" mapconcat identity "." magit-config-get-from-cached-list magit-git-items "config" "-z" "--get-all"] 10 (#$ . 16636)])
|
#@82 Return the boolean value of the Git variable specified by KEYS.
|
|
(fn &rest KEYS)
|
(defalias 'magit-get-boolean #[128 "\301\302\303#\203 \304\305!!@\306\232\202 \307\310\311#\306\232\207" [magit--refresh-cache mapconcat identity "." last magit-config-get-from-cached-list "true" magit-git-str "config" "--bool"] 6 (#$ . 17042)])
|
#@86 Set the value of the Git variable specified by KEYS to VALUE.
|
|
(fn VALUE &rest KEYS)
|
(defalias 'magit-set #[385 "\211@\203 \300\301@\"\205 \211A\262\242\302\303\304#\203' \305\306$\210\202. \305\306\307$\210\207" [string-prefix-p "--" mapconcat identity "." magit-git-success "config" "--unset"] 9 (#$ . 17381)])
|
(byte-code "\300\301\302\303#\300\207" [function-put magit-get gv-expander #[385 "\300\301\302$\207" [gv--defsetter magit-get #[385 "\300BB\207" [magit-set] 5 "\n\n(fn VAL &rest KEYS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
|
#@89 Set all values of the Git variable specified by KEYS to VALUES.
|
|
(fn VALUES &rest KEYS)
|
(defalias 'magit-set-all #[385 "\211@\203 \300\301@\"\205 \211A\262\242\302\303\304#\305!\203% \306\307\310$\210\211\205< \211@\306\307\311%\210A\266\202\202& \262\207" [string-prefix-p "--" mapconcat identity "." magit-get magit-call-git "config" "--unset-all" "--add"] 12 (#$ . 17937)])
|
#@23
|
|
(fn &optional FILE)
|
(defalias 'magit--safe-default-directory #[256 "\30120 \302\303\206 !!\304\305!\204, \306\307!!\262\232\203& \310\301\304\"\210\262\202 \266\2020\207" [default-directory unsafe-default-dir file-name-as-directory expand-file-name nil magit-file-accessible-directory-p file-name-directory directory-file-name throw] 6 (#$ . 18336)])
|
#@24
|
|
(fn FILE &rest BODY)
|
(defalias 'magit--with-safe-default-directory '(macro . #[385 "\300\301\302DDCBB\207" [when-let default-directory magit--safe-default-directory] 6 (#$ . 18707)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit--with-safe-default-directory lisp-indent-function 1 put edebug-form-spec (form body)] 5)
|
#@338 Return the absolute and resolved path of the .git directory.
|
|
If the `GIT_DIR' environment variable is define then return that.
|
Otherwise return the .git directory for DIRECTORY, or if that is
|
nil, then for `default-directory' instead. If the directory is
|
not located inside a Git repository, then return nil.
|
|
(fn &optional DIRECTORY)
|
(defalias 'magit-gitdir #[256 "\211\206 \301 )\207" [default-directory magit-git-dir] 2 (#$ . 19063)])
|
#@286 Return the absolute and resolved path of the .git directory.
|
|
If the `GIT_DIR' environment variable is define then return that.
|
Otherwise return the .git directory for `default-directory'. If
|
the directory is not located inside a Git repository, then return
|
nil.
|
|
(fn &optional PATH)
|
(defalias 'magit-git-dir #[256 "\203p \302E\303A\"\211\203 \211@@@T\240\266\211A\202m \211@@AT\241\266\304\305!\211\205] \306\307!\211\205[ \310\311!!\262\312!\204M \312 !P\262\203Z \313\314!\"\202[ \211\262)B\211AB\241\266\211\262\262\207\304\305!\211\205\243 \306\307!\211\205\241 \310\311!!\262\312!\204\223 \312 !P\262\203\240 \313\314!\"\202\241 \211\262)\207" [magit--refresh-cache default-directory magit-git-dir assoc magit--safe-default-directory nil magit-rev-parse-safe "--git-dir" file-name-as-directory magit-expand-git-file-name file-remote-p expand-file-name convert-standard-filename] 10 (#$ . 19513)])
|
(defvar magit--separated-gitdirs nil)
|
(defalias 'magit--record-separated-gitdir #[0 "\301 \302 \303\304!!\203 \305!\262\306\307\310\311\312&\313\314\315\"!\232?\205. BB\211\207" [magit--separated-gitdirs magit-toplevel magit-git-dir file-symlink-p directory-file-name file-truename cl-delete :key car :test equal file-name-as-directory expand-file-name ".git"] 9])
|
#@911 Return the absolute path to the toplevel of the current repository.
|
|
From within the working tree or control directory of a repository
|
return the absolute path to the toplevel directory of the working
|
tree. As a special case, from within a bare repository return
|
the control directory instead. When called outside a repository
|
then return nil.
|
|
When optional DIRECTORY is non-nil then return the toplevel for
|
that directory instead of the one for `default-directory'.
|
|
Try to respect the option `find-file-visit-truename', i.e. when
|
the value of that option is nil, then avoid needlessly returning
|
the truename. When a symlink to a sub-directory of the working
|
tree is involved, or when called from within a sub-directory of
|
the gitdir or from the toplevel of a gitdir, which itself is not
|
located within the working tree, then it is not possible to avoid
|
returning the truename.
|
|
(fn &optional DIRECTORY)
|
(defalias 'magit-toplevel #[256 "\203\374 \211\206 \304B\305A\"\211\203# \211@@@T\240\266\211A\202\371 \211@@AT\241\266\306!\211\205\351 \307\310!\211\203\222 \311\312!\262\n\204\206 \313\314!\204\206 \315\307\316!!\262\317!\203a \320 !P\202d \321!\262\211\307\316!\322\230\205~ \307\310!\211\205| \312!\230\262)\203\206 \211\202\215 \320 !\315!P\262\202\347 \307\323!\211\205\345 \315\317!\203\252 \320 !\312!P\202\255 \321!!\262\324 \203\271 \211\202\345 \321\325\"\326!\205\306 \327!\211\203\326 \211\330\232\204\326 \331!\202\343 \332 \"@\206\343 \331\333!!\266\202\262\262)B\211AB\241\266\211\262\262\207\306!\211\205\270\307\310!\211\203a\311\312!\262\n\204U\313\314!\204U\315\307\316!!\262\317!\2030\320 !P\2023\321!\262\211\307\316!\322\230\205M\307\310!\211\205K\312!\230\262)\203U\211\202\\\320 !\315!P\262\202\266\307\323!\211\205\264\315\317!\203y\320 !\312!P\202|\321!!\262\324 \203\210\211\202\264\321\325\"\326!\205\225\327!\211\203\245\211\330\232\204\245\331!\202\262\332 \"@\206\262\331\333!!\266\202\262\262)\207" [magit--refresh-cache default-directory find-file-visit-truename magit--separated-gitdirs magit-toplevel assoc magit--safe-default-directory magit-rev-parse-safe "--show-toplevel" nil magit-expand-git-file-name getenv "GIT_WORK_TREE" file-name-as-directory "--show-cdup" file-name-absolute-p file-remote-p expand-file-name "" "--git-dir" magit-bare-repo-p "gitdir" file-exists-p magit-file-line ".git" file-name-directory rassoc directory-file-name] 11 (#$ . 20843)])
|
#@19
|
|
(fn &rest BODY)
|
(defalias 'magit-with-toplevel '(macro . #[128 "\300\301!\302\303BC\304\302\305DCBB\306BBBE\207" [cl-gensym "toplevel" let ((magit-toplevel)) if default-directory ((magit--not-inside-repository-error))] 9 (#$ . 23354)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310\311\"\210\307\312\313\"\207" [function-put magit-with-toplevel lisp-indent-function defun put edebug-form-spec (body) define-error magit-outside-git-repo "Not inside Git repository" magit-git-executable-not-found "Git executable cannot be found (see https://magit.vc/goto/e6a78ed2)"] 5)
|
(defalias 'magit--not-inside-repository-error #[0 "\302!\203 \303\304 \"\207\303\305\"\207" [magit-git-executable default-directory executable-find signal magit-outside-git-repo magit-git-executable-not-found] 3])
|
#@246 Return t if `default-directory' is below the repository directory.
|
If it is below the working directory, then return nil.
|
If it isn't below either, then signal an error unless NOERROR
|
is non-nil, in which case return nil.
|
|
(fn &optioal NOERROR)
|
(defalias 'magit-inside-gitdir-p #[514 "\301!\205! \302 \211\203 \303\"\202 \203 \304\202 \305\306\"\262\207" [default-directory magit--assert-default-directory magit-git-dir file-in-directory-p nil signal magit-outside-git-repo] 6 (#$ . 24169)])
|
#@247 Return t if `default-directory' is below the working directory.
|
If it is below the repository directory, then return nil.
|
If it isn't below either, then signal an error unless NOERROR
|
is non-nil, in which case return nil.
|
|
(fn &optional NOERROR)
|
(defalias 'magit-inside-worktree-p #[256 "\301!\205 \3021 \303\304!0\207\210\211?\205 \305\306\"\207" [default-directory magit--assert-default-directory (magit-invalid-git-boolean) magit-rev-parse-true "--is-inside-work-tree" signal magit-outside-git-repo] 4 (#$ . 24678)])
|
#@233 Return t if the current repository is bare.
|
If it is non-bare, then return nil. If `default-directory'
|
isn't below a Git repository, then signal an error unless
|
NOERROR is non-nil, in which case return nil.
|
|
(fn &optional NOERROR)
|
(defalias 'magit-bare-repo-p #[256 "\301!\205 \3021 \303\304!0\207\210\211?\205 \305\306\"\207" [default-directory magit--assert-default-directory (magit-invalid-git-boolean) magit-rev-parse-true "--is-bare-repository" signal magit-outside-git-repo] 4 (#$ . 25210)])
|
#@26
|
|
(fn &optional NOERROR)
|
(defalias 'magit--assert-default-directory #[256 "\301!\206' \211?\205' \302!\303\203 \304\202 \305\306\203! \307\202\" \310E\"\262\207" [default-directory file-directory-p file-exists-p signal file-error file-missing "Running git in directory" "Not a directory" "No such file or directory"] 7 (#$ . 25720)])
|
#@164 Return t if DIRECTORY is a Git repository.
|
When optional NON-BARE is non-nil also return nil if DIRECTORY is
|
a bare repository.
|
|
(fn DIRECTORY &optional NON-BARE)
|
(defalias 'magit-git-repo-p #[513 "\300!\2055 \301\302\303\"!\2065 \300\302\303\"!\2065 \211?\2055 \301\302\304\"!\2055 \300\302\305\"!\2055 \300\302\306\"!\207" [file-directory-p file-regular-p expand-file-name ".git" "HEAD" "refs" "objects"] 6 (#$ . 26069)])
|
(defvar magit-buffer-revision nil nil)
|
(make-variable-buffer-local 'magit-buffer-revision)
|
(defvar magit-buffer-refname nil nil)
|
(make-variable-buffer-local 'magit-buffer-refname)
|
(defvar magit-buffer-file-name nil nil)
|
(byte-code "\300\301!\210\302\303\304\305#\210\302\306\304\305#\210\302\301\304\305#\207" [make-variable-buffer-local magit-buffer-file-name put magit-buffer-revision permanent-local t magit-buffer-refname] 4)
|
#@352 Return the path of FILE relative to the repository root.
|
|
If optional FILE is nil or omitted, return the relative path of
|
the file being visited in the current buffer, if any, else nil.
|
If the file is not inside a Git repository, then return nil.
|
|
If TRACKED is non-nil, return the path only if it matches a
|
tracked file.
|
|
(fn &optional FILE TRACKED)
|
(defalias 'magit-file-relative-name #[512 "\204 r\303 \206 pq\210\206 \206 \304\305!\205 \n\262)\205B \211\203/ \306\307!!\205B \310\311\312\313!!!!\211\205@ \307\"\262\207" [magit-buffer-file-name buffer-file-name default-directory buffer-base-buffer derived-mode-p dired-mode magit-file-tracked-p file-relative-name magit-toplevel magit--safe-default-directory directory-file-name file-name-directory] 7 (#$ . 26936)])
|
#@13
|
|
(fn FILE)
|
(defalias 'magit-file-tracked-p #[257 "\300\301\302#\207" [magit-git-success "ls-files" "--error-unmatch"] 5 (#$ . 27729)])
|
#@19
|
|
(fn &rest ARGS)
|
(defalias 'magit-list-files #[128 "\300\301\302\303\304%\207" [apply magit-git-items "ls-files" "-z" "--full-name"] 7 (#$ . 27872)])
|
(defalias 'magit-tracked-files #[0 "\300\301!\207" [magit-list-files "--cached"] 2])
|
#@28
|
|
(fn &optional ALL FILES)
|
(defalias 'magit-untracked-files #[512 "\300\301?\205 \302\303$\207" [magit-list-files "--other" "--exclude-standard" "--"] 7 (#$ . 28115)])
|
#@34
|
|
(fn &optional NOMODULES FILES)
|
(defalias 'magit-unstaged-files #[512 "\300\301\302\303\205 \304\305&\207" [magit-git-items "diff-files" "-z" "--name-only" "--ignore-submodules" "--"] 9 (#$ . 28292)])
|
#@34
|
|
(fn &optional NOMODULES FILES)
|
(defalias 'magit-staged-files #[512 "\300\301\302\303\304\205 \305\306 \307&\207" [magit-git-items "diff-index" "-z" "--name-only" "--cached" "--ignore-submodules" magit-headish "--"] 11 (#$ . 28505)])
|
#@19
|
|
(fn &rest ARGS)
|
(defalias 'magit-binary-files #[128 "\300\301\302\303\300\304\305\306\307\310\n&\"\"\207" [apply append mapcar #[257 "\300\301\"\205\f \302\303\"C\207" [string-match "^- - \\(.+\\)" match-string 1] 4 "\n\n(fn IT)"] magit-git-items "diff" "-z" "--numstat" "--ignore-submodules"] 12 (#$ . 28752)])
|
(defalias 'magit-unmerged-files #[0 "\300\301\302\303\304$\207" [magit-git-items "diff-files" "-z" "--name-only" "--diff-filter=U"] 5])
|
(defalias 'magit-ignored-files #[0 "\300\301\302\303\304\305\306&\207" [magit-git-items "ls-files" "-z" "--others" "--ignored" "--exclude-standard" "--directory"] 7])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-revision-files #[257 "\301 \211\203 \211\302\303\304\305\306%)\202 \307 \207" [default-directory magit-toplevel magit-git-items "ls-tree" "-z" "-r" "--name-only" magit--not-inside-repository-error] 8 (#$ . 29380)])
|
#@292 Return list of files the have changed between two revisions.
|
If OTHER-REV is non-nil, REV-OR-RANGE should be a revision, not a
|
range. Otherwise, it can be any revision or range accepted by
|
"git diff" (i.e., <rev>, <revA>..<revB>, or <revA>...<revB>).
|
|
(fn REV-OR-RANGE &optional OTHER-REV)
|
(defalias 'magit-changed-files #[513 "\301 \211\203 \211\302\303\304\305%)\202 \306 \207" [default-directory magit-toplevel magit-git-items "diff" "-z" "--name-only" magit--not-inside-repository-error] 9 (#$ . 29635)])
|
#@18
|
|
(fn REVA REVB)
|
(defalias 'magit-renamed-files #[514 "\300\301\302\303\304\305\306\307\310\311 &\"\"\207" [mapcar #[257 "\211A@\3008B\207" [2] 4 "\n\n(fn IT)"] -partition 3 magit-git-items "diff-tree" "-r" "--diff-filter=R" "-z" "-M"] 14 (#$ . 30158)])
|
#@19
|
|
(fn &rest ARGS)
|
(defalias 'magit-file-status #[128 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\212\311\312\313#\210)`\314\315\314w\303V\203a fTf\316\\`{\314u\210\317>\203P `\262\315\314w\210\211`{FB\262\314u\210\202Y \211\314FB\262\266`\262\202 \262*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 magit-git-insert "status" "-z" nil "[:print:]" 3 (82 67)] 11 (#$ . 30423)])
|
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable magit-cygwin-mount-points funcall function #[0 "\305=\2056 \306\307\310\311 \n\"\312\313 \314\"@\315\316 \317#)\266\203?\2050 \3201. \313\321!0\2020 \210\315)\"\322\323\324$\207" [system-type magit-git-environment process-environment magit-git-executable inhibit-changing-match-data windows-nt cl-sort mapcar #[257 "\300\301\"\203 \302\303\304\"!\302\303\305\"!B\207\306\307\310\311$\207" [string-match "^\\(.*\\) on \\(.*\\) type" file-name-as-directory match-string 2 1 lwarn (magit) :error "Failed to parse Cygwin mount: %S"] 6 "\n\n(fn IT)"] append "\\`[a-zA-Z]:" process-lines "--exec-path" nil t string-match (error) "mount" > :key #[257 "\211@A\211\211G\266\202\207" [] 6 "\n\n(fn ARG0)"]] 10] "Alist of (CYGWIN . WIN32) directory names.\nSorted from longest to shortest CYGWIN name." :package-version (magit . "2.3.0") :group magit-process :type (alist :key-type string :value-type directory)] 10)
|
#@17
|
|
(fn FILENAME)
|
(defalias 'magit-expand-git-file-name #[257 "\301!\204 \302!\262\303\304\305$\211\203: \211A\262\242\211\2034 \211\203. \211G\306OP\202/ \262\2025 \262\202; \207" [magit-cygwin-mount-points file-name-absolute-p expand-file-name cl-assoc :test #[514 "\300\"\207" [string-prefix-p] 5 "\n\n(fn F CYG)"] nil] 8 (#$ . 31931)])
|
#@192 Convert FILENAME so that it can be passed to git.
|
1. If it's a remote filename, then remove the remote part.
|
2. Deal with an `windows-nt' Emacs vs. Cygwin Git incompatibility.
|
|
(fn FILENAME)
|
(defalias 'magit-convert-filename-for-git #[257 "\301!\203L \302\303\304$\211\203C \211A\262\242\211\2036 \211\203) G\305OP\2021 \306\307\"\2061 \262\202> \306\307\"\206> \262\202K \306\307\"\206K \207\207" [magit-cygwin-mount-points file-name-absolute-p cl-rassoc :test #[514 "\300\"\207" [string-prefix-p] 5 "\n\n(fn F WIN)"] nil file-remote-p localname] 8 (#$ . 32294)])
|
#@13
|
|
(fn PATH)
|
(defalias 'magit-decode-git-path #[257 "\211\302H\303=\203 \304\305!\206 @\306#\207\207" [magit-git-output-coding-system default-process-coding-system 0 34 decode-coding-string read t] 5 (#$ . 32884)])
|
(defalias 'magit-file-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\"\202\" \211\205\" \301\305\"\205\" \306!\207" [magit-current-section magit-section-match-1 file eieio-oref value hunk magit-section-parent-value] 4])
|
(defalias 'magit-current-file #[0 "\301 \206 \302 \206 \303\304!\205 \3058@\207" [magit-refresh-args magit-file-relative-name magit-file-at-point derived-mode-p magit-log-mode 2] 2])
|
#@63 Return t if there is no commit in the current Git repository.
|
(defalias 'magit-no-commit-p #[0 "\300\301!?\207" [magit-rev-verify "HEAD"] 2 (#$ . 33527)])
|
#@52 Return t if COMMIT is a merge commit.
|
|
(fn COMMIT)
|
(defalias 'magit-merge-commit-p #[257 "\300!G\301V\207" [magit-commit-parents 1] 3 (#$ . 33688)])
|
#@168 Return t if there are any staged changes.
|
If optional FILES is non-nil, then only changes to those files
|
are considered.
|
|
(fn &optional IGNORE-SUBMODULES &rest FILES)
|
(defalias 'magit-anything-staged-p #[384 "\300\301\302\303\205 \304\305&\207" [magit-git-failure "diff" "--quiet" "--cached" "--ignore-submodules" "--"] 9 (#$ . 33845)])
|
#@170 Return t if there are any unstaged changes.
|
If optional FILES is non-nil, then only changes to those files
|
are considered.
|
|
(fn &optional IGNORE-SUBMODULES &rest FILES)
|
(defalias 'magit-anything-unstaged-p #[384 "\300\301\302\205 \303\304%\207" [magit-git-failure "diff" "--quiet" "--ignore-submodules" "--"] 8 (#$ . 34194)])
|
#@180 Return t if there are any staged or unstaged changes.
|
If optional FILES is non-nil, then only changes to those files
|
are considered.
|
|
(fn &optional IGNORE-SUBMODULES &rest FILES)
|
(defalias 'magit-anything-modified-p #[384 "\300\301#\206 \300\302#\207" [apply magit-anything-staged-p magit-anything-unstaged-p] 6 (#$ . 34530)])
|
#@143 Return t if there are any merge conflicts.
|
If optional FILES is non-nil, then only conflicts in those files
|
are considered.
|
|
(fn &rest FILES)
|
(defalias 'magit-anything-unmerged-p #[128 "\300\301\302#\205 \303\207" [magit-git-string "ls-files" "--unmerged" t] 5 (#$ . 34869)])
|
#@15
|
|
(fn MODULE)
|
(defalias 'magit-module-worktree-p #[257 "\301 \211\203 \211\302\303\211\304\"!!)\202 \305 \207" [default-directory magit-toplevel file-exists-p expand-file-name ".git" magit--not-inside-repository-error] 7 (#$ . 35153)])
|
#@15
|
|
(fn MODULE)
|
(defalias 'magit-module-no-worktree-p #[257 "\300!?\207" [magit-module-worktree-p] 3 (#$ . 35399)])
|
(defalias 'magit-ignore-submodules-p #[0 "\301\302\"\207" [magit-diff-section-arguments cl-find-if #[257 "\300\301\"\207" [string-prefix-p "--ignore-submodules"] 4 "\n\n(fn ARG)"]] 3])
|
#@115 Execute `git rev-parse ARGS', returning first line of output.
|
If there is no output, return nil.
|
|
(fn &rest ARGS)
|
(defalias 'magit-rev-parse #[128 "\300\301\302#\207" [apply magit-git-string "rev-parse"] 5 (#$ . 35708)])
|
#@169 Execute `git rev-parse ARGS', returning first line of output.
|
If there is no output, return nil. Like `magit-rev-parse' but
|
ignore `magit-git-debug'.
|
|
(fn &rest ARGS)
|
(defalias 'magit-rev-parse-safe #[128 "\300\301\302#\207" [apply magit-git-str "rev-parse"] 5 (#$ . 35937)])
|
#@159 Execute `git rev-parse ARGS', returning t if it prints "true".
|
If it prints "false", then return nil. For any other output
|
signal an error.
|
|
(fn &rest ARGS)
|
(defalias 'magit-rev-parse-true #[128 "\300\301\"\207" [magit-git-true "rev-parse"] 4 (#$ . 36222)])
|
#@159 Execute `git rev-parse ARGS', returning t if it prints "false".
|
If it prints "true", then return nil. For any other output
|
signal an error.
|
|
(fn &rest ARGS)
|
(defalias 'magit-rev-parse-false #[128 "\300\301\"\207" [magit-git-false "rev-parse"] 4 (#$ . 36489)])
|
#@178 Execute `git rev-parse ARGS', returning t if it prints "true".
|
Return t if the first (and usually only) output line is the
|
string "true", otherwise return nil.
|
|
(fn &rest ARGS)
|
(defalias 'magit-rev-parse-p #[128 "\300\301\"\302\232\207" [magit-git-str "rev-parse" "true"] 4 (#$ . 36758)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-rev-verify #[257 "\300\301\"\207" [magit-rev-parse-safe "--verify"] 4 (#$ . 37054)])
|
#@68 Return full hash for REV if it names an existing commit.
|
|
(fn REV)
|
(defalias 'magit-rev-verify-commit #[257 "\300\301P!\207" [magit-rev-verify "^{commit}"] 4 (#$ . 37174)])
|
#@12
|
|
(fn A B)
|
(defalias 'magit-rev-equal #[514 "\300\301\302$\207" [magit-git-success "diff" "--quiet"] 7 (#$ . 37354)])
|
#@12
|
|
(fn A B)
|
(defalias 'magit-rev-eq #[514 "\300!\300!\205 \211\205 \232\207" [magit-rev-verify] 6 (#$ . 37480)])
|
#@66 Return non-nil if commit A is an ancestor of commit B.
|
|
(fn A B)
|
(defalias 'magit-rev-ancestor-p #[514 "\300\301\302$\207" [magit-git-success "merge-base" "--is-ancestor"] 7 (#$ . 37605)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-rev-head-p #[257 "\211\301\232\206\" \211\205\" \302\303\304\305#)\266\203?\205\" \306!\306\301!\232\207" [inhibit-changing-match-data "HEAD" "\\.\\." nil t string-match magit-rev-parse] 8 (#$ . 37802)])
|
#@185 Return t if the user is the author of REV.
|
More precisely return t if `user.name' is equal to the author
|
name of REV and/or `user.email' is equal to the author email
|
of REV.
|
|
(fn REV)
|
(defalias 'magit-rev-author-p #[257 "\300\301!\302\303\"\232\206 \300\304!\302\305\"\232\207" [magit-get "user.name" magit-rev-format "%an" "user.email" "%ae"] 5 (#$ . 38047)])
|
#@362 Return a symbolic name for REV.
|
PATTERN is passed to the `--refs' flag of `git-name-rev' and can
|
be used to limit the result to a matching ref. When structured
|
as "refs/<subdir>/*", PATTERN is taken as a namespace. In this
|
case, the name returned by `git-name-rev' is discarded if it
|
corresponds to a ref outside of the namespace.
|
|
(fn REV &optional PATTERN)
|
(defalias 'magit-rev-name #[513 "\301\302\303\304\205 \305P%\211\205K \203J \306\307\310\311#)\266\203\203J \312\313O\211\307\310\311#)\266\203\205@ \314P!??\205E \262\202K \211\207" [inhibit-changing-match-data magit-git-string "name-rev" "--name-only" "--no-undefined" "--refs=" "\\`refs/[^/]+/\\*\\'" nil t string-match 0 -1 magit-rev-verify] 11 (#$ . 38418)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-rev-branch #[257 "\301\302\"\211\205 \303\304\305\306#)\266\203?\205 \211\207" [inhibit-changing-match-data magit-rev-name "refs/heads/*" "[~^]" nil t string-match] 9 (#$ . 39170)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-get-shortname #[257 "\300\301\"\211\302!\206 \211\303!\206 \211\304!\211\204 \305\306\"\202< \307\310\"\2039 \311\312\313\"!\2032 \211\202< \312\313\"\202< \314!\207" [apply-partially magit-rev-name "refs/tags/*" "refs/heads/*" "refs/remotes/*" magit-rev-parse "--short" string-match "^\\(?:tags\\|remotes\\)/\\(.+\\)" magit-ref-ambiguous-p match-string 1 magit-ref-maybe-qualify] 7 (#$ . 39394)])
|
#@26
|
|
(fn REV &optional LAX)
|
(defalias 'magit-name-branch #[513 "\300!\206 \301!\206 \211\205 \300\302\"\206 \301\302\"\207" [magit-name-local-branch magit-name-remote-branch t] 5 (#$ . 39835)])
|
#@26
|
|
(fn REV &optional LAX)
|
(defalias 'magit-name-local-branch #[513 "\301\302\"\211\205 \204 \303\304\305\306#)\266\203?\205 \211\207" [inhibit-changing-match-data magit-rev-name "refs/heads/*" "[~^]" nil t string-match] 10 (#$ . 40040)])
|
#@26
|
|
(fn REV &optional LAX)
|
(defalias 'magit-name-remote-branch #[513 "\301\302\"\211\205! \204 \303\304\305\306#)\266\203?\205! \211\307\304O\207" [inhibit-changing-match-data magit-rev-name "refs/remotes/*" "[~^]" nil t string-match 8] 10 (#$ . 40293)])
|
#@26
|
|
(fn REV &optional LAX)
|
(defalias 'magit-name-tag #[513 "\301\302\"\211\205! \204 \303\304\305\306#)\266\203?\205! \211\307\304O\207" [inhibit-changing-match-data magit-rev-name "refs/tags/*" "[~^]" nil t string-match 5] 10 (#$ . 40560)])
|
#@139 Return fully qualified refname for NAME.
|
If NAME is ambiguous, return nil. NAME may include suffixes such
|
as "^1" and "~3".
|
|
(fn NAME)
|
(defalias 'magit-ref-fullname #[257 "\300 \301\302\303\304\305!\306\"\307$\216\310\311\"\203+ \312\313\314\315\"\"\211\205& \211\314\316\"P\262\202. \317\320!)\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "\\`\\([^^~]+\\)\\(.*\\)" magit-rev-parse "--symbolic-full-name" match-string 1 2 error "`name' has an unrecognized format"] 8 (#$ . 40815)])
|
#@13
|
|
(fn NAME)
|
(defalias 'magit-ref-ambiguous-p #[257 "\300!?\207" [magit-ref-fullname] 3 (#$ . 41378)])
|
#@84 If NAME is ambiguous, prepend PREFIX to it.
|
|
(fn NAME &optional (PREFIX "heads/"))
|
(defalias 'magit-ref-maybe-qualify #[385 "\211\203 \211A\262\242\202 \300\203 \301\302\303\304G\\D\"\210\305!\205# \211P\207" ["heads/" signal wrong-number-of-arguments magit-ref-maybe-qualify 2 magit-ref-ambiguous-p] 8 (#$ . 41487)])
|
#@12
|
|
(fn REF)
|
(defalias 'magit-ref-exists-p #[257 "\300\301\302#\207" [magit-git-success "show-ref" "--verify"] 5 (#$ . 41820)])
|
#@165 Return t if the refs A and B are `equal'.
|
A symbolic-ref pointing to some ref, is `equal' to that ref,
|
as are two symbolic-refs pointing to the same ref.
|
|
(fn A B)
|
(defalias 'magit-ref-equal #[514 "\300!\300!\232\207" [magit-ref-fullname] 5 (#$ . 41954)])
|
#@176 Return t if the refs A and B are `eq'.
|
A symbolic-ref is `eq' to itself, but not to the ref it points
|
to, or to some other symbolic-ref that points to the same ref.
|
|
(fn A B)
|
(defalias 'magit-ref-eq #[514 "\300!\300!\203 \211\203 \232\206\" ?\205\" \211?\205\" \301\"\207" [magit-symbolic-ref-p magit-ref-equal] 7 (#$ . 42219)])
|
#@68 Return "HEAD" or if that doesn't exist the hash of the empty tree.
|
(defalias 'magit-headish #[0 "\300 \203 \301\302!\207\303\207" [magit-no-commit-p magit-git-string "mktree" "HEAD"] 2 (#$ . 42564)])
|
(defalias 'magit-branch-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\"\202* \211\205* \301\305\"\205* \306 \206* \307\303\304\"!\207" [magit-current-section magit-section-match-1 branch eieio-oref value commit magit--painted-branch-at-point magit-name-branch] 5])
|
#@23
|
|
(fn &optional TYPE)
|
(defalias 'magit--painted-branch-at-point #[256 "\211\300=\204 \301`\302\"\303\304D>\203 \305\306\307\310\"!A\2061 \211\311=?\2051 \301`\302\"\312\313D>\2051 \306\307\310\"\207" [remote get-text-property face magit-branch-local magit-branch-current magit-split-branch-name thing-at-point git-revision t local magit-branch-remote magit-branch-remote-head] 5 (#$ . 43048)])
|
(defalias 'magit-local-branch-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\305\"!\211\306 \235\205 \211\262\2027 \211\2057 \301\307\"\2057 \310\311!\2067 \312\304\305\"!\207" [magit-current-section magit-section-match-1 branch magit-ref-maybe-qualify eieio-oref value magit-list-local-branch-names commit magit--painted-branch-at-point local magit-name-local-branch] 5])
|
(defalias 'magit-remote-branch-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\"\211\305 \235\205 \211\262\2025 \211\2055 \301\306\"\2055 \307\310!\2065 \311\303\304\"!\207" [magit-current-section magit-section-match-1 branch eieio-oref value magit-list-remote-branch-names commit magit--painted-branch-at-point remote magit-name-remote-branch] 5])
|
(defalias 'magit-commit-at-point #[0 "\301\302!\206 \303\304!\205 @\207" [magit-refresh-args magit-section-value-if commit derived-mode-p magit-revision-mode] 2])
|
(defalias 'magit-branch-or-commit-at-point #[0 "\206g \302 \211\203 \303\304\"\203 \305\306\307\"!\202R \211\203@ \303\310\"\203@ \311 \206R \306\307\"\312!\206; \313!\206; \211\262\202R \211\205R \303\314\"\205R \305\306\307\"\315\"\262\206g \316\317\320\"\206g \321\322\323\"\205g @\207" [magit-buffer-refname magit-refresh-args magit-current-section magit-section-match-1 branch magit-ref-maybe-qualify eieio-oref value commit magit--painted-branch-at-point magit-name-branch magit-get-shortname tag "tags/" thing-at-point git-revision t derived-mode-p magit-revision-mode magit-merge-preview-mode] 5])
|
(defalias 'magit-tag-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\"\202% \211\205% \301\305\"\205% \306\303\304\"!\207" [magit-current-section magit-section-match-1 tag eieio-oref value commit magit-name-tag] 5])
|
(defalias 'magit-stash-at-point #[0 "\300\301!\207" [magit-section-value-if stash] 2])
|
(defalias 'magit-remote-at-point #[0 "\300 \211\203 \301\302\"\203 \303\304\"\202\" \211\205\" \301\305\"\205\" \306!\207" [magit-current-section magit-section-match-1 remote eieio-oref value branch magit-section-parent-value] 4])
|
#@28
|
|
(fn &optional PREDICATE)
|
(defalias 'magit-module-at-point #[256 "\300\301!\205 \302\303 \304\"\203 !\205 \211\262\207" [magit-section-match magit-module-section eieio-oref magit-current-section value] 4 (#$ . 45533)])
|
#@107 Return the refname of the currently checked out branch.
|
Return nil if no branch is currently checked out.
|
(defalias 'magit-get-current-branch #[0 "\300\301\302\303#\207" [magit-git-string "symbolic-ref" "--short" "HEAD"] 4 (#$ . 45767)])
|
#@85 Maximum time to spend in `magit-get-previous-branch'.
|
Given as a number of seconds.
|
(defvar magit-get-previous-branch-timeout 0.5 (#$ . 46011))
|
#@263 Return the refname of the previously checked out branch.
|
Return nil if no branch can be found in the `HEAD' reflog
|
which is different from the current branch and still exists.
|
The amount of time spent searching is limited by
|
`magit-get-previous-branch-timeout'.
|
(defalias 'magit-get-previous-branch #[0 "\301 \302 \303\304\301 ZV\203 \304\211\262\202. \305\306\307\"!\211\262\2038 \310!\211\262\2031 \211\232\2038 T\262\202 \207" [magit-get-previous-branch-timeout float-time magit-get-current-branch 1 nil magit-rev-verify format "@{-%i}" magit-rev-branch] 8 (#$ . 46162)])
|
#@25
|
|
(fn &optional BRANCH)
|
(defalias 'magit-get-upstream-ref #[256 "\211\204\f \300 \211\262\2059 \301\302\303#\301\302\304#\2057 \211\2057 \305\230\203( \211\2027 \306\307\"\2057 \310\311\312\313OR\266\202\207" [magit-get-current-branch magit-get "branch" "remote" "merge" "." string-prefix-p "refs/heads/" "refs/remotes/" "/" 11 nil] 9 (#$ . 46755)])
|
#@24
|
|
(fn BRANCH UPSTREAM)
|
(defalias 'magit-set-upstream-branch #[514 "\211\203( \300!\211@A\211\301\302\"\303\"\266\301\304\"\303\305P\"\262\266\202\207\306\307\310#\207" [magit-split-branch-name format "branch.%s.remote" magit-set "branch.%s.merge" "refs/heads/" magit-call-git "branch" "--unset-upstream"] 11 (#$ . 47119)])
|
#@32
|
|
(fn &optional BRANCH VERIFY)
|
(defalias 'magit-get-upstream-branch #[512 "\204\f \301 \211\262\205i \302\303\304#\211\205 \302\303\305#\211\205g \306\307\"\205g \211\310\311O\312\230\2037 \313\314\315#\202Z \316\311\317\320#)\266\203\203R \313\321Q\314\322#\202Z \313\323Q\314\322#\203d \324!\205e \211\266\202\266\202\207" [inhibit-changing-match-data magit-get-current-branch magit-get "branch" "remote" "merge" string-prefix-p "refs/heads/" 11 nil "." propertize face magit-branch-local "[@:]" t string-match " " magit-branch-remote "/" magit-rev-verify] 12 (#$ . 47462)])
|
#@31
|
|
(fn BRANCH &optional FORCE)
|
(defalias 'magit-get-indirect-upstream-branch #[513 "\302\303\304#\211\205{ \211\305\232?\205{ \204_ \306\307\310\203W \203W @\203, \306\262\202K \311\312\313#\203; \211\232\202I \211\306\307\314#)\266\203\262\210\211T\262A\262\202 \266\211\262\205{ \315!\211\205y \211GT\306O\232\205y \316\"\205y \211\262\207" [magit-branch-prefer-remote-upstream inhibit-changing-match-data magit-get "branch" "remote" "." nil t 0 magit-git-success "check-ref-format" "--branch" string-match magit-get-upstream-branch magit-rev-ancestor-p] 15 (#$ . 48064)])
|
#@35
|
|
(fn &optional BRANCH NON-LOCAL)
|
(defalias 'magit-get-upstream-remote #[512 "\204 \300 \262\205 \301\302\303#\205 \211\304\232?\205 \211\262\207" [magit-get-current-branch magit-get "branch" "remote" "."] 6 (#$ . 48674)])
|
#@25
|
|
(fn &optional BRANCH)
|
(defalias 'magit-get-push-remote #[256 "\211\204\f \300 \211\262\203 \301\302\303#\206 \301\304!\207" [magit-get-current-branch magit-get "branch" "pushRemote" "remote.pushDefault"] 5 (#$ . 48913)])
|
#@32
|
|
(fn &optional BRANCH VERIFY)
|
(defalias 'magit-get-push-branch #[512 "\204\f \300 \211\262\205, \301!\211\205 \211\302Q\211\205* \203% \303!\205* \304\305\306#\266\202\207" [magit-get-current-branch magit-get-push-remote "/" magit-rev-verify propertize face magit-branch-remote] 8 (#$ . 49146)])
|
#@25
|
|
(fn &optional BRANCH)
|
(defalias 'magit-get-@{push}-branch #[256 "\300\301\302P\"\211\205 \303\304\"\205 \211\305\306O\207" [magit-rev-parse "--symbolic-full-name" "@{push}" string-prefix-p "refs/remotes/" 13 nil] 5 (#$ . 49457)])
|
#@25
|
|
(fn &optional BRANCH)
|
(defalias 'magit-get-remote #[256 "\211\204\f \300 \211\262\205 \301\302\303#\211\304\232?\205 \211\262\207" [magit-get-current-branch magit-get "branch" "remote" "."] 5 (#$ . 49699)])
|
#@25
|
|
(fn &optional BRANCH)
|
(defalias 'magit-get-some-remote #[256 "\300!\206 \301\302!\203 \300\302!\206 \303 \304\235@\206 \211@\262\207" [magit-get-remote magit-branch-p "master" magit-list-remotes "origin"] 4 (#$ . 49919)])
|
#@475 Return non-nil if BRANCH is merged into its upstream and TARGET.
|
|
TARGET defaults to the current branch. If `HEAD' is detached and
|
TARGET is nil, then always return nil. As a special case, if
|
TARGET is t, then return non-nil if BRANCH is merged into any one
|
of the other local branches.
|
|
If, and only if, BRANCH has an upstream, then only return non-nil
|
if BRANCH is merged into both TARGET (as described above) as well
|
as into its upstream.
|
|
(fn BRANCH &optional TARGET)
|
(defalias 'magit-branch-merged-p #[513 "\300!\205 \301!\211\203 \302\303\304$\202 \305\262\205= \211\305=\203+ \306\307!\310!\"\207\211\2061 \311 \211\205; \302\303\304$\262\207" [magit-branch-p magit-get-upstream-branch magit-git-success "merge-base" "--is-ancestor" t delete magit-name-local-branch magit-list-containing-branches magit-get-current-branch] 8 (#$ . 50157)])
|
#@15
|
|
(fn BRANCH)
|
(defalias 'magit-split-branch-name #[257 "\211\300 \235\203 \301B\207\302\303\"\203& \304\303\"\211@A\211@A\211B\266\202\207\302\305\"\205Z \211\306\211\224O\307 \310\306\311\312\313!\314\"\315$\216\316 \235)\262\203T \211\306\225\317OB\202X \320\321\"\262\207" [magit-list-local-branch-names "." string-match " " split-string "/" 0 match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 magit-list-remotes nil error "Invalid branch name %s"] 10 (#$ . 51025)])
|
#@357 Return the closest tag reachable from REV.
|
|
If optional REV is nil, then default to `HEAD'.
|
If optional WITH-DISTANCE is non-nil then return (TAG COMMITS),
|
if it is `dirty' return (TAG COMMIT DIRTY). COMMITS is the number
|
of commits in `HEAD' but not in TAG and DIRTY is t if there are
|
uncommitted changes, nil otherwise.
|
|
(fn &optional REV WITH-DISTANCE)
|
(defalias 'magit-get-current-tag #[512 "\300\301\302\303\304=\205 \305%\211\205L \306 \307\310\311\312\313!\314\"\315$\216\316\317\"\210\203E \320\321\"\322\320\323\"\2066 \324!\320\315\"\205@ \325CBB\202I \320\321\")\262\207" [magit-git-str "describe" "--long" "--tags" dirty "--dirty" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" match-string 1 string-to-number 2 "0" t] 10 (#$ . 51559)])
|
#@387 Return the closest tag from which REV is reachable.
|
|
If optional REV is nil, then default to `HEAD'.
|
If no such tag can be found or if the distance is 0 (in which
|
case it is the current tag, not the next), return nil instead.
|
If optional WITH-DISTANCE is non-nil, then return (TAG COMMITS)
|
where COMMITS is the number of commits in TAG but not in REV.
|
|
(fn &optional REV WITH-DISTANCE)
|
(defalias 'magit-get-next-tag #[512 "\300\301\302\206 \303#\211\205D \304 \305\306\307\310\311!\312\"\313$\216\314\315\"\205A \316\306\"\262\317!\232?\205A \203@ \320\"@D\202A )\262\207" [magit-git-str "describe" "--contains" "HEAD" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "^[^^~]+" match-string magit-get-current-tag magit-rev-diff-count] 10 (#$ . 52453)])
|
(defvar magit-list-refs-namespaces '("refs/heads" "refs/remotes" "refs/tags" "refs/pull"))
|
#@490 Return list of references.
|
|
When NAMESPACES is non-nil, list refs from these namespaces
|
rather than those from `magit-list-refs-namespaces'.
|
|
FORMAT is passed to the `--format' flag of `git for-each-ref'
|
and defaults to "%(refname)". If the format is "%(refname)"
|
or "%(refname:short)", then drop the symbolic-ref "HEAD".
|
|
SORTBY is a key or list of keys to pass to the `--sort' flag of
|
`git for-each-ref'. When nil, use `magit-list-refs-sortby'
|
|
(fn &optional NAMESPACES FORMAT SORTBY)
|
(defalias 'magit-list-refs #[768 "\204 \303\262\304\305\306P\307\310\206 \211;\203 \211\211C\262\202- \211<\203, \211\211\262\202- \311\262\"\2066 $\312\235\203p \311\313\203g @\314\311\315\316#)\266\203\204[ \211B\262\210\211T\262A\262\202@ \266\211\237\262\202q \211\207" [magit-list-refs-sortby magit-list-refs-namespaces inhibit-changing-match-data "%(refname)" magit-git-lines "for-each-ref" "--format=" mapcar #[257 "\300P\207" ["--sort="] 3 "\n\n(fn IT)"] nil ("%(refname)" "%(refname:short)") 0 "\\(\\`\\|/\\)HEAD\\'" t string-match] 15 (#$ . 53376)])
|
(defalias 'magit-list-branches #[0 "\300\301\302D!\207" [magit-list-refs "refs/heads" "refs/remotes"] 3])
|
(defalias 'magit-list-local-branches #[0 "\300\301!\207" [magit-list-refs "refs/heads"] 2])
|
#@25
|
|
(fn &optional REMOTE)
|
(defalias 'magit-list-remote-branches #[256 "\300\301P!\207" [magit-list-refs "refs/remotes/"] 4 (#$ . 54660)])
|
#@38
|
|
(fn RELATION &optional COMMIT ARG)
|
(defalias 'magit-list-related-branches #[769 "\301\302\303\304\305$\"\306\2034 @\307\301\310\311#)\266\203\204( \211B\262\210\211T\262A\262\202 \266\211\237\207" [inhibit-changing-match-data nil mapcar #[257 "\211\300\301O\207" [2 nil] 4 "\n\n(fn IT)"] magit-git-lines "branch" 0 "\\(\\`(HEAD\\|HEAD -> \\)" t string-match] 14 (#$ . 54803)])
|
#@29
|
|
(fn &optional COMMIT ARG)
|
(defalias 'magit-list-containing-branches #[512 "\300\301#\207" [magit-list-related-branches "--contains"] 6 (#$ . 55207)])
|
#@25
|
|
(fn &optional COMMIT)
|
(defalias 'magit-list-publishing-branches #[256 "\301\302\203! @\303\"\203 \211B\262\210\211T\262A\262\202 \266\211\237\207" [magit-published-branches nil 0 magit-rev-ancestor-p] 8 (#$ . 55367)])
|
#@29
|
|
(fn &optional COMMIT ARG)
|
(defalias 'magit-list-merged-branches #[512 "\300\301#\207" [magit-list-related-branches "--merged"] 6 (#$ . 55606)])
|
#@29
|
|
(fn &optional COMMIT ARG)
|
(defalias 'magit-list-unmerged-branches #[512 "\300\301#\207" [magit-list-related-branches "--no-merged"] 6 (#$ . 55760)])
|
(defalias 'magit-list-unmerged-to-upstream-branches #[0 "\300\301 \302\203, @\303!\211\205 \304!\235\262\203 \211B\262\210\211T\262A\262\202 \266\211\237\207" [nil magit-list-local-branch-names 0 magit-get-upstream-branch magit-list-unmerged-branches] 8])
|
#@15
|
|
(fn COMMIT)
|
(defalias 'magit-list-branches-pointing-at #[257 "\300\301\302!\"\303\304\305!\306\203= @\307\"\205' \310\311\"\312\313\"?\205% \211\262\211\2030 \211B\262\266\211T\262A\262\202 \266\211\237\262\207" [format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'" magit-rev-verify nil magit-git-lines "show-ref" 0 string-match match-string 2 string-suffix-p "HEAD"] 10 (#$ . 56190)])
|
#@29
|
|
(fn &optional NAMESPACES)
|
(defalias 'magit-list-refnames #[256 "\300\301\"\207" [magit-list-refs "%(refname:short)"] 4 (#$ . 56602)])
|
(defalias 'magit-list-branch-names #[0 "\300\301\302D!\207" [magit-list-refnames "refs/heads" "refs/remotes"] 3])
|
(defalias 'magit-list-local-branch-names #[0 "\300\301!\207" [magit-list-refnames "refs/heads"] 2])
|
#@34
|
|
(fn &optional REMOTE RELATIVE)
|
(defalias 'magit-list-remote-branch-names #[512 "\203# \211\203# \300\301\"\302\303\304\305\306\307\310\311!\312\"\313\314%\315!\"\"\207\316\317P!\207" [format "^refs/remotes/%s/\\(.+\\)" apply append mapcar make-byte-code 257 "\301\300\"\205\f \302\303\"C\207" vconcat vector [string-match match-string 1] 4 "\n\n(fn IT)" magit-list-remote-branches magit-list-refnames "refs/remotes/"] 12 (#$ . 56959)])
|
#@26
|
|
(fn FORMAT &rest ARGS)
|
(defalias 'magit-format-refs #[385 "\301\302\303P\206 \304\305\306E#\307\310\311\312#)\266\203\203% \313\314\"\202& \211\207" [inhibit-changing-match-data magit-git-lines "for-each-ref" "--format=" "refs/heads" "refs/remotes" "refs/tags" "\f" nil t string-match mapcar #[257 "\300\301\"\207" [split-string "\f"] 4 "\n\n(fn IT)"]] 10 (#$ . 57412)])
|
(defalias 'magit-list-remotes #[0 "\300\301!\207" [magit-git-lines "remote"] 2])
|
(defalias 'magit-list-tags #[0 "\300\301!\207" [magit-git-lines "tag"] 2])
|
#@25
|
|
(fn &optional FORMAT)
|
(defalias 'magit-list-stashes #[256 "\300\301\302\303\206 \304P#\207" [magit-git-lines "stash" "list" "--format=" "%gd"] 6 (#$ . 57957)])
|
#@72 Return notes refs according to `core.notesRef' and `notes.displayRef'.
|
(defalias 'magit-list-active-notes-refs #[0 "\300\301\302\303\304!\206\n \305\306\307!$\207" [magit-git-lines "for-each-ref" "--format=%(refname)" magit-get "core.notesRef" "refs/notes/commits" magit-get-all "notes.displayRef"] 6 (#$ . 58127)])
|
(defalias 'magit-list-notes-refnames #[0 "\300\301\302\303!\"\207" [mapcar #[257 "\211\300\301O\207" [6 nil] 4 "\n\n(fn IT)"] magit-list-refnames "refs/notes"] 4])
|
#@15
|
|
(fn REMOTE)
|
(defalias 'magit-remote-list-tags #[257 "\301\302\303\304#\305\2038 @\306\301\307\310#)\266\203?\205\" \211\311\301O\211\203+ \211B\262\266\211T\262A\262\202 \266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" "--tags" 0 "\\^{}$" t string-match 51] 12 (#$ . 58613)])
|
#@15
|
|
(fn REMOTE)
|
(defalias 'magit-remote-list-branches #[257 "\301\302\303\304#\305\2038 @\306\301\307\310#)\266\203?\205\" \211\311\301O\211\203+ \211B\262\266\211T\262A\262\202 \266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" "--heads" 0 "\\^{}$" t string-match 52] 12 (#$ . 58943)])
|
#@15
|
|
(fn REMOTE)
|
(defalias 'magit-remote-list-refs #[257 "\301\302\303\"\304\2037 @\305\301\306\307#)\266\203?\205! \211\310\301O\211\203* \211B\262\266\211T\262A\262\202 \266\211\237\207" [inhibit-changing-match-data nil magit-git-lines "ls-remote" 0 "\\^{}$" t string-match 41] 12 (#$ . 59278)])
|
(defalias 'magit-list-module-paths #[0 "\300\301\302\303\304\305\306\307#\"\"\207" [apply append mapcar #[257 "\300\301\"\205\f \302\303\"C\207" [string-match "^160000 [0-9a-z]\\{40\\} 0 \\(.+\\)$" match-string 1] 4 "\n\n(fn IT)"] magit-git-items "ls-files" "-z" "--stage"] 8])
|
#@103 Return the name of the submodule at PATH.
|
PATH has to be relative to the super-repository.
|
|
(fn PATH)
|
(defalias 'magit-get-submodule-name #[257 "\300\301\302\303\304\305\306\307 \"\310\311\312\313\314 !!\315Q&\206 \316\317\"@\320\"A@\207" [split-string magit-git-items "config" "-z" "-f" expand-file-name ".gitmodules" magit-toplevel "--get-regexp" "^submodule\\..*\\.path$" "^" regexp-quote directory-file-name "$" error "No such submodule `%s'" "\n"] 13 (#$ . 59876)])
|
(defalias 'magit-list-worktrees #[0 "\302\211\303\304\"\305\306\307\310#)\211\203\252 \211@\311\306\"\203, \211\312\302O\302\211\211F\211\262B\262\202\243 \211\313\230\203u @\314\315!?\205? \316\317!\211\203i \320\321!!\203i \211\321!\240\266AA\211\322\323!\240\266\324\233\211\325 \240\266\202p A\211\326\240\266)\210\202\243 \311\323\"\203\212 AA\211\327\302O\240\266\202\243 \311\330\"\203\237 \324\233\211\331\302O\240\266\202\243 \211\332\230\210A\266\202\202 \210\237\207" [magit-git-global-arguments default-directory nil remove "--no-pager" magit-git-lines "worktree" "list" "--porcelain" string-prefix-p 9 "bare" magit-get-boolean "core.bare" magit-get "core.worktree" file-exists-p expand-file-name magit-rev-parse "HEAD" 3 magit-get-current-branch t 5 "branch" 18 "detached"] 9])
|
#@13
|
|
(fn NAME)
|
(defalias 'magit-symbolic-ref-p #[257 "\300\301\302#\207" [magit-git-success "symbolic-ref" "--quiet"] 5 (#$ . 61177)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-ref-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-refs magit-list-refnames] 3 (#$ . 61316)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-branches magit-list-branch-names] 3 (#$ . 61458)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-local-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-local-branches magit-list-local-branch-names] 3 (#$ . 61611)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-remote-branch-p #[257 "\211\300 \235@\206 \211\301 \235@\207" [magit-list-remote-branches magit-list-remote-branch-names] 3 (#$ . 61782)])
|
#@15
|
|
(fn BRANCH)
|
(defalias 'magit-branch-set-face #[257 "\300\301\302!\203 \303\202 \304#\207" [propertize face magit-local-branch-p magit-branch-local magit-branch-remote] 6 (#$ . 61956)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-tag-p #[257 "\211\300 \235@\207" [magit-list-tags] 3 (#$ . 62153)])
|
#@15
|
|
(fn STRING)
|
(defalias 'magit-remote-p #[257 "\211\300 \235@\207" [magit-list-remotes] 3 (#$ . 62255)])
|
#@103 Return the commits in A but not B and vice versa.
|
Return a list of two integers: (A>B B>A).
|
|
(fn A B)
|
(defalias 'magit-rev-diff-count #[514 "\300\301\302\303\304\305\306\307 Q$\310\"\"\207" [mapcar string-to-number split-string magit-git-string "rev-list" "--count" "--left-right" "..." " "] 12 (#$ . 62367)])
|
(defalias 'magit-abbrev-length #[0 "\300\301!\211\203 \302!\202. \303\304\305\"\211\203 \211G\202 \306\262\303\304\307\"\211\203* \211G\202+ \306\262^\207" [magit-get "core.abbrev" string-to-number magit-rev-parse "--short" "HEAD" 7 "HEAD~"] 5])
|
#@22
|
|
(fn &optional ARG)
|
(defalias 'magit-abbrev-arg #[256 "\300\301\206 \302\303 #\207" [format "--%s=%d" "abbrev" magit-abbrev-length] 5 (#$ . 62938)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-rev-abbrev #[257 "\300\301\302!\"\207" [magit-rev-parse magit-abbrev-arg "short"] 4 (#$ . 63096)])
|
#@30
|
|
(fn COMMIT &optional ARGS)
|
(defalias 'magit-commit-children #[513 "\300\301\302\300\303\304\305\306\206 \307\310\311E\312 %\"\313\2036 @A\235\203* \211B\262\210\211T\262A\262\202 \266\211\237\262\"\207" [mapcar car nil #[257 "\300\301\"\207" [split-string " "] 4 "\n\n(fn IT)"] magit-git-lines "log" "--format=%H %P" "--branches" "--tags" "--remotes" "--not" 0] 13 (#$ . 63230)])
|
#@15
|
|
(fn COMMIT)
|
(defalias 'magit-commit-parents #[257 "\300\301\302\303$\211\205 \304!A\207" [magit-git-string "rev-list" "-1" "--parents" split-string] 6 (#$ . 63636)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-patch-id #[257 "\303\304!r\211q\210\305\306\307\310\311!\312\"\313$\216\314\315\316\315 \317\n!\320\321 $\262&\210\322\323 !@*\207" [shell-file-name shell-command-switch magit-git-executable generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 magit-process-file nil (t nil) shell-quote-argument format "%s diff-tree -u %s | %s patch-id" split-string buffer-string] 14 (#$ . 63813)])
|
#@34
|
|
(fn FORMAT &optional REV ARGS)
|
(defalias 'magit-rev-format #[769 "\300\301\302\303P\203 \304P\202 \305\306&\211\307\230?\205 \211\207" [magit-git-string "show" "--no-patch" "--format=" "^{commit}" "HEAD" "--" ""] 10 (#$ . 64306)])
|
#@34
|
|
(fn FORMAT &optional REV ARGS)
|
(defalias 'magit-rev-insert-format #[769 "\300\301\302\303P\203 \304P\202 \305\306&\207" [magit-git-insert "show" "--no-patch" "--format=" "^{commit}" "HEAD" "--"] 10 (#$ . 64556)])
|
#@12
|
|
(fn REV)
|
(defalias 'magit-format-rev-summary #[257 "\300\301\"\211\205 \302\303\"\210\304\305\211\224\306\307%\210\211\207" [magit-rev-format "%h %s" string-match " " put-text-property 0 face magit-hash] 8 (#$ . 64787)])
|
#@492 How refs are formatted for display.
|
|
Each entry controls how a certain type of ref is displayed, and
|
has the form (REGEXP . FACE). REGEXP is a regular expression
|
used to match full refs. The first entry whose REGEXP matches
|
the reference is used.
|
|
In log and revision buffers the first regexp submatch becomes the
|
"label" that represents the ref and is propertized with FONT.
|
In refs buffers the displayed text is controlled by other means
|
and this option only controls what face is used.
|
(defvar magit-ref-namespaces '(("\\`HEAD\\'" . magit-head) ("\\`refs/tags/\\(.+\\)" . magit-tag) ("\\`refs/heads/\\(.+\\)" . magit-branch-local) ("\\`refs/remotes/\\(.+\\)" . magit-branch-remote) ("\\`refs/bisect/\\(bad\\)" . magit-bisect-bad) ("\\`refs/bisect/\\(skip.*\\)" . magit-bisect-skip) ("\\`refs/bisect/\\(good.*\\)" . magit-bisect-good) ("\\`refs/stash$" . magit-refname-stash) ("\\`refs/wip/\\(.+\\)" . magit-refname-wip) ("\\`refs/pullreqs/\\(.+\\)" . magit-refname-pullreq) ("\\`\\(bad\\):" . magit-bisect-bad) ("\\`\\(skip\\):" . magit-bisect-skip) ("\\`\\(good\\):" . magit-bisect-good) ("\\`\\(.+\\)" . magit-refname)) (#$ . 65021))
|
#@15
|
|
(fn STRING)
|
(defalias 'magit-format-ref-labels #[257 "\302\303\304\302\305\304##\262\306 \307\310\311\312\313!\314\"\315$\216\316\317\320\321!\203T \322A@\235\203T \323 \324\325\326\327 !\"\330\307\331\332\312\313\"\333\"\334\335%\336\302\337\340 #\341#\"\266\203\202[ \336\341#\262\317\211\211\211\211\211\211\211\211\203\n\211@\317 \341\310\203\233 \203\233 @\203\203 \317\262\202\217 \342@\"\203\217 \211\262\210\211T\262A\262\202o \266\211\262A\343\344\345\"\206\252 \346#\347\350\"\203\272 \211\262\f\202\351\352\"\203\313 \343\353\346\352#\262 \202\351\354\"\203\333 \211 B\262 \202\351\355\"\203\353 \211B\262\202\351\356\"\203\373 \211B\262\202\211B\262\266A\266\202\202e \210\357\360\"\262\361 \362\341\"\211\203p\211@\363!\235@\211\203<\364 \"\262\342\365\"\210\211\310\211\225O\262\232\203N\211\343\346\366#P\262\f\202h\232\203`\211\343\346\367#P\262 \202h\211PB\262\210A\266\202\202\210\211\203\261\204\261\211\235\203\226\370\310G\371\317%\210\211\262\364\"\262\202\261\211\235@\211\203\260\370\310G\371\317%\210\211\262 \364\"\262\210\266\372\373\374\n\n\n\375 \237\237 \237 $BBB!\376#\266\210\266\202)\207" [magit-refresh-args magit-ref-namespaces replace-regexp-in-string ")\\s-*\\'" "" "\\`\\s-*(" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\\(, \\|tag: \\|HEAD -> \\)" nil derived-mode-p magit-log-mode "--simplify-by-decoration" magit-list-local-branch-names format "^%s/.+" regexp-opt magit-list-remotes mapcar 257 "\211\302\230\203 \207\303\304\"\203 \207\211\300\235\203 \305P\207\306\301\"\203$ \307P\207\304P\207" ["HEAD" string-prefix-p "refs/" "refs/heads/" string-match "refs/remotes/"] 4 "\n\n(fn IT)" split-string "tag: " "refs/tags/" t string-match propertize match-string 1 face memql (magit-bisect-bad magit-bisect-skip magit-bisect-good) eql magit-head "@" magit-tag magit-branch-local magit-branch-remote -keep #[257 "\300\301\"\203/ \302\303\"\302\304\"\211\305\232?\205. \306P\307\310\311\312\"\"\232\203- \313\314\315#\202. \207\207" [string-match "\\`\\([^/]*\\)/\\(.*\\)\\'" match-string 1 2 "HEAD" "refs/remotes/" magit-git-string "symbolic-ref" format "refs/remotes/%s/HEAD" propertize face magit-branch-remote-head] 9 "\n\n(fn NAME)"] magit-get-current-branch magit-get-upstream-branch magit-get-push-branch delete "^[^/]*/" magit-branch-current (magit-branch-upstream magit-branch-local) add-face-text-property magit-branch-upstream mapconcat identity -flatten append " "] 23 (#$ . 66168)])
|
#@15
|
|
(fn OBJECT)
|
(defalias 'magit-object-type #[257 "\300\301\302#\207" [magit-git-string "cat-file" "-t"] 5 (#$ . 68800)])
|
#@31
|
|
(fn COMMIT FILE &rest BODY)
|
(defalias 'magit-with-blob '(macro . #[642 "\300\301\302DC\303\304\305\306\307\n\310BBFD\311BBBBD\207" [with-temp-buffer let buffer-file-name save-excursion magit-git-insert "cat-file" "-p" concat (":" buffer-file-name) (decode-coding-inserted-region (point-min) (point-max) buffer-file-name t nil nil t)] 13 (#$ . 68928)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-blob lisp-indent-function 2 put edebug-form-spec (form form body)] 5)
|
#@28
|
|
(fn TREE ARG &rest BODY)
|
(defalias 'magit-with-temp-index '(macro . #[642 "\300\301!\302\303\304BD\305\306\307\310\311\312 \313\314\315 E\257\316BBE\317\320\302\321\322\314\323\fE\324BBDC\nBB\302\325\322\314\323 E\326BBDC BBFE\327\330\314\331EDDEE\207" [cl-gensym "file" let (magit--refresh-cache nil) ((magit-convert-filename-for-git (make-temp-name (magit-git-dir "index.magit.")))) unwind-protect magit-with-toplevel --when-let or magit-git-success "read-tree" it concat "--index-output=" ((error "Cannot read tree %s" it)) if (file-remote-p default-directory) magit-tramp-process-environment cons "GIT_INDEX_FILE=" (magit-tramp-process-environment) process-environment (process-environment) ignore-errors delete-file (file-remote-p default-directory)] 18 (#$ . 69439)]))
|
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-with-temp-index lisp-indent-function 2 put edebug-form-spec (form form body)] 5)
|
#@45
|
|
(fn MESSAGE &optional TREE &rest PARENTS)
|
(defalias 'magit-commit-tree #[641 "\300\301\302\303\304\305\306\307\310\311 \"\"\"\206 \300\312!\206 \313\314!&\207" [magit-git-string "commit-tree" "--no-gpg-sign" "-m" apply append mapcar #[257 "\300D\207" ["-p"] 3 "\n\n(fn IT)"] delq nil "write-tree" error "Cannot write tree"] 15 (#$ . 70387)])
|
#@50
|
|
(fn MESSAGE &optional ARG &rest OTHER-PARENTS)
|
(defalias 'magit-commit-worktree #[641 "\304\305\306\307\310!!!\311\312\313\314\315!\316\"\317$\216\320 \211\203q \211\321\211\2035 \322\323\324P$\2045 \325\326\"\210\210\327 !\203V \330P\nB\331\332 !\205R \333\334\304\321%)\202m \330P B\331\332 !\205l \333\334\304\321%))\202s \335 \262*\207" [magit--refresh-cache default-directory magit-tramp-process-environment process-environment nil magit-convert-filename-for-git make-temp-name magit-git-dir "index.magit." make-byte-code 0 "\3021 \303\304 !\300P!0\207\210\305\207" vconcat vector [default-directory (error) delete-file file-remote-p nil] 3 magit-toplevel "HEAD" magit-git-success "read-tree" "--index-output=" error "Cannot read tree %s" file-remote-p "GIT_INDEX_FILE=" magit-update-files magit-unstaged-files apply magit-commit-tree magit--not-inside-repository-error] 13 (#$ . 70746)])
|
#@14
|
|
(fn FILES)
|
(defalias 'magit-update-files #[257 "\300\301\302\303\304%\207" [magit-git-success "update-index" "--add" "--remove" "--"] 7 (#$ . 71672)])
|
#@43
|
|
(fn REF MESSAGE REV &optional STASHISH)
|
(defalias 'magit-update-ref #[1027 "\301\302\303 \304\"\204# \305\306\307\310\311 !\206 \312&\313U\202\223 \311!\314\315P!\316!\204 \203> \317\306\320$\210\321\322!\323\"\210\211\324\325\326!!\327\313\330\331\332!\333\"\334$\216r\211q\210)r\211q\210\335\301\211\301\313%\210*\266\203 \204 \317\306\310\336 \312&\210\266\317\306\310\311\n!\206\221 \312&\206\233 \337\340#)\207" [magit--refresh-cache nil version< magit-git-version "2.6.0" magit-call-git "update-ref" "--create-reflog" "-m" magit-rev-verify "" 0 magit-git-dir "logs/" file-exists-p magit-git-success "-d" make-directory file-name-directory t get-buffer-create generate-new-buffer-name " *temp file*" make-byte-code "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 write-region "enable reflog" error "Cannot update %s with %s"] 14 (#$ . 71832)])
|
(defconst magit-range-re "\\`\\([^ ]*[^.]\\)?\\(\\.\\.\\.?\\)\\([^.][^ ]*\\)?\\'")
|
#@14
|
|
(fn RANGE)
|
(defalias 'magit-split-range #[257 "\301\"\205- \302\303\"\206 \304\302\305\"\206 \304\302\306\"\307\230\203( \310\311#\202) B\266\202\207" [magit-range-re string-match match-string 1 "HEAD" 3 2 "..." magit-git-string "merge-base"] 7 (#$ . 72841)])
|
#@63 Characters allowable in filenames, excluding space and colon.
|
(defvar magit-thingatpt--git-revision-chars "-_./[:alnum:]@{}^~!" (#$ . 73120))
|
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\207" [put git-revision end-op #[0 "\301\302\303Q\304\305#\207" [magit-thingatpt--git-revision-chars re-search-forward "\\=[" "]*" nil t] 4] beginning-op #[0 "\301\302\303Q\304\305#\203 \304u\207eb\207" [magit-thingatpt--git-revision-chars re-search-backward "[^" "]" nil t] 4] thing-at-point magit-thingatpt--git-revision] 4)
|
(defalias 'magit-thingatpt--git-revision #[0 "\300\301!\211\205 \302@A\"\303!\205 \211\262\207" [bounds-of-thing-at-point git-revision buffer-substring-no-properties magit-rev-verify-commit] 4])
|
(defvar magit-revision-history nil)
|
#@43
|
|
(fn PROMPT &optional SECONDARY-DEFAULT)
|
(defalias 'magit-read-branch #[513 "\300\301 \302\303\302\304\305 \206 \206 \306 &\207" [magit-completing-read magit-list-branch-names nil t magit-revision-history magit-branch-at-point magit-get-current-branch] 10 (#$ . 73906)])
|
#@43
|
|
(fn PROMPT &optional SECONDARY-DEFAULT)
|
(defalias 'magit-read-branch-or-commit #[513 "\300\301\302 B\303\211\211\304\305 \206 \206 \306 &\206 \307\310!\207" [magit-completing-read "HEAD" magit-list-refnames nil magit-revision-history magit-branch-or-commit-at-point magit-get-current-branch user-error "Nothing selected"] 10 (#$ . 74190)])
|
#@43
|
|
(fn PROMPT &optional SECONDARY-DEFAULT)
|
(defalias 'magit-read-range-or-commit #[513 "\300\301\302\303\"\211\205 \304 \210\305!@\306@Q\262\206% \307 \206% \206% \310 \"\207" [magit-read-range magit-region-values (commit branch) t deactivate-mark last ".." magit-branch-or-commit-at-point magit-get-current-branch] 8 (#$ . 74545)])
|
#@33
|
|
(fn PROMPT &optional DEFAULT)
|
(defalias 'magit-read-range #[513 "\300\301 \302\303%\207" [magit-completing-read-multiple magit-list-refnames "\\.\\.\\.?" magit-revision-history] 8 (#$ . 74889)])
|
#@67
|
|
(fn PROMPT &optional REMOTE DEFAULT LOCAL-BRANCH REQUIRE-MATCH)
|
(defalias 'magit-read-remote-branch #[1281 "\300\301\205& \203 \302Q\202& \303\304\305\306\307\310\n!\311\"\312\313%\314 \"\315\316\"\"\317\317\320 &\204? \321\322\"\203C \211\202G \323\324\"\207" [magit-completing-read -union "/" mapcar make-byte-code 257 "\211\301\300Q\207" vconcat vector ["/"] 4 "\n\n(fn IT)" magit-list-remotes magit-list-remote-branch-names t nil magit-revision-history string-match "\\`\\([^/]+\\)/\\(.+\\)" user-error "`%s' doesn't have the form REMOTE/BRANCH"] 15 (#$ . 75094)])
|
#@22
|
|
(fn PROMPT REMOTE)
|
(defalias 'magit-read-refspec #[514 "\300\301\302!\210\303!\301\304!\210\"\207" [magit-completing-read message "Determining available refs..." magit-remote-list-refs "Determining available refs...done"] 7 (#$ . 75689)])
|
#@43
|
|
(fn PROMPT &optional SECONDARY-DEFAULT)
|
(defalias 'magit-read-local-branch #[513 "\300\301 \302\303\302\304\305 \206 \206 \306 &\207" [magit-completing-read magit-list-local-branch-names nil t magit-revision-history magit-local-branch-at-point magit-get-current-branch] 10 (#$ . 75938)])
|
#@15
|
|
(fn PROMPT)
|
(defalias 'magit-read-local-branch-or-commit #[257 "\300 \301 \302\203 B\202 \303\211\211\304\305 \206 &\206$ \306\307!\207" [magit-list-local-branch-names magit-commit-at-point magit-completing-read nil magit-revision-history magit-local-branch-at-point user-error "Nothing selected"] 11 (#$ . 76240)])
|
#@43
|
|
(fn PROMPT &optional SECONDARY-DEFAULT)
|
(defalias 'magit-read-local-branch-or-ref #[513 "\300\301 \302\303!\244\304\305\304\306\307 \206 \206 \310 &\207" [magit-completing-read magit-list-local-branch-names magit-list-refs "refs/" nil t magit-revision-history magit-local-branch-at-point magit-get-current-branch] 10 (#$ . 76575)])
|
#@68
|
|
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT NO-REQUIRE-MATCH)
|
(defalias 'magit-read-other-branch #[1025 "\300 \301 \206 \232\204 \206# \232\204 \206# \206# \302 \303\304\305 \"\306?\306\307&\207" [magit-get-current-branch magit-branch-at-point magit-get-previous-branch magit-completing-read delete magit-list-branch-names nil magit-revision-history] 16 (#$ . 76921)])
|
#@51
|
|
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
|
(defalias 'magit-read-other-branch-or-commit #[769 "\300 \301 \206 \232\204 \206# \232\204 \206# \206# \302 \303\304\305 \"\306\211\211\307&\2069 \310\311!\207" [magit-get-current-branch magit-branch-or-commit-at-point magit-get-previous-branch magit-completing-read delete magit-list-refnames nil magit-revision-history user-error "Nothing selected"] 15 (#$ . 77321)])
|
#@68
|
|
(fn PROMPT &optional EXCLUDE SECONDARY-DEFAULT NO-REQUIRE-MATCH)
|
(defalias 'magit-read-other-local-branch #[1025 "\300 \301 \206 \232\204 \206# \232\204 \206# \206# \302 \303\304\305 \"\306?\306\307&\207" [magit-get-current-branch magit-local-branch-at-point magit-get-previous-branch magit-completing-read delete magit-list-local-branch-names nil magit-revision-history] 16 (#$ . 77765)])
|
#@15
|
|
(fn PROMPT)
|
(defalias 'magit-read-branch-prefer-other #[257 "\300 \301 \211\205 \302!\303 \304\305 \306\307\306\310\311\312!\206k \206k A\204, @\206k \306 \307\313\203[ \203[ @\203E \306\262\202O \211\232\204O \211\262\210\211T\262A\262\2021 \266\211\262\206k \314 \206k @&\207" [magit-get-current-branch magit-commit-at-point magit-list-branches-pointing-at magit--painted-branch-at-point magit-completing-read magit-list-branch-names nil t magit-revision-history magit-section-value-if branch 0 magit-get-previous-branch] 19 (#$ . 78183)])
|
#@61
|
|
(fn &optional (BRANCH (magit-get-current-branch)) PROMPT)
|
(defalias 'magit-read-upstream-branch #[128 "\211\203 \211A\262\242\202 \301 \211A\262\242\203$ \302\303\304\305G\\D\"\210\306\206- \307\310\"\311\312\313\314\315\316\317\n!\320\"\321\322%\323 \"\324\325 \"\"\326\211\211\327\330 \331 \211\203\\ \211 \232\203\\ \326\262\203h \206m \211\202m \211\206m \266\202\206\243 \332\333! \334\232?\205\200 \332\334!\203\214 \206\221 \211\202\221 \211\206\221 \266\202\206\243 \335 \211\n\232?\205\241 \211\262&\207" [magit-prefer-remote-upstream magit-get-current-branch signal wrong-number-of-arguments magit-read-upstream-branch 2 magit-completing-read format "Change upstream of %s to" -union mapcar make-byte-code 257 "\211\301\300Q\207" vconcat vector ["/"] 4 "\n\n(fn IT)" magit-list-remotes delete magit-list-branch-names nil magit-revision-history magit-remote-branch-at-point magit-branch-at-point magit-branch-p "origin/master" "master" magit-get-previous-branch] 14 (#$ . 78759)])
|
#@32
|
|
(fn PROMPT &optional BRANCH)
|
(defalias 'magit-read-starting-point #[513 "\301\205 \302\300!\203 \203 \303\304\"\202 \305\306\307\310#P\311Q\312C\313 \244\314\315 \316\317#\244\316\211\211\320\321 &\206: \322\323!\207" [ivy-mode magit-completing-read boundp format " `%s'" " " propertize face magit-branch-local " starting at" "HEAD" magit-list-refnames directory-files magit-git-dir nil "_HEAD\\'" magit-revision-history magit--default-starting-point user-error "Nothing selected"] 10 (#$ . 79783)])
|
(defalias 'magit--default-starting-point #[0 "\301 \302 \203 \206 \211\202 \211\206 \266\202\206& \303 \206& \304 \206& \305 \207" [magit-prefer-remote-upstream magit-remote-branch-at-point magit-local-branch-at-point magit-commit-at-point magit-stash-at-point magit-get-current-branch] 3])
|
#@39
|
|
(fn PROMPT &optional REQUIRE-MATCH)
|
(defalias 'magit-read-tag #[513 "\300\301 \302\302\303\304 &\207" [magit-completing-read magit-list-tags nil magit-revision-history magit-tag-at-point] 10 (#$ . 80599)])
|
#@15
|
|
(fn PROMPT)
|
(defalias 'magit-read-stash #[257 "\300 \301\302\303\302\211\304 @&\207" [magit-list-stashes magit-completing-read nil t magit-stash-at-point] 11 (#$ . 80816)])
|
#@42
|
|
(fn PROMPT &optional DEFAULT USE-ONLY)
|
(defalias 'magit-read-remote #[769 "\300 \203 \211G\301U\203 \211@\202' \302\303\304\303\211 \206% \305 \206% \306 &\207" [magit-list-remotes 1 magit-completing-read nil t magit-remote-at-point magit-get-remote] 12 (#$ . 81002)])
|
#@33
|
|
(fn PROMPT &optional DEFAULT)
|
(defalias 'magit-read-remote-or-url #[513 "\300\301 \302\303\304E\244\305\211\211\211\206 \306 \206 \307 &\207" [magit-completing-read magit-list-remotes "https://" "git://" "git@" nil magit-remote-at-point magit-get-remote] 10 (#$ . 81286)])
|
#@35
|
|
(fn PROMPT &optional PREDICATE)
|
(defalias 'magit-read-module-path #[513 "\300\301 \302\303\211\304!&\207" [magit-completing-read magit-list-module-paths t nil magit-module-at-point] 11 (#$ . 81573)])
|
#@33
|
|
(fn VERB &optional PREDICATE)
|
(defalias 'magit-module-confirm #[513 "\301\203* \302 \262\203 \303\"\262\211\204F \203# \304\305\"\210\202F \304\306!\210\202F \307\310!\262\211\203F \203= \303\"\262\211\204F \304\311\"\210\211G\312V\203[ \313\314\301\315\316\"\301%\202c \317\315\320\"\"C\207" [current-prefix-arg nil magit-list-module-paths -filter user-error "No modules satisfying %s available" "No modules available" magit-region-values magit-module-section "No modules satisfying %s selected" 1 magit-confirm t format "%s %%i modules" magit-read-module-path "%s module"] 9 (#$ . 81786)])
|
#@40
|
|
(fn VARIABLE WIDTH &optional GLOBAL)
|
(defalias 'magit--format-popup-variable:value #[770 "\300\301\302\303G#]\304\"\305\205 \306\"\211\203\" \307\310\311#\202' \307\312\310\313#\262Q\207" [make-string 1 - 3 32 magit-get "--global" propertize face magit-popup-option-value "unset" magit-popup-disabled-argument] 10 (#$ . 82406)])
|
#@40
|
|
(fn VARIABLE WIDTH &optional GLOBAL)
|
(defalias 'magit--format-popup-variable:values #[770 "\300\301\302\303G#]\304\"\305\205 \306\"\211\2036 \307@\310\311#\312\313\314\315\316\317 !\320\"\321\322%A\323#P\202; \307\324\310\325#\262Q\207" [make-string 1 - 3 32 magit-get-all "--global" propertize face magit-popup-option-value mapconcat make-byte-code 257 "\301\302\300\303\"\304\305\306#Q\207" vconcat vector ["\n" make-string 32 propertize face magit-popup-option-value] 7 "\n\n(fn VALUE)" "" "unset" magit-popup-disabled-argument] 14 (#$ . 82753)])
|
#@49
|
|
(fn VARIABLE CHOICES &optional DEFAULT OTHER)
|
(defalias 'magit--set-popup-variable #[1026 "\302\303\304\305#\211\203 \211\235A@\202 @\262\"\210\206 \211\203. r\211q\210\306 \210)\2021 \306 \210\210\307\310\311$#\207" [magit-current-pre-popup-buffer magit-pre-popup-buffer magit-set magit-git-string "config" "--local" magit-refresh message "%s %s" magit--format-popup-variable:choices*] 12 (#$ . 83324)])
|
#@55
|
|
(fn VARIABLE CHOICES &optional DEFAULT OTHER WIDTH)
|
(defalias 'magit--format-popup-variable:choices #[1282 "\203 \300GZ\301\"\202 \302\303$Q\207" [make-string 32 " " magit--format-popup-variable:choices*] 12 (#$ . 83757)])
|
#@49
|
|
(fn VARIABLE CHOICES &optional DEFAULT OTHER)
|
(defalias 'magit--format-popup-variable:choices* #[1026 "\300\301\302#\300\301\303#\203 \304!\211\205 \305Q\262\262\306\307\310\311#\312\313\314\315\316\317!\320\"\321\322%\306\323\310\311##\204F \204F \205\233 \306\323\310\311#\203n \306\324P\310\203] \311\202j \235\203i \325\202j \326#\202\232 \203\204 \306\310\203 \311\202\200 \325#\202\232 \205\232 \306\327P\310\203\230 \311\202\231 \325#P\306\330\310\311#R\207" [magit-git-string "config" "--local" "--global" magit-get ":" propertize "[" face magit-popup-disabled-argument mapconcat make-byte-code 257 "\301\302\300\232\203 \303\202 \304#\207" vconcat vector [propertize face magit-popup-option-value magit-popup-disabled-argument] 6 "\n\n(fn CHOICE)" "|" "global:" magit-popup-option-value font-lock-warning-face "default:" "]"] 14 (#$ . 84003)])
|
(provide 'magit-git)
|
