magit-git.el 79.7 KB
Newer Older
1
;;; magit-git.el --- Git functionality  -*- lexical-binding: t -*-
2

Jonas Bernoulli's avatar
Jonas Bernoulli committed
3
;; Copyright (C) 2010-2018  The Magit Project Contributors
4
;;
5 6
;; You should have received a copy of the AUTHORS.md file which
;; lists all contributors.  If not, see http://magit.vc/authors.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

;; Author: Jonas Bernoulli <jonas@bernoul.li>
;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>

;; Magit is free software; you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; Magit is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
;; License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with Magit.  If not, see http://www.gnu.org/licenses.

24 25 26 27
;;; Commentary:

;; This library implements wrappers for various Git plumbing commands.

28 29 30 31 32
;;; Code:

(require 'cl-lib)
(require 'dash)

33
(require 'magit-popup)
34 35 36
(require 'magit-utils)
(require 'magit-section)

Jonas Bernoulli's avatar
Jonas Bernoulli committed
37
(declare-function magit-call-git 'magit-process)
38
(declare-function magit-maybe-make-margin-overlay 'magit-log)
39
(declare-function magit-process-buffer 'magit-process)
Jonas Bernoulli's avatar
Jonas Bernoulli committed
40
(declare-function magit-process-file 'magit-process)
41
(declare-function magit-process-insert-section 'magit-process)
42
(declare-function magit-refresh 'magit-mode)
43
(defvar magit-process-error-message-regexps)
44
(defvar magit-refresh-args) ; from `magit-mode' for `magit-current-file'
45
(defvar magit-branch-prefer-remote-upstream)
46

47 48
(defvar magit-tramp-process-environment nil)

49 50 51 52 53 54 55
;;; Options

;; For now this is shared between `magit-process' and `magit-git'.
(defgroup magit-process nil
  "Git and other external processes used by Magit."
  :group 'magit)

56 57
(defvar magit-git-environment
  (list (format "INSIDE_EMACS=%s,magit" emacs-version))
58 59
  "Prepended to `process-environment' while running git.")

60 61 62 63 64 65 66 67 68 69 70 71
(defcustom magit-git-output-coding-system
  (and (eq system-type 'windows-nt) 'utf-8)
  "Coding system for receiving output from Git.

If non-nil, the Git config value `i18n.logOutputEncoding' should
be set via `magit-git-global-arguments' to value consistent with
this."
  :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)))

72
(defcustom magit-git-executable
73 74 75 76 77
  ;; Git might be installed in a different location on a remote, so
  ;; it is better not to use the full path to the executable, except
  ;; on Window were we would otherwise end up using one one of the
  ;; wrappers "cmd/git.exe" or "cmd/git.cmd", which are much slower
  ;; than using "bin/git.exe" directly.
78
  (or (and (eq system-type 'windows-nt)
79
           (--when-let (executable-find "git")
80 81 82 83 84 85 86 87 88 89 90 91
             (or (ignore-errors
                   ;; Git for Windows 2.x provides cygpath so we can
                   ;; ask it for native paths.  Using an upper case
                   ;; alias makes this fail on 1.x (which is good,
                   ;; because we would not want to end up using some
                   ;; other cygpath).
                   (prog1 (car
                           (process-lines
                            it "-c"
                            "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x"
                            "X" "git"))
                     (setq magit-git-environment
92
                           (cons (concat "PATH="
93 94 95
                                         (car (process-lines
                                               it "-c"
                                               "alias.P=!cygpath -wp \"$PATH\""
96 97
                                               "P")))
                                 magit-git-environment))))
98
                 ;; For 1.x, we search for bin/ next to cmd/.
99 100 101 102 103 104 105 106
                 (let ((alt (directory-file-name (file-name-directory it))))
                   (if (and (equal (file-name-nondirectory alt) "cmd")
                            (setq alt (expand-file-name
                                       (convert-standard-filename "bin/git.exe")
                                       (file-name-directory alt)))
                            (file-executable-p alt))
                       alt
                     it)))))
107 108 109 110 111
      "git")
  "The Git executable used by Magit."
  :group 'magit-process
  :type 'string)

112
(defcustom magit-git-global-arguments
113
  `("--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true"
114
    "-c" "log.showSignature=false"
115 116
    ,@(and (eq system-type 'windows-nt)
           (list "-c" "i18n.logOutputEncoding=UTF-8")))
117
  "Global Git arguments.
118 119 120 121 122 123 124 125 126 127 128 129

The arguments set here are used every time the git executable is
run as a subprocess.  They are placed right after the executable
itself and before the git command - as in `git HERE... COMMAND
REST'.  See the manpage `git(1)' for valid arguments.

Be careful what you add here, especially if you are using Tramp
to connect to servers with ancient Git versions.  Never remove
anything that is part of the default value, unless you really
know what you are doing.  And think very hard before adding
something; it will be used every time Magit runs Git for any
purpose."
130
  :package-version '(magit . "2.9.0")
131
  :group 'magit-git-arguments
132
  :group 'magit-process
133 134
  :type '(repeat string))

135
(defvar magit-git-debug nil
136
  "Whether to enable additional reporting of git errors.
137

138
Magit basically calls git for one of these two reasons: for
139 140
side-effects or to do something with its standard output.

141
When git is run for side-effects then its output, including error
142
messages, go into the process buffer which is shown when using \
143 144
\\<magit-status-mode-map>\\[magit-process].

145
When git's output is consumed in some way, then it would be too
146
expensive to also insert it into this buffer, but when this
147 148 149 150
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
151
permanently, that would negatively affect performance.")
152

153

154 155 156 157 158 159 160 161 162 163 164 165 166 167
(defcustom magit-prefer-remote-upstream nil
  "Whether to favor remote branches when reading the upstream branch.

This controls whether commands that read a branch from the user
and then set it as the upstream branch, offer a local or a remote
branch as default completion candidate, when they have the choice.

This affects all commands that use `magit-read-upstream-branch'
or `magit-read-starting-point', which includes all commands that
change the upstream and many which create new branches."
  :package-version '(magit . "2.4.2")
  :group 'magit-commands
  :type 'boolean)

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
(defcustom magit-list-refs-sortby nil
  "How to sort the ref collection in the prompt.

This affects commands that read a ref.  More specifically, it
controls the order of refs returned by `magit-list-refs', which
is called by functions like `magit-list-branch-names' to generate
the collection of refs.  By default, refs are sorted according to
their full refname (i.e., 'refs/...').

Any value accepted by the `--sort' flag of `git for-each-ref' can
be used.  For example, \"-creatordate\" places refs with more
recent committer or tagger dates earlier in the list.  A list of
strings can also be given in order to pass multiple sort keys to
`git for-each-ref'.

Note that, depending on the completion framework you use, this
may not be sufficient to change the order in which the refs are
displayed.  It only controls the order of the collection passed
to `magit-completing-read' or, for commands that support reading
multiple strings, `read-from-minibuffer'.  The completion
framework ultimately determines how the collection is displayed."
189
  :package-version '(magit . "2.11.0")
190 191 192
  :group 'magit-miscellanous
  :type '(choice string (repeat string)))

193 194
;;; Git

195 196 197
(defvar magit--refresh-cache nil)

(defmacro magit--with-refresh-cache (key &rest body)
198
  (declare (indent 1) (debug (form body)))
199 200 201 202 203 204 205 206 207 208 209 210 211
  (let ((k (cl-gensym)))
    `(if magit--refresh-cache
         (let ((,k ,key))
           (--if-let (assoc ,k (cdr magit--refresh-cache))
               (progn (cl-incf (caar magit--refresh-cache))
                      (cdr it))
             (cl-incf (cdar magit--refresh-cache))
             (let ((value ,(macroexp-progn body)))
               (push (cons ,k value)
                     (cdr magit--refresh-cache))
               value)))
       ,@body)))

212 213 214 215
(defmacro magit-with-editor (&rest body)
  "Like `with-editor' but let-bind some more variables."
  (declare (indent 0) (debug (body)))
  `(let ((magit-process-popup-time -1)
216 217 218 219 220 221
         ;; The user may have customized `shell-file-name' to
         ;; something which results in `w32-shell-dos-semantics' nil
         ;; (which changes the quoting style used by
         ;; `shell-quote-argument'), but Git for Windows expects shell
         ;; quoting in the dos style.
         (shell-file-name (if (and (eq system-type 'windows-nt)
222
                                   ;; If we have Cygwin mount points,
223 224 225 226 227
                                   ;; the git flavor is cygwin, so dos
                                   ;; shell quoting is probably wrong.
                                   (not magit-cygwin-mount-points))
                              "cmdproxy"
                            shell-file-name)))
228 229 230
     (with-editor "GIT_EDITOR"
       ,@body)))

231
(defun magit-process-git-arguments (args)
232 233 234 235 236 237 238
  "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.
239 240 241 242 243 244 245 246 247 248 249
* Prepend `magit-git-global-arguments' to ARGS.
* On w32 systems, encode to `w32-ansi-code-page'."
  (setq args (append magit-git-global-arguments (-flatten args)))
  (if (and (eq system-type 'windows-nt) (boundp 'w32-ansi-code-page))
      ;; On w32, the process arguments *must* be encoded in the
      ;; current code-page (see #3250).
      (mapcar (lambda (arg)
                (encode-coding-string
                 arg (intern (format "cp%d" w32-ansi-code-page))))
              args)
    args))
250 251 252

(defun magit-git-exit-code (&rest args)
  "Execute Git with ARGS, returning its exit code."
253
  (apply #'magit-process-file magit-git-executable nil nil nil
254 255 256 257 258 259 260 261 262 263
         (magit-process-git-arguments args)))

(defun magit-git-success (&rest args)
  "Execute Git with ARGS, returning t if its exit code is 0."
  (= (magit-git-exit-code args) 0))

(defun magit-git-failure (&rest args)
  "Execute Git with ARGS, returning t if its exit code is 1."
  (= (magit-git-exit-code args) 1))

264
(defun magit-git-str (&rest args)
265
  "Execute Git with ARGS, returning the first line of its output.
266 267
If there is no output, return nil.  If the output begins with a
newline, return an empty string.  Like `magit-git-string' but
268
ignore `magit-git-debug'."
269 270 271 272 273 274 275 276
  (setq args (-flatten args))
  (magit--with-refresh-cache (cons default-directory args)
    (with-temp-buffer
      (apply #'magit-process-file magit-git-executable nil (list t nil) nil
             (magit-process-git-arguments args))
      (unless (bobp)
        (goto-char (point-min))
        (buffer-substring-no-properties (point) (line-end-position))))))
277 278 279 280 281

(defun magit-git-true (&rest args)
  "Execute Git with ARGS, returning t if it prints \"true\".
Return t if the first (and usually only) output line is the
string \"true\", otherwise return nil."
282
  (equal (magit-git-str args) "true"))
283 284 285 286 287

(defun magit-git-false (&rest args)
  "Execute Git with ARGS, returning t if it prints \"false\".
Return t if the first (and usually only) output line is the
string \"false\", otherwise return nil."
288
  (equal (magit-git-str args) "false"))
289 290

(defun magit-git-insert (&rest args)
291
  "Execute Git with ARGS, inserting its output at point.
292 293
If Git exits with a non-zero exit status, then show a message and
add a section in the respective process buffer."
294
  (setq args (magit-process-git-arguments args))
295 296 297 298 299 300
  (if magit-git-debug
      (let (log)
        (unwind-protect
            (progn
              (setq log (make-temp-file "magit-stderr"))
              (delete-file log)
301
              (let ((exit (apply #'magit-process-file magit-git-executable
302 303 304 305 306 307 308
                                 nil (list t log) nil args)))
                (when (> exit 0)
                  (let ((msg "Git failed"))
                    (when (file-exists-p log)
                      (setq msg (with-temp-buffer
                                  (insert-file-contents log)
                                  (goto-char (point-max))
309 310 311
                                  (cond
                                   ((functionp magit-git-debug)
                                    (funcall magit-git-debug (buffer-string)))
312 313 314 315
                                   ((run-hook-wrapped
                                     'magit-process-error-message-regexps
                                     (lambda (re) (re-search-backward re nil t)))
                                    (match-string-no-properties 1)))))
316
                      (let ((magit-git-debug nil))
317
                        (with-current-buffer (magit-process-buffer t)
318 319
                          (magit-process-insert-section default-directory
                                                        magit-git-executable
320 321 322 323
                                                        args exit log))))
                    (message "%s" msg)))
                exit))
          (ignore-errors (delete-file log))))
324 325
    (apply #'magit-process-file magit-git-executable
           nil (list t nil) nil args)))
326

327 328
(defun magit-git-string (&rest args)
  "Execute Git with ARGS, returning the first line of its output.
329 330
If there is no output, return nil.  If the output begins with a
newline, return an empty string."
331 332 333 334 335 336 337
  (setq args (-flatten args))
  (magit--with-refresh-cache (cons default-directory args)
    (with-temp-buffer
      (apply #'magit-git-insert args)
      (unless (bobp)
        (goto-char (point-min))
        (buffer-substring-no-properties (point) (line-end-position))))))
338

339 340
(defun magit-git-lines (&rest args)
  "Execute Git with ARGS, returning its output as a list of lines.
341 342 343 344
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."
345
  (with-temp-buffer
346 347
    (apply #'magit-git-insert args)
    (split-string (buffer-string) "\n" t)))
348

349 350 351 352 353 354 355 356 357 358
(defun magit-git-items (&rest args)
  "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."
  (with-temp-buffer
    (apply #'magit-git-insert args)
    (split-string (buffer-string) "\0" t)))

359 360 361
(defun magit-git-wash (washer &rest args)
  "Execute Git with ARGS, inserting washed output at point.
Actually first insert the raw output at point.  If there is no
362
output, call `magit-cancel-section'.  Otherwise temporarily narrow
363
the buffer to the inserted text, move to its beginning, and then
364
call function WASHER with ARGS as its sole argument."
365 366
  (declare (indent 1))
  (let ((beg (point)))
367
    (setq args (-flatten args))
368 369 370 371 372 373 374 375 376 377 378
    (magit-git-insert args)
    (if (= (point) beg)
        (magit-cancel-section)
      (unless (bolp)
        (insert "\n"))
      (save-restriction
        (narrow-to-region beg (point))
        (goto-char beg)
        (funcall washer args))
      (when (or (= (point) beg)
                (= (point) (1+ beg)))
379 380
        (magit-cancel-section))
      (magit-maybe-make-margin-overlay))))
381

382
(defun magit-git-version (&optional raw)
383 384
  (--when-let (let (magit-git-global-arguments)
                (ignore-errors (substring (magit-git-string "version") 12)))
385 386
    (if raw it (and (string-match "^\\([0-9]+\\.[0-9]+\\.[0-9]+\\)" it)
                    (match-string 1 it)))))
387

388 389
;;; Files

390 391 392 393 394
(defun magit--safe-default-directory (&optional file)
  (catch 'unsafe-default-dir
    (let ((dir (file-name-as-directory
                (expand-file-name (or file default-directory))))
          (previous nil))
395
      (while (not (magit-file-accessible-directory-p dir))
396 397 398 399 400 401
        (setq dir (file-name-directory (directory-file-name dir)))
        (when (equal dir previous)
          (throw 'unsafe-default-dir nil))
        (setq previous dir))
      dir)))

402
(defmacro magit--with-safe-default-directory (file &rest body)
403
  (declare (indent 1) (debug (form body)))
404 405
  `(-when-let (default-directory (magit--safe-default-directory ,file))
     ,@body))
406

407
(defun magit-git-dir (&optional path)
408 409 410 411 412
  "Return absolute path to the control directory of the current repository.

All symlinks are followed.  If optional PATH is non-nil, then
it has to be a path relative to the control directory and its
absolute path is returned."
413 414
  (magit--with-refresh-cache (list default-directory 'magit-git-dir path)
    (magit--with-safe-default-directory nil
415
      (-when-let (dir (magit-rev-parse-safe "--git-dir"))
416 417 418
        (setq dir (file-name-as-directory (magit-expand-git-file-name dir)))
        (unless (file-remote-p dir)
          (setq dir (concat (file-remote-p default-directory) dir)))
419
        (if path (expand-file-name (convert-standard-filename path) dir) dir)))))
420

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
(defvar magit--separated-gitdirs nil)

(defun magit--record-separated-gitdir ()
  (let ((topdir (magit-toplevel))
        (gitdir (magit-git-dir)))
    ;; We want to delete the entry for `topdir' here, rather than within
    ;; (unless ...), in case a `--separate-git-dir' repository was switched to
    ;; the standard structure (i.e., "topdir/.git/").
    (setq magit--separated-gitdirs (cl-delete topdir
                                            magit--separated-gitdirs
                                            :key #'car :test #'equal))
    (unless (equal (file-name-as-directory (expand-file-name ".git" topdir))
                   gitdir)
      (push (cons topdir gitdir) magit--separated-gitdirs))))

436
(defun magit-toplevel (&optional directory)
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
  "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."
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
  (magit--with-refresh-cache
      (cons (or directory default-directory) 'magit-toplevel)
    (magit--with-safe-default-directory directory
      (-if-let (topdir (magit-rev-parse-safe "--show-toplevel"))
          (let (updir)
            (setq topdir (magit-expand-git-file-name topdir))
            (if (and
                 ;; Always honor these settings.
                 (not find-file-visit-truename)
                 (not (getenv "GIT_WORK_TREE"))
                 ;; `--show-cdup' is the relative path to the toplevel
                 ;; from `(file-truename default-directory)'.  Here we
                 ;; pretend it is relative to `default-directory', and
                 ;; go to that directory.  Then we check whether
                 ;; `--show-toplevel' still returns the same value and
                 ;; whether `--show-cdup' now is the empty string.  If
                 ;; both is the case, then we are at the toplevel of
                 ;; the same working tree, but also avoided needlessly
                 ;; following any symlinks.
                 (progn
                   (setq updir (file-name-as-directory
                                (magit-rev-parse-safe "--show-cdup")))
                   (setq updir (if (file-name-absolute-p updir)
                                   (concat (file-remote-p default-directory) updir)
                                 (expand-file-name updir)))
                   (let ((default-directory updir))
                     (and (string-equal (magit-rev-parse-safe "--show-cdup") "")
                          (--when-let (magit-rev-parse-safe "--show-toplevel")
                            (string-equal (magit-expand-git-file-name it)
                                          topdir))))))
                updir
              (concat (file-remote-p default-directory)
                      (file-name-as-directory topdir))))
        (-when-let (gitdir (magit-rev-parse-safe "--git-dir"))
          (setq gitdir (file-name-as-directory
                        (if (file-name-absolute-p gitdir)
                            ;; We might have followed a symlink.
                            (concat (file-remote-p default-directory)
                                    (magit-expand-git-file-name gitdir))
                          (expand-file-name gitdir))))
          (if (magit-bare-repo-p)
              gitdir
            (let* ((link (expand-file-name "gitdir" gitdir))
                   (wtree (and (file-exists-p link)
                               (magit-file-line link))))
500 501 502 503 504 505 506 507 508 509 510 511
              (cond
               ((and wtree
                     ;; Ignore .git/gitdir files that result from a
                     ;; Git bug.  See #2364.
                     (not (equal wtree ".git")))
                ;; Return the linked working tree.
                (file-name-directory wtree))
               ;; The working directory may not be the parent directory of
               ;; .git if it was set up with `git init --separate-git-dir'.
               ;; See #2955.
               ((car (rassoc gitdir magit--separated-gitdirs)))
               (t
512
                ;; Step outside the control directory to enter the working tree.
513
                (file-name-directory (directory-file-name gitdir)))))))))))
514 515

(defmacro magit-with-toplevel (&rest body)
516
  (declare (indent defun) (debug (body)))
517 518 519 520 521
  (let ((toplevel (cl-gensym "toplevel")))
    `(let ((,toplevel (magit-toplevel)))
       (if ,toplevel
           (let ((default-directory ,toplevel))
             ,@body)
522 523 524 525 526 527 528
         (magit--not-inside-repository-error)))))

(defun magit--not-inside-repository-error ()
  (if (executable-find magit-git-executable)
      (user-error "Not inside a Git repository: %s" default-directory)
    (user-error "The `git' executable cannot be found.  See %s"
                "https://magit.vc/goto/e6a78ed2")))
529 530 531

(defun magit-inside-gitdir-p ()
  "Return t if `default-directory' is below a repository directory."
532 533
  ;; This does not work if the gitdir is not located inside the
  ;; working tree: (magit-rev-parse-p "--is-inside-git-dir").
Sean Allred's avatar
Sean Allred committed
534 535
  (-when-let (gitdir (magit-git-dir))
    (file-in-directory-p default-directory gitdir)))
536 537 538 539 540 541 542 543 544 545 546 547

(defun magit-inside-worktree-p ()
  "Return t if `default-directory' is below the work tree of a repository."
  (magit-rev-parse-p "--is-inside-work-tree"))

(defun magit-bare-repo-p ()
  "Return t if the current repository is bare."
  (magit-rev-parse-p "--is-bare-repository"))

(defun magit-git-repo-p (directory &optional non-bare)
  "Return t if DIRECTORY is a Git repository.
When optional NON-BARE is non-nil also return nil if DIRECTORY is
548
a bare repository."
549 550 551 552 553 554 555 556 557 558 559 560 561 562
  (or (file-regular-p (expand-file-name ".git" directory))
      (file-directory-p (expand-file-name ".git" directory))
      (and (not non-bare)
           (file-regular-p (expand-file-name "HEAD" directory))
           (file-directory-p (expand-file-name "refs" directory))
           (file-directory-p (expand-file-name "objects" directory)))))

(defvar-local magit-buffer-revision  nil)
(defvar-local magit-buffer-refname   nil)
(defvar-local magit-buffer-file-name nil)
(put 'magit-buffer-revision  'permanent-local t)
(put 'magit-buffer-refname   'permanent-local t)
(put 'magit-buffer-file-name 'permanent-local t)

563
(defun magit-file-relative-name (&optional file tracked)
564
  "Return the path of FILE relative to the repository root.
565

566
If optional FILE is nil or omitted, return the relative path of
567
the file being visited in the current buffer, if any, else nil.
568
If the file is not inside a Git repository, then return nil.
569 570 571

If TRACKED is non-nil, return the path only if it matches a
tracked file."
572 573 574 575
  (unless file
    (with-current-buffer (or (buffer-base-buffer)
                             (current-buffer))
      (setq file (or magit-buffer-file-name buffer-file-name))))
576
  (when (and file (or (not tracked)
577
                      (magit-file-tracked-p (file-relative-name file))))
578
    (--when-let (magit-toplevel
579 580
                 (magit--safe-default-directory
                  (directory-file-name (file-name-directory file))))
581
      (file-relative-name file it))))
582 583 584 585

(defun magit-file-tracked-p (file)
  (magit-git-success "ls-files" "--error-unmatch" file))

586
(defun magit-list-files (&rest args)
587
  (apply #'magit-git-items "ls-files" "-z" "--full-name" args))
588

589
(defun magit-tracked-files ()
590
  (magit-list-files "--cached"))
591

592 593
(defun magit-untracked-files (&optional all files)
  (magit-list-files "--other" (unless all "--exclude-standard") "--" files))
594

595
(defun magit-unstaged-files (&optional nomodules files)
596
  (magit-git-items "diff-files" "-z" "--name-only"
597 598
                   (and nomodules "--ignore-submodules")
                   "--" files))
599

600
(defun magit-staged-files (&optional nomodules files)
601
  (magit-git-items "diff-index" "-z" "--name-only" "--cached"
602
                   (and nomodules "--ignore-submodules")
603
                   (magit-headish) "--" files))
604

605 606 607 608 609 610
(defun magit-staged-binary-files ()
  (--mapcat (and (string-match "^-\t-\t\\(.+\\)" it)
                 (list (match-string 1 it)))
            (magit-git-items "diff" "-z" "--cached"
                             "--numstat" "--ignore-submodules")))

611
(defun magit-unmerged-files ()
612
  (magit-git-items "diff-files" "-z" "--name-only" "--diff-filter=U"))
613 614

(defun magit-revision-files (rev)
615
  (magit-with-toplevel
616
    (magit-git-items "ls-tree" "-z" "-r" "--name-only" rev)))
617

618 619 620 621 622
(defun magit-changed-files (rev-or-range &optional other-rev)
  "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>)."
623
  (magit-with-toplevel
624 625 626 627 628
    (magit-git-items "diff" "-z" "--name-only" rev-or-range other-rev)))

(defun magit-renamed-files (revA revB)
  (--map (cons (nth 1 it) (nth 2 it))
         (-partition 3 (magit-git-items
629
                        "diff-tree" "-r" "--diff-filter=R" "-z" "-M"
630
                        revA revB))))
631

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
(defun magit-file-status (&rest args)
  (with-temp-buffer
    (save-excursion (magit-git-insert "status" "-z" args))
    (let ((pos (point)) status)
      (while (> (skip-chars-forward "[:print:]") 0)
        (let ((x (char-after     pos))
              (y (char-after (1+ pos)))
              (file (buffer-substring (+ pos 3) (point))))
          (forward-char)
          (if (memq x '(?R ?C))
              (progn
                (setq pos (point))
                (skip-chars-forward "[:print:]")
                (push (list file (buffer-substring pos (point)) x y) status)
                (forward-char))
            (push (list file nil x y) status)))
        (setq pos (point)))
      status)))
650

651 652 653
(defcustom magit-cygwin-mount-points
  (when (eq system-type 'windows-nt)
    (cl-sort (--map (if (string-match "^\\(.*\\) on \\(.*\\) type" it)
654 655
                        (cons (file-name-as-directory (match-string 2 it))
                              (file-name-as-directory (match-string 1 it)))
656 657
                      (lwarn '(magit) :error
                             "Failed to parse Cygwin mount: %S" it))
658 659
                    ;; If --exec-path is not a native Windows path,
                    ;; then we probably have a cygwin git.
660 661 662 663 664 665 666
                    (let ((process-environment
                           (append magit-git-environment process-environment)))
                      (and (not (string-match-p
                                 "\\`[a-zA-Z]:"
                                 (car (process-lines
                                       magit-git-executable "--exec-path"))))
                           (ignore-errors (process-lines "mount")))))
667
             #'> :key (-lambda ((cyg . _win)) (length cyg))))
668 669
  "Alist of (CYGWIN . WIN32) directory names.
Sorted from longest to shortest CYGWIN name."
670 671 672 673
  :package-version '(magit . "2.3.0")
  :group 'magit-process
  :type '(alist :key-type string :value-type directory))

674 675 676
(defun magit-expand-git-file-name (filename)
  (unless (file-name-absolute-p filename)
    (setq filename (expand-file-name filename)))
677 678 679 680
  (-if-let ((cyg . win)
            (cl-assoc filename magit-cygwin-mount-points
                      :test (lambda (f cyg) (string-prefix-p cyg f))))
      (concat win (substring filename (length cyg)))
681
    filename))
682

683 684 685 686 687 688 689 690 691 692 693 694
(defun magit-convert-filename-for-git (filename)
  "Convert FILENAME so that it can be passed to git.
1. If it's a remote filename, then remove the remote part.
2. Expand \"~/\", git isn't a shell and does not understand it.
3. Deal with an `windows-nt' Emacs vs. Cygwin Git incompatibility."
  (if (file-name-absolute-p filename)
      (-if-let ((cyg . win)
                (cl-rassoc filename magit-cygwin-mount-points
                           :test (lambda (f win) (string-prefix-p win f))))
          (concat cyg (substring filename (length win)))
        (or (file-remote-p filename 'localname)
            filename))
695 696
    filename))

697 698
(defun magit-decode-git-path (path)
  (if (eq (aref path 0) ?\")
699 700 701 702
      (decode-coding-string (read path)
                            (or magit-git-output-coding-system
                                (car default-process-coding-system))
                            t)
703 704 705 706
    path))

(defun magit-file-at-point ()
  (magit-section-case
707
    (file (oref it value))
708 709 710 711 712 713
    (hunk (magit-section-parent-value it))))

(defun magit-current-file ()
  (or (magit-file-relative-name)
      (magit-file-at-point)
      (and (derived-mode-p 'magit-log-mode)
714
           (car (nth 2 magit-refresh-args)))))
715 716 717 718 719

;;; Predicates

(defun magit-no-commit-p ()
  "Return t if there is no commit in the current Git repository."
720
  (not (magit-rev-verify "HEAD")))
721

722 723 724 725
(defun magit-merge-commit-p (commit)
  "Return t if COMMIT is a merge commit."
  (> (length (magit-commit-parents commit)) 1))

726
(defun magit-anything-staged-p (&optional ignore-submodules &rest files)
727 728 729
  "Return t if there are any staged changes.
If optional FILES is non-nil, then only changes to those files
are considered."
730 731 732
  (magit-git-failure "diff" "--quiet" "--cached"
                     (and ignore-submodules "--ignore-submodules")
                     "--" files))
733

734
(defun magit-anything-unstaged-p (&optional ignore-submodules &rest files)
735 736 737
  "Return t if there are any unstaged changes.
If optional FILES is non-nil, then only changes to those files
are considered."
738 739 740
  (magit-git-failure "diff" "--quiet"
                     (and ignore-submodules "--ignore-submodules")
                     "--" files))
741

742
(defun magit-anything-modified-p (&optional ignore-submodules &rest files)
743 744 745
  "Return t if there are any staged or unstaged changes.
If optional FILES is non-nil, then only changes to those files
are considered."
746 747
  (or (apply 'magit-anything-staged-p   ignore-submodules files)
      (apply 'magit-anything-unstaged-p ignore-submodules files)))
748 749 750 751 752 753 754 755 756 757 758

(defun magit-anything-unmerged-p (&rest files)
  "Return t if there are any merge conflicts.
If optional FILES is non-nil, then only conflicts in those files
are considered."
  (and (magit-git-string "ls-files" "--unmerged" files) t))

;;; Revisions and References

(defun magit-rev-parse (&rest args)
  "Execute `git rev-parse ARGS', returning first line of output.
759
If there is no output, return nil."
760 761
  (apply #'magit-git-string "rev-parse" args))

762 763
(defun magit-rev-parse-safe (&rest args)
  "Execute `git rev-parse ARGS', returning first line of output.
764
If there is no output, return nil.  Like `magit-rev-parse' but
765 766 767
ignore `magit-git-debug'."
  (apply #'magit-git-str "rev-parse" args))

768 769 770 771 772 773
(defun magit-rev-parse-p (&rest args)
  "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."
  (magit-git-true "rev-parse" args))

774
(defun magit-rev-verify (rev)
775
  (magit-rev-parse-safe "--verify" rev))
776

777 778 779 780
(defun magit-rev-verify-commit (rev)
  "Return full hash for REV if it names an existing commit."
  (magit-rev-verify (concat rev "^{commit}")))

781 782 783
(defun magit-rev-equal (a b)
  (magit-git-success "diff" "--quiet" a b))

784 785 786 787
(defun magit-rev-eq (a b)
  (equal (magit-rev-verify a)
         (magit-rev-verify b)))

788 789 790 791
(defun magit-rev-ancestor-p (a b)
  "Return non-nil if commit A is an ancestor of commit B."
  (magit-git-success "merge-base" "--is-ancestor" a b))

792
(defun magit-rev-head-p (rev)
793
  (or (equal rev "HEAD")
794 795 796 797
      (and rev
           (not (string-match-p "\\.\\." rev))
           (equal (magit-rev-parse rev)
                  (magit-rev-parse "HEAD")))))
798

799
(defun magit-rev-name (rev &optional pattern)
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
  "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."
  (--when-let (magit-git-string "name-rev" "--name-only" "--no-undefined"
                                (and pattern (concat "--refs=" pattern))
                                rev)
    ;; We can't use name-rev's --exclude to filter out "*/PATTERN"
    ;; because --exclude wasn't added until Git v2.13.0.
    (if (and pattern
             (string-match-p "\\`refs/[^/]+/\\*\\'" pattern))
        (let ((namespace (substring pattern 0 -1)))
          (unless (and (string-match-p namespace it)
                       (not (magit-rev-verify (concat namespace it))))
            it))
      it)))
818

819 820 821 822
(defun magit-rev-branch (rev)
  (--when-let (magit-rev-name rev "refs/heads/*")
    (unless (string-match-p "~" it) it)))

823
(defun magit-get-shortname (rev)
824 825 826 827
  (let* ((fn (apply-partially 'magit-rev-name rev))
         (name (or (funcall fn "refs/tags/*")
                   (funcall fn "refs/heads/*")
                   (funcall fn "refs/remotes/*"))))
828 829 830 831 832 833 834
    (cond ((not name)
           (magit-rev-parse "--short" rev))
          ((string-match "^\\(?:tags\\|remotes\\)/\\(.+\\)" name)
           (if (magit-ref-ambiguous-p (match-string 1 name))
               name
             (match-string 1 name)))
          (t (magit-ref-maybe-qualify name)))))
835

836 837 838 839 840 841 842
(defun magit-name-branch (rev &optional lax)
  (or (magit-name-local-branch rev)
      (magit-name-remote-branch rev)
      (and lax (or (magit-name-local-branch rev t)
                   (magit-name-remote-branch rev t)))))

(defun magit-name-local-branch (rev &optional lax)
843
  (--when-let (magit-rev-name rev "refs/heads/*")
844
    (and (or lax (not (string-match-p "[~^]" it))) it)))
845 846

(defun magit-name-remote-branch (rev &optional lax)
847
  (--when-let (magit-rev-name rev "refs/remotes/*")
848
    (and (or lax (not (string-match-p "[~^]" it)))
849 850 851
         (substring it 8))))

(defun magit-name-tag (rev &optional lax)
852
  (--when-let (magit-rev-name rev "refs/tags/*")
853
    (and (or lax (not (string-match-p "[~^]" it)))
854 855
         (substring it 5))))

856
(defun magit-ref-fullname (name)
857 858 859 860 861 862 863 864 865
  "Return fully qualified refname for NAME.
If NAME is ambiguous, return nil.  NAME may include suffixes such
as \"^1\" and \"~3\".  "
  (save-match-data
    (if (string-match "\\`\\([^^~]+\\)\\(.*\\)" name)
        (--when-let (magit-rev-parse "--symbolic-full-name"
                                     (match-string 1 name))
          (concat it (match-string 2 name)))
      (error "`name' has an unrecognized format"))))
866

867 868 869
(defun magit-ref-ambiguous-p (name)
  (not (magit-ref-fullname name)))

870 871 872 873 874 875
(cl-defun magit-ref-maybe-qualify (name &optional (prefix "heads/"))
  "If NAME is ambiguous, prepend PREFIX to it."
  (concat (and (magit-ref-ambiguous-p name)
               prefix)
          name))

876 877 878
(defun magit-ref-exists-p (ref)
  (magit-git-success "show-ref" "--verify" ref))

879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
(defun magit-ref-equal (a b)
  "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."
  (equal (magit-ref-fullname a)
         (magit-ref-fullname b)))

(defun magit-ref-eq (a b)
  "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."
  (let ((symbolic-a (magit-symbolic-ref-p a))
        (symbolic-b (magit-symbolic-ref-p b)))
    (or (and symbolic-a
             symbolic-b
             (equal a b))
        (and (not symbolic-a)
             (not symbolic-b)
             (magit-ref-equal a b)))))

899 900 901 902 903 904 905
(defun magit-headish ()
  "Return \"HEAD\" or if that doesn't exist the hash of the empty tree."
  (if (magit-no-commit-p)
      (magit-git-string "mktree")
    "HEAD"))

(defun magit-branch-at-point ()
906
  (magit-section-case
907 908
    (branch (oref it value))
    (commit (magit-name-branch (oref it value)))))
909

910
(defun magit-local-branch-at-point ()
911
  (magit-section-case
912
    (branch (let ((branch (magit-ref-maybe-qualify (oref it value))))
913 914
              (when (member branch (magit-list-local-branch-names))
                branch)))
915
    (commit (magit-name-local-branch (oref it value)))))
916 917

(defun magit-remote-branch-at-point ()
918
  (magit-section-case
919
    (branch (let ((branch (oref it value)))
920 921
              (when (member branch (magit-list-remote-branch-names))
                branch)))
922
    (commit (magit-name-remote-branch (oref it value)))))
923

924
(defun magit-commit-at-point ()
925 926
  (or (magit-section-when commit)
      (and (derived-mode-p 'magit-revision-mode)
927
           (car magit-refresh-args))))
928 929

(defun magit-branch-or-commit-at-point ()
930 931
  (or magit-buffer-refname
      (magit-section-case
932 933
        (branch (magit-ref-maybe-qualify (oref it value)))
        (commit (let ((rev (oref it value)))
934
                  (or (magit-get-shortname rev) rev)))
935
        (tag (magit-ref-maybe-qualify (oref it value) "tags/")))
936
      (thing-at-point 'git-revision t)
937 938
      (and (derived-mode-p 'magit-revision-mode
                           'magit-merge-preview-mode)
939
           (car magit-refresh-args))))
940

941
(defun magit-tag-at-point ()
942
  (magit-section-case
943 944
    (tag    (oref it value))
    (commit (magit-name-tag (oref it value)))))
945

946
(defun magit-stash-at-point ()
947 948 949 950
  (magit-section-when stash))

(defun magit-remote-at-point ()
  (magit-section-case
951
    (remote (oref it value))
952 953 954 955 956 957 958 959 960
    (branch (magit-section-parent-value it))))

(defun magit-get-current-branch ()
  "Return the refname of the currently checked out branch.
Return nil if no branch is currently checked out."
  (magit-git-string "symbolic-ref" "--short" "HEAD"))

(defun magit-get-previous-branch ()
  "Return the refname of the previously checked out branch.
961 962
Return nil if no branch can be found in the `HEAD' reflog
which is different from the current branch and still exists."
963 964
  (let ((current (magit-get-current-branch))
        (i 1) prev)
965
    (while (and (setq prev (magit-rev-verify (format "@{-%i}" i)))
966 967
                (or (not (setq prev (magit-rev-branch prev)))
                    (equal prev current)))
968 969 970
      (cl-incf i))
    prev))

971 972 973 974 975 976 977 978 979 980 981
(defun magit-get-upstream-ref (&optional branch)
  (and (or branch (setq branch (magit-get-current-branch)))
       (let ((remote (magit-get "branch" branch "remote"))
             (merge  (magit-get "branch" branch "merge")))
         (when (and remote merge)
           (cond ((string-equal remote ".") merge)
                 ((string-prefix-p "refs/heads/" merge)
                  (concat "refs/remotes/" remote "/" (substring merge 11))))))))

(defun magit-get-upstream-branch (&optional branch verify)
  (and (or branch (setq branch (magit-get-current-branch)))
982 983 984 985 986
       (-when-let* ((remote (magit-get "branch" branch "remote"))
                    (merge  (magit-get "branch" branch "merge")))
         (and (string-prefix-p "refs/heads/" merge)
              (let* ((upstream (substring merge 11))
                     (upstream
987 988 989 990 991 992 993 994
                      (cond ((string-equal remote ".")
                             (propertize upstream 'face 'magit-branch-local))
                            ((string-match-p "[@:]" remote)
                             (propertize (concat remote " " upstream)
                                         'face 'magit-branch-remote))
                            (t
                             (propertize (concat remote "/" upstream)
                                         'face 'magit-branch-remote)))))
995 996 997
                (and (or (not verify)
                         (magit-rev-verify upstream))
                     upstream))))))
998

999
(defun magit-get-indirect-upstream-branch (branch &optional force)
1000 1001
  (let ((remote (magit-get "branch" branch "remote")))
    (and remote (not (equal remote "."))
1002
         ;; The user has opted in...
1003 1004 1005 1006 1007
         (or force
             (--any (if (magit-git-success "check-ref-format" "--branch" it)
                        (equal it branch)
                      (string-match-p it branch))
                    magit-branch-prefer-remote-upstream))
1008
         ;; and local BRANCH tracks a remote branch...
1009 1010 1011 1012 1013 1014 1015 1016 1017
         (let ((upstream (magit-get-upstream-branch branch)))
           ;; whose upstream...
           (and upstream
                ;; has the same name as BRANCH and...
                (equal (substring upstream (1+ (length remote))) branch)
                ;; and can be fast-forwarded to BRANCH.
                (magit-rev-ancestor-p upstream branch)
                upstream)))))

1018 1019 1020
(defun magit-get-upstream-remote (&optional branch)
  (and (or branch (setq branch (magit-get-current-branch)))
       (magit-get "branch" branch "remote")))
1021

1022 1023 1024
(defun magit-get-push-remote (&optional branch)
  (or (and (or branch (setq branch (magit-get-current-branch)))
           (magit-get "branch" branch "pushRemote"))
1025 1026
      (magit-get "remote.pushDefault")))

1027 1028
(defun magit-get-push-branch (&optional branch verify)
  (and (or branch (setq branch (magit-get-current-branch)))
1029 1030 1031 1032 1033
       (-when-let* ((remote (magit-get-push-remote branch))
                    (push-branch (concat remote "/" branch)))
         (and (or (not verify)
                  (magit-rev-verify push-branch))
              push-branch))))
1034

1035 1036 1037 1038 1039 1040
(defun magit-get-@{push}-branch (&optional branch)
  (let ((ref (magit-rev-parse "--symbolic-full-name"
                              (concat branch "@{push}"))))
    (when (and ref (string-prefix-p "refs/remotes/" ref))
      (substring ref 13))))

1041 1042
(defun magit-get-remote (&optional branch)
  (when (or branch (setq branch (magit-get-current-branch)))
1043 1044 1045 1046
    (let ((remote (magit-get "branch" branch "remote")))
      (unless (equal remote ".")
        remote))))

1047 1048 1049 1050 1051 1052 1053 1054
(defun magit-get-some-remote (&optional branch)
  (or (magit-get-remote branch)
      (and (magit-branch-p "master")
           (magit-get-remote "master"))
      (let ((remotes (magit-list-remotes)))
        (or (car (member "origin" remotes))
            (car remotes)))))

1055
(defun magit-branch-merged-p (branch &optional target)
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
  "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."
  (and (--if-let (and (magit-branch-p branch)
                      (magit-get-upstream-branch branch))
           (magit-git-success "merge-base" "--is-ancestor" branch it)
         t)
       (if (eq target t)
           (delete (magit-name-local-branch branch)
                   (magit-list-containing-branches branch))
         (--when-let (or target (magit-get-current-branch))
           (magit-git-success "merge-base" "--is-ancestor" branch it)))))
1075

1076 1077 1078
(defun magit-split-branch-name (branch)
  (cond ((member branch (magit-list-local-branch-names))
         (cons "." branch))
1079 1080 1081
        ((string-match " " branch)
         (pcase-let ((`(,url ,branch) (split-string branch " ")))
           (cons url branch)))
1082 1083 1084 1085 1086
        ((string-match "/" branch)
         (let ((remote (substring branch 0 (match-beginning 0))))
           (if (save-match-data (member remote (magit-list-remotes)))
               (cons remote (substring branch (match-end 0)))
             (error "Invalid branch name %s" branch))))))
1087

1088 1089
(defun magit-get-current-tag (&optional rev with-distance)
  "Return the closest tag reachable from REV.
1090

1091
If optional REV is nil, then default to `HEAD'.
1092 1093
If optional WITH-DISTANCE is non-nil then return (TAG COMMITS),
if it is `dirty' return (TAG COMMIT DIRTY). COMMITS is the number
1094
of commits in `HEAD' but not in TAG and DIRTY is t if there are
1095
uncommitted changes, nil otherwise."
1096 1097
  (--when-let (magit-git-str "describe" "--long" "--tags"
                             (and (eq with-distance 'dirty) "--dirty") rev)
1098 1099 1100 1101
    (save-match-data
      (string-match
       "\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" it)
      (if with-distance
1102 1103 1104
          `(,(match-string 1 it)
            ,(string-to-number (or (match-string 2 it) "0"))
            ,@(and (match-string 3 it) (list t)))
1105 1106
        (match-string 1 it)))))

1107 1108
(defun magit-get-next-tag (&optional rev with-distance)
  "Return the closest tag from which REV is reachable.
1109

1110
If optional REV is nil, then default to `HEAD'.
1111
If no such tag can be found or if the distance is 0 (in which
1112 1113
case it is the current tag, not the next), return nil instead.
If optional WITH-DISTANCE is non-nil, then return (TAG COMMITS)
1114
where COMMITS is the number of commits in TAG but not in REV."
1115
  (--when-let (magit-git-str "describe" "--contains" (or rev "HEAD"))
1116 1117 1118
    (save-match-data
      (when (string-match "^[^^~]+" it)
        (setq it (match-string 0 it))
1119
        (unless (equal it (magit-get-current-tag rev))
1120
          (if with-distance
1121
              (list it (car (magit-rev-diff-count it rev)))
1122 1123
            it))))))

1124
(defvar magit-list-refs-namespaces
1125
  '("refs/heads" "refs/remotes" "refs/tags" "refs/pull"))
1126

1127
(defun magit-list-refs (&optional namespaces format sortby)
1128 1129 1130 1131 1132 1133
  "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
1134 1135 1136 1137
defaults to \"%(refname)\".

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'"
1138 1139
  (magit-git-lines "for-each-ref"
                   (concat "--format=" (or format "%(refname)"))
1140 1141 1142 1143
                   (--map (concat "--sort=" it)
                          (pcase (or sortby magit-list-refs-sortby)
                            ((and val (pred stringp)) (list val))
                            ((and val (pred listp)) val)))
1144
                   (or namespaces magit-list-refs-namespaces)))
1145 1146

(defun magit-list-branches ()
1147
  (magit-list-refs (list "refs/heads" "refs/remotes")))
1148 1149 1150 1151 1152 1153 1154

(defun magit-list-local-branches ()
  (magit-list-refs "refs/heads"))

(defun magit-list-remote-branches (&optional remote)
  (magit-list-refs (concat "refs/remotes/" remote)))

1155
(defun magit-list-containing-branches (&optional commit)
1156 1157 1158
  (--filter (not (string-match-p "\\`(HEAD" it))
            (--map (substring it 2)
                   (magit-git-lines "branch" "--contains" commit))))
1159

1160
(defun magit-list-merged-branches (&optional commit)
1161 1162 1163
  (--filter (not (string-match-p "\\`(HEAD" it))
            (--map (substring it 2)
                   (magit-git-lines "branch" "--merged" commit))))
1164

1165
(defun magit-list-unmerged-branches (&optional commit)
1166 1167 1168
  (--filter (not (string-match-p "\\`(HEAD" it))
            (--map (substring it 2)
                   (magit-git-lines "branch" "--no-merged" commit))))
1169 1170

(defun magit-list-unmerged-to-upstream-branches ()
1171
  (--filter (-when-let (upstream (magit-get-upstream-branch it))
1172 1173 1174
              (member it (magit-list-unmerged-branches upstream)))
            (magit-list-local-branch-names)))

1175 1176 1177 1178 1179 1180 1181 1182 1183
(defun magit-list-branches-pointing-at (commit)
  (let ((re (format "\\`%s refs/\\(heads\\|remotes\\)/\\(.*\\)\\'"
                   (magit-rev-verify commit))))
    (--keep (and (string-match re it)
                 (let ((name (match-string 2 it)))
                   (and (not (string-suffix-p "HEAD" name))
                        name)))
            (magit-git-lines "show-ref"))))

1184 1185
(defun magit-list-refnames (&optional namespaces)
  (magit-list-refs namespaces "%(refname:short)"))
1186 1187

(defun magit-list-branch-names ()
1188
  (magit-list-refnames (list "refs/heads" "refs/remotes")))
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200

(defun magit-list-local-branch-names ()
  (magit-list-refnames "refs/heads"))

(defun magit-list-remote-branch-names (&optional remote relative)
  (if (and remote relative)
      (let ((regexp (format "^refs/remotes/%s/\\(.+\\)" remote)))
        (--mapcat (when (string-match regexp it)
                    (list (match-string 1 it)))
                  (magit-list-remote-branches remote)))
    (magit-list-refnames (concat "refs/remotes/" remote))))

1201 1202 1203 1204 1205 1206 1207 1208
(defun magit-format-refs (format &rest args)
  (let ((lines (magit-git-lines
                "for-each-ref" (concat "--format=" format)
                (or args (list "refs/heads" "refs/remotes" "refs/tags")))))
    (if (string-match-p "\f" format)
        (--map (split-string it "\f") lines)
      lines)))

1209 1210 1211 1212 1213 1214
(defun magit-list-remotes ()
  (magit-git-lines "remote"))

(defun magit-list-tags ()
  (magit-git-lines "tag"))

1215 1216 1217
(defun magit-list-stashes (&optional format)
  (magit-git-lines "stash" "list" (concat "--format=" (or format "%gd"))))

1218 1219 1220
(defun magit-list-active-notes-refs ()
  "Return notes refs according to `core.notesRef' and `notes.displayRef'."
  (magit-git-lines "for-each-ref" "--format=%(refname)"
1221
                   (or (magit-get "core.notesRef") "refs/notes/commits")
1222 1223
                   (magit-get-all "notes.displayRef")))

Jonas Bernoulli's avatar
Jonas Bernoulli committed
1224 1225 1226
(defun magit-list-notes-refnames ()
  (--map (substring it 6) (magit-list-refnames "refs/notes")))

1227
(defun magit-remote-list-tags (remote)
1228 1229 1230
  (--keep (and (not (string-match-p "\\^{}$" it))
               (substring it 51))
          (magit-git-lines "ls-remote" "--tags" remote)))
1231

1232
(defun magit-remote-list-branches (remote)
1233 1234 1235
  (--keep (and (not (string-match-p "\\^{}$" it))
               (substring it 52))
          (magit-git-lines "ls-remote" "--heads" remote)))
1236

1237 1238 1239 1240 1241
(defun magit-remote-list-refs (remote)
  (--keep (and (not (string-match-p "\\^{}$" it))
               (substring it 41))
          (magit-git-lines "ls-remote" remote)))

1242
(defun magit-get-submodules ()
1243 1244 1245
  (--mapcat (and (string-match "^160000 [0-9a-z]\\{40\\} 0\t\\(.+\\)$" it)
                 (list (match-string 1 it)))
            (magit-git-items "ls-files" "-z" "--stage")))
1246

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
(defun magit-get-submodule-name (path)
  "Return the name of the submodule at PATH.
PATH has to be relative to the super-repository."
  (cadr (split-string
         (car (or (magit-git-items
                   "config" "-z"
                   "-f" (expand-file-name ".gitmodules" (magit-toplevel))
                   "--get-regexp" "^submodule\\..*\\.path$"
                   (concat "^" (regexp-quote (directory-file-name path)) "$"))
                  (error "No such submodule `%s'" path)))
         "\n")))

1259 1260
(defun magit-list-worktrees ()
  (let (worktrees worktree)
1261
    (dolist (line (let ((magit-git-global-arguments
1262
                         ;; KLUDGE At least in v2.8.3 this triggers a segfault.
1263
                         (remove "--no-pager" magit-git-global-arguments)))
1264
                    (magit-git-lines "worktree" "list" "--porcelain")))
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
      (cond ((string-prefix-p "worktree" line)
             (push (setq worktree (list (substring line 9) nil nil nil))
                   worktrees))
            ((string-equal line "bare")
             (let* ((default-directory (car worktree))
                    (wt (and (not (magit-get-boolean "core.bare"))
                             (magit-get "core.worktree"))))
               (if (and wt (file-exists-p (expand-file-name wt)))
                   (progn (setf (nth 0 worktree) (expand-file-name wt))
                          (setf (nth 2 worktree) (magit-rev-parse "HEAD"))
                          (setf (nth 3 worktree) (magit-get-current-branch)))
                 (setf (nth 1 worktree) t))))
            ((string-prefix-p "HEAD" line)
             (setf (nth 2 worktree) (substring line 5)))
            ((string-prefix-p "branch" line)
             (setf (nth 3 worktree) (substring line 18)))
            ((string-equal line "detached"))))
    (nreverse worktrees)))

1284 1285 1286
(defun magit-symbolic-ref-p (name)
  (magit-git-success "symbolic-ref" "--quiet" name))

1287 1288 1289 1290
(defun magit-ref-p (rev)
  (or (car (member rev (magit-list-refs)))
      (car (member rev (magit-list-refnames)))))

1291 1292 1293
(defun magit-branch-p (rev)
  (or (car (member rev (magit-list-branches)))
      (car (member rev (magit-list-branch-names)))))
1294

1295 1296 1297
(defun magit-local-branch-p (rev)
  (or (car (member rev (magit-list-local-branches)))
      (car (member rev (magit-list-local-branch-names)))))
1298

1299 1300 1301 1302
(defun magit-remote-branch-p (rev)
  (or (car (member rev (magit-list-remote-branches)))
      (car (member rev (magit-list-remote-branch-names)))))

1303 1304 1305 1306 1307
(defun magit-branch-set-face (branch)
  (propertize branch 'face (if (magit-local-branch-p branch)
                               'magit-branch-local
                             'magit-branch-remote)))

1308 1309 1310
(defun magit-tag-p (rev)
  (car (member rev (magit-list-tags))))

1311 1312 1313
(defun magit-remote-p (string)
  (car (member string (magit-list-remotes))))

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
(defun magit-rev-diff-count (a b)
  "Return the commits in A but not B and vice versa.
Return a list of two integers: (A>B B>A)."
  (mapcar 'string-to-number
          (split-string (magit-git-string "rev-list"
                                          "--count" "--left-right"
                                          (concat a "..." b))
                        "\t")))

(defun magit-abbrev-length ()
1324 1325
  (--if-let (magit-get "core.abbrev")
      (string-to-number it)
1326 1327 1328 1329 1330 1331 1332
    ;; Guess the length git will be using based on an example
    ;; abbreviation.  Actually HEAD's abbreviation might be an
    ;; outlier, so use the shorter of the abbreviations for two
    ;; commits.  When a commit does not exist, then fall back
    ;; to the default of 7.  See #3034.
    (min (--if-let (magit-rev-parse "--short" "HEAD")  (length it) 7)
         (--if-let (magit-rev-parse "--short" "HEAD~") (length it) 7))))
1333

1334 1335 1336 1337 1338
(defun magit-abbrev-arg (&optional arg)
  (format "--%s=%d" (or arg "abbrev") (magit-abbrev-length)))

(defun magit-rev-abbrev (rev)
  (magit-rev-parse (magit-abbrev-arg "short") rev))
1339

1340 1341 1342 1343 1344 1345 1346 1347 1348
(defun magit-commit-children (commit &optional args)
  (-map #'car
        (--filter (member commit (cdr it))
                  (--map (split-string it " ")
                         (magit-git-lines
                          "log" "--format=%H %P"
                          (or args (list "--branches" "--tags" "--remotes"))
                          "--not" commit)))))

1349
(defun magit-commit-parents (commit)
1350 1351
  (--when-let (magit-git-string "rev-list" "-1" "--parents" commit)
    (cdr (split-string it))))
1352

1353 1354
(defun magit-patch-id (rev)
  (with-temp-buffer
1355 1356 1357 1358
    (magit-process-file
     shell-file-name nil '(t nil) nil shell-command-switch
     (let ((exec (shell-quote-argument magit-git-executable)))
       (format "%s diff-tree -u %s | %s patch-id" exec rev exec)))
1359 1360
    (car (split-string (buffer-string)))))

1361 1362 1363
(defun magit-rev-format (format &optional rev args)
  (let ((str (magit-git-string "show" "--no-patch"
                               (concat "--format=" format) args
1364
                               (if rev (concat rev "^{commit}") "HEAD") "--")))
1365 1366
    (unless (string-equal str "")
      str)))
1367

1368 1369 1370
(defun magit-rev-insert-format (format &optional rev args)
  (magit-git-insert "show" "--no-patch"
                    (concat "--format=" format) args
1371
                    (if rev (concat rev "^{commit}") "HEAD") "--"))
1372

1373 1374 1375 1376 1377 1378
(defun magit-format-rev-summary (rev)
  (--when-let (magit-rev-format "%h %s" rev)
    (string-match " " it)
    (put-text-property 0 (match-beginning 0) 'face 'magit-hash it)
    it))

1379
(defvar magit-ref-namespaces
1380
  '(("\\`HEAD\\'"                  . magit-head)
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
    ("\\`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)
    ("\\`\\(bad\\):"               . magit-bisect-bad)
    ("\\`\\(skip\\):"              . magit-bisect-skip)
    ("\\`\\(good\\):"              . magit-bisect-good)
1392
    ("\\`\\(.+\\)"                 . magit-refname))
1393 1394 1395
  "How refs are formatted for display.

Each entry controls how a certain type of ref is displayed, and
1396 1397 1398 1399
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.  The first regexp submatch becomes the
\"label\" that represents the ref and is propertized with FONT.")
1400

1401
(defun magit-format-ref-labels (string)
1402 1403 1404 1405 1406 1407
  ;; To support Git <2.2.0, we remove the surrounding parentheses here
  ;; rather than specifying that STRING should be generated with Git's
  ;; "%D" placeholder.
  (setq string (->> string
                    (replace-regexp-in-string "\\`\\s-*(" "")
                    (replace-regexp-in-string ")\\s-*\\'" "")))
1408
  (save-match-data
1409 1410
    (let ((regexp "\\(, \\|tag: \\|HEAD -> \\)")
          names)
Jonas Bernoulli's avatar
Jonas Bernoulli committed
1411
      (if (and (derived-mode-p 'magit-log-mode)
1412
               (member "--simplify-by-decoration" (cadr magit-refresh-args)))
Jonas Bernoulli's avatar
Jonas Bernoulli committed
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
          (let ((branches (magit-list-local-branch-names))
                (re (format "^%s/.+" (regexp-opt (magit-list-remotes)))))
            (setq names
                  (--map (cond ((string-equal it "HEAD")     it)
                               ((string-prefix-p "refs/" it) it)
                               ((member it branches) (concat "refs/heads/" it))
                               ((string-match re it) (concat "refs/remotes/" it))
                               (t                    (concat "refs/" it)))
                         (split-string
                          (replace-regexp-in-string "tag: " "refs/tags/" string)
1423 1424
                          regexp t))))
        (setq names (split-string string regexp t)))
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
      (let (state head tags branches remotes other combined)
        (dolist (ref names)
          (let* ((face (cdr (--first (string-match (car it) ref)
                                     magit-ref-namespaces)))
                 (name (propertize (or (match-string 1 ref) ref) 'face face)))
            (cl-case face
              ((magit-bisect-bad magit-bisect-skip magit-bisect-good)
               (setq state name))
              (magit-head
               (setq head (propertize "@" 'face 'magit-head)))
              (magit-tag            (push name tags))
              (magit-branch-local   (push name branches))
              (magit-branch-remote  (push name remotes))
              (t                    (push name other)))))
        (setq remotes
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
              (-keep
               (lambda (name)
                 (if (string-match "\\`\\([^/]*\\)/\\(.*\\)\\'" name)
                     (let ((r (match-string 1 name))
                           (b (match-string 2 name)))
                       (and (not (equal b "HEAD"))
                            (if (equal (concat "refs/remotes/" name)
                                       (magit-git-string
                                        "symbolic-ref"
                                        (format "refs/remotes/%s/HEAD" r)))
                                (propertize name
                                            'face 'magit-branch-remote-head)
                              name)))
                   name))
               remotes))
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
        (dolist (name branches)
          (let ((push (car (member (magit-get-push-branch name) remotes))))
            (when push
              (setq remotes (delete push remotes))
              (string-match "^[^/]*/" push)
              (setq push (substring push 0 (match-end 0))))
            (if (equal name (magit-get-current-branch))
                (setq head
                      (concat push
                              (propertize name 'face 'magit-branch-current)))
              (push (concat push name) combined))))
        (mapconcat #'identity
                   (-flatten `(,state
                               ,head
                               ,@(nreverse tags)
                               ,@(nreverse combined)
                               ,@(nreverse remotes)
                               ,@other))
                   " ")))))
1474

1475 1476 1477
(defun magit-object-type (object)
  (magit-git-string "cat-file" "-t" object))

1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
(defmacro magit-with-blob (commit file &rest body)
  (declare (indent 2)
           (debug (form form body)))
  `(with-temp-buffer
     (let ((buffer-file-name ,file))
       (save-excursion
         (magit-git-insert "cat-file" "-p"
                           (concat ,commit ":" buffer-file-name)))
       (decode-coding-inserted-region
        (point-min) (point-max) buffer-file-name t nil nil t)
       ,@body)))

1490 1491
(defmacro magit-with-temp-index (tree arg &rest body)
  (declare (indent 2) (debug (form form body)))
1492
  (let ((file (cl-gensym "file")))
1493 1494
    `(let ((magit--refresh-cache nil)
           (,file (magit-convert-filename-for-git
1495
                   (make-temp-name (magit-git-dir "index.magit.")))))
1496
       (unwind-protect