Fix MS-Windows build.
[emacs.git] / lisp / vc / vc-git.el
blob472c42840af135b7f28c3f1346838a62ed04fef0
1 ;;; vc-git.el --- VC backend for the git version control system -*- lexical-binding: t -*-
3 ;; Copyright (C) 2006-2013 Free Software Foundation, Inc.
5 ;; Author: Alexandre Julliard <julliard@winehq.org>
6 ;; Keywords: vc tools
7 ;; Package: vc
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24 ;;; Commentary:
26 ;; This file contains a VC backend for the git version control
27 ;; system.
30 ;;; Installation:
32 ;; To install: put this file on the load-path and add Git to the list
33 ;; of supported backends in `vc-handled-backends'; the following line,
34 ;; placed in your init file, will accomplish this:
36 ;; (add-to-list 'vc-handled-backends 'Git)
38 ;;; Todo:
39 ;; - check if more functions could use vc-git-command instead
40 ;; of start-process.
41 ;; - changelog generation
43 ;; Implement the rest of the vc interface. See the comment at the
44 ;; beginning of vc.el. The current status is:
45 ;; ("??" means: "figure out what to do about it")
47 ;; FUNCTION NAME STATUS
48 ;; BACKEND PROPERTIES
49 ;; * revision-granularity OK
50 ;; STATE-QUERYING FUNCTIONS
51 ;; * registered (file) OK
52 ;; * state (file) OK
53 ;; - state-heuristic (file) NOT NEEDED
54 ;; * working-revision (file) OK
55 ;; - latest-on-branch-p (file) NOT NEEDED
56 ;; * checkout-model (files) OK
57 ;; - workfile-unchanged-p (file) OK
58 ;; - mode-line-string (file) OK
59 ;; STATE-CHANGING FUNCTIONS
60 ;; * create-repo () OK
61 ;; * register (files &optional rev comment) OK
62 ;; - init-revision (file) NOT NEEDED
63 ;; - responsible-p (file) OK
64 ;; - could-register (file) NOT NEEDED, DEFAULT IS GOOD
65 ;; - receive-file (file rev) NOT NEEDED
66 ;; - unregister (file) OK
67 ;; * checkin (files rev comment) OK
68 ;; * find-revision (file rev buffer) OK
69 ;; * checkout (file &optional editable rev) OK
70 ;; * revert (file &optional contents-done) OK
71 ;; - rollback (files) COULD BE SUPPORTED
72 ;; - merge (file rev1 rev2) It would be possible to merge
73 ;; changes into a single file, but
74 ;; when committing they wouldn't
75 ;; be identified as a merge
76 ;; by git, so it's probably
77 ;; not a good idea.
78 ;; - merge-news (file) see `merge'
79 ;; - steal-lock (file &optional revision) NOT NEEDED
80 ;; HISTORY FUNCTIONS
81 ;; * print-log (files buffer &optional shortlog start-revision limit) OK
82 ;; - log-view-mode () OK
83 ;; - show-log-entry (revision) OK
84 ;; - comment-history (file) ??
85 ;; - update-changelog (files) COULD BE SUPPORTED
86 ;; * diff (file &optional rev1 rev2 buffer) OK
87 ;; - revision-completion-table (files) OK
88 ;; - annotate-command (file buf &optional rev) OK
89 ;; - annotate-time () OK
90 ;; - annotate-current-time () NOT NEEDED
91 ;; - annotate-extract-revision-at-line () OK
92 ;; TAG SYSTEM
93 ;; - create-tag (dir name branchp) OK
94 ;; - retrieve-tag (dir name update) OK
95 ;; MISCELLANEOUS
96 ;; - make-version-backups-p (file) NOT NEEDED
97 ;; - repository-hostname (dirname) NOT NEEDED
98 ;; - previous-revision (file rev) OK
99 ;; - next-revision (file rev) OK
100 ;; - check-headers () COULD BE SUPPORTED
101 ;; - clear-headers () NOT NEEDED
102 ;; - delete-file (file) OK
103 ;; - rename-file (old new) OK
104 ;; - find-file-hook () NOT NEEDED
106 ;;; Code:
108 (eval-when-compile
109 (require 'cl-lib)
110 (require 'vc)
111 (require 'vc-dir)
112 (require 'grep))
114 (defgroup vc-git nil
115 "VC Git backend."
116 :version "24.1"
117 :group 'vc)
119 (defcustom vc-git-diff-switches t
120 "String or list of strings specifying switches for Git diff under VC.
121 If nil, use the value of `vc-diff-switches'. If t, use no switches."
122 :type '(choice (const :tag "Unspecified" nil)
123 (const :tag "None" t)
124 (string :tag "Argument String")
125 (repeat :tag "Argument List" :value ("") string))
126 :version "23.1"
127 :group 'vc-git)
129 (defcustom vc-git-program "git"
130 "Name of the Git executable (excluding any arguments)."
131 :version "24.1"
132 :type 'string
133 :group 'vc-git)
135 (defcustom vc-git-root-log-format
136 '("%d%h..: %an %ad %s"
137 ;; The first shy group matches the characters drawn by --graph.
138 ;; We use numbered groups because `log-view-message-re' wants the
139 ;; revision number to be group 1.
140 "^\\(?:[*/\\| ]+ \\)?\\(?2: ([^)]+)\\)?\\(?1:[0-9a-z]+\\)..: \
141 \\(?3:.*?\\)[ \t]+\\(?4:[0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\}\\)"
142 ((1 'log-view-message-face)
143 (2 'change-log-list nil lax)
144 (3 'change-log-name)
145 (4 'change-log-date)))
146 "Git log format for `vc-print-root-log'.
147 This should be a list (FORMAT REGEXP KEYWORDS), where FORMAT is a
148 format string (which is passed to \"git log\" via the argument
149 \"--pretty=tformat:FORMAT\"), REGEXP is a regular expression
150 matching the resulting Git log output, and KEYWORDS is a list of
151 `font-lock-keywords' for highlighting the Log View buffer."
152 :type '(list string string (repeat sexp))
153 :group 'vc-git
154 :version "24.1")
156 (defvar vc-git-commits-coding-system 'utf-8
157 "Default coding system for git commits.")
159 ;; History of Git commands.
160 (defvar vc-git-history nil)
162 ;;; BACKEND PROPERTIES
164 (defun vc-git-revision-granularity () 'repository)
165 (defun vc-git-checkout-model (_files) 'implicit)
167 ;;; STATE-QUERYING FUNCTIONS
169 ;;;###autoload (defun vc-git-registered (file)
170 ;;;###autoload "Return non-nil if FILE is registered with git."
171 ;;;###autoload (if (vc-find-root file ".git") ; Short cut.
172 ;;;###autoload (progn
173 ;;;###autoload (load "vc-git" nil t)
174 ;;;###autoload (vc-git-registered file))))
176 (defun vc-git-registered (file)
177 "Check whether FILE is registered with git."
178 (let ((dir (vc-git-root file)))
179 (when dir
180 (with-temp-buffer
181 (let* (process-file-side-effects
182 ;; Do not use the `file-name-directory' here: git-ls-files
183 ;; sometimes fails to return the correct status for relative
184 ;; path specs.
185 ;; See also: http://marc.info/?l=git&m=125787684318129&w=2
186 (name (file-relative-name file dir))
187 (str (ignore-errors
188 (cd dir)
189 (vc-git--out-ok "ls-files" "-c" "-z" "--" name)
190 ;; If result is empty, use ls-tree to check for deleted
191 ;; file.
192 (when (eq (point-min) (point-max))
193 (vc-git--out-ok "ls-tree" "--name-only" "-z" "HEAD"
194 "--" name))
195 (buffer-string))))
196 (and str
197 (> (length str) (length name))
198 (string= (substring str 0 (1+ (length name)))
199 (concat name "\0"))))))))
201 (defun vc-git--state-code (code)
202 "Convert from a string to a added/deleted/modified state."
203 (pcase (string-to-char code)
204 (?M 'edited)
205 (?A 'added)
206 (?D 'removed)
207 (?U 'edited) ;; FIXME
208 (?T 'edited))) ;; FIXME
210 (defun vc-git-state (file)
211 "Git-specific version of `vc-state'."
212 ;; FIXME: This can't set 'ignored or 'conflict yet
213 ;; The 'ignored state could be detected with `git ls-files -i -o
214 ;; --exclude-standard` It also can't set 'needs-update or
215 ;; 'needs-merge. The rough equivalent would be that upstream branch
216 ;; for current branch is in fast-forward state i.e. current branch
217 ;; is direct ancestor of corresponding upstream branch, and the file
218 ;; was modified upstream. But we can't check that without a network
219 ;; operation.
220 ;; This assumes that status is known to be not `unregistered' because
221 ;; we've been successfully dispatched here from `vc-state', that
222 ;; means `vc-git-registered' returned t earlier once. Bug#11757
223 (let ((diff (vc-git--run-command-string
224 file "diff-index" "-p" "--raw" "-z" "HEAD" "--")))
225 (if (and diff
226 (string-match ":[0-7]\\{6\\} [0-7]\\{6\\} [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\([ADMUT]\\)\0[^\0]+\0\\(.*\n.\\)?"
227 diff))
228 (let ((diff-letter (match-string 1 diff)))
229 (if (not (match-beginning 2))
230 ;; Empty diff: file contents is the same as the HEAD
231 ;; revision, but timestamps are different (eg, file
232 ;; was "touch"ed). Update timestamp in index:
233 (prog1 'up-to-date
234 (vc-git--call nil "add" "--refresh" "--"
235 (file-relative-name file)))
236 (vc-git--state-code diff-letter)))
237 (if (vc-git--empty-db-p) 'added 'up-to-date))))
239 (defun vc-git-working-revision (file)
240 "Git-specific version of `vc-working-revision'."
241 (let* (process-file-side-effects
242 (str (vc-git--run-command-string nil "symbolic-ref" "HEAD")))
243 (vc-file-setprop file 'vc-git-detached (null str))
244 (if str
245 (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
246 (match-string 2 str)
247 str)
248 (vc-git--rev-parse "HEAD"))))
250 (defun vc-git-workfile-unchanged-p (file)
251 (eq 'up-to-date (vc-git-state file)))
253 (defun vc-git-mode-line-string (file)
254 "Return a string for `vc-mode-line' to put in the mode line for FILE."
255 (let* ((rev (vc-working-revision file))
256 (detached (vc-file-getprop file 'vc-git-detached))
257 (def-ml (vc-default-mode-line-string 'Git file))
258 (help-echo (get-text-property 0 'help-echo def-ml)))
259 (propertize (if detached
260 (substring def-ml 0 (- 7 (length rev)))
261 def-ml)
262 'help-echo (concat help-echo "\nCurrent revision: " rev))))
264 (cl-defstruct (vc-git-extra-fileinfo
265 (:copier nil)
266 (:constructor vc-git-create-extra-fileinfo
267 (old-perm new-perm &optional rename-state orig-name))
268 (:conc-name vc-git-extra-fileinfo->))
269 old-perm new-perm ;; Permission flags.
270 rename-state ;; Rename or copy state.
271 orig-name) ;; Original name for renames or copies.
273 (defun vc-git-escape-file-name (name)
274 "Escape a file name if necessary."
275 (if (string-match "[\n\t\"\\]" name)
276 (concat "\""
277 (mapconcat (lambda (c)
278 (pcase c
279 (?\n "\\n")
280 (?\t "\\t")
281 (?\\ "\\\\")
282 (?\" "\\\"")
283 (_ (char-to-string c))))
284 name "")
285 "\"")
286 name))
288 (defun vc-git-file-type-as-string (old-perm new-perm)
289 "Return a string describing the file type based on its permissions."
290 (let* ((old-type (lsh (or old-perm 0) -9))
291 (new-type (lsh (or new-perm 0) -9))
292 (str (pcase new-type
293 (?\100 ;; File.
294 (pcase old-type
295 (?\100 nil)
296 (?\120 " (type change symlink -> file)")
297 (?\160 " (type change subproject -> file)")))
298 (?\120 ;; Symlink.
299 (pcase old-type
300 (?\100 " (type change file -> symlink)")
301 (?\160 " (type change subproject -> symlink)")
302 (t " (symlink)")))
303 (?\160 ;; Subproject.
304 (pcase old-type
305 (?\100 " (type change file -> subproject)")
306 (?\120 " (type change symlink -> subproject)")
307 (t " (subproject)")))
308 (?\110 nil) ;; Directory (internal, not a real git state).
309 (?\000 ;; Deleted or unknown.
310 (pcase old-type
311 (?\120 " (symlink)")
312 (?\160 " (subproject)")))
313 (_ (format " (unknown type %o)" new-type)))))
314 (cond (str (propertize str 'face 'font-lock-comment-face))
315 ((eq new-type ?\110) "/")
316 (t ""))))
318 (defun vc-git-rename-as-string (state extra)
319 "Return a string describing the copy or rename associated with INFO,
320 or an empty string if none."
321 (let ((rename-state (when extra
322 (vc-git-extra-fileinfo->rename-state extra))))
323 (if rename-state
324 (propertize
325 (concat " ("
326 (if (eq rename-state 'copy) "copied from "
327 (if (eq state 'added) "renamed from "
328 "renamed to "))
329 (vc-git-escape-file-name
330 (vc-git-extra-fileinfo->orig-name extra))
331 ")")
332 'face 'font-lock-comment-face)
333 "")))
335 (defun vc-git-permissions-as-string (old-perm new-perm)
336 "Format a permission change as string."
337 (propertize
338 (if (or (not old-perm)
339 (not new-perm)
340 (eq 0 (logand ?\111 (logxor old-perm new-perm))))
342 (if (eq 0 (logand ?\111 old-perm)) "+x" "-x"))
343 'face 'font-lock-type-face))
345 (defun vc-git-dir-printer (info)
346 "Pretty-printer for the vc-dir-fileinfo structure."
347 (let* ((isdir (vc-dir-fileinfo->directory info))
348 (state (if isdir "" (vc-dir-fileinfo->state info)))
349 (extra (vc-dir-fileinfo->extra info))
350 (old-perm (when extra (vc-git-extra-fileinfo->old-perm extra)))
351 (new-perm (when extra (vc-git-extra-fileinfo->new-perm extra))))
352 (insert
354 (propertize (format "%c" (if (vc-dir-fileinfo->marked info) ?* ? ))
355 'face 'font-lock-type-face)
357 (propertize
358 (format "%-12s" state)
359 'face (cond ((eq state 'up-to-date) 'font-lock-builtin-face)
360 ((eq state 'missing) 'font-lock-warning-face)
361 (t 'font-lock-variable-name-face))
362 'mouse-face 'highlight)
363 " " (vc-git-permissions-as-string old-perm new-perm)
365 (propertize (vc-git-escape-file-name (vc-dir-fileinfo->name info))
366 'face (if isdir 'font-lock-comment-delimiter-face
367 'font-lock-function-name-face)
368 'help-echo
369 (if isdir
370 "Directory\nVC operations can be applied to it\nmouse-3: Pop-up menu"
371 "File\nmouse-3: Pop-up menu")
372 'keymap vc-dir-filename-mouse-map
373 'mouse-face 'highlight)
374 (vc-git-file-type-as-string old-perm new-perm)
375 (vc-git-rename-as-string state extra))))
377 (defun vc-git-after-dir-status-stage (stage files update-function)
378 "Process sentinel for the various dir-status stages."
379 (let (next-stage result)
380 (goto-char (point-min))
381 (pcase stage
382 (`update-index
383 (setq next-stage (if (vc-git--empty-db-p) 'ls-files-added
384 (if files 'ls-files-up-to-date 'diff-index))))
385 (`ls-files-added
386 (setq next-stage 'ls-files-unknown)
387 (while (re-search-forward "\\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} 0\t\\([^\0]+\\)\0" nil t)
388 (let ((new-perm (string-to-number (match-string 1) 8))
389 (name (match-string 2)))
390 (push (list name 'added (vc-git-create-extra-fileinfo 0 new-perm))
391 result))))
392 (`ls-files-up-to-date
393 (setq next-stage 'diff-index)
394 (while (re-search-forward "\\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} 0\t\\([^\0]+\\)\0" nil t)
395 (let ((perm (string-to-number (match-string 1) 8))
396 (name (match-string 2)))
397 (push (list name 'up-to-date
398 (vc-git-create-extra-fileinfo perm perm))
399 result))))
400 (`ls-files-unknown
401 (when files (setq next-stage 'ls-files-ignored))
402 (while (re-search-forward "\\([^\0]*?\\)\0" nil t 1)
403 (push (list (match-string 1) 'unregistered
404 (vc-git-create-extra-fileinfo 0 0))
405 result)))
406 (`ls-files-ignored
407 (while (re-search-forward "\\([^\0]*?\\)\0" nil t 1)
408 (push (list (match-string 1) 'ignored
409 (vc-git-create-extra-fileinfo 0 0))
410 result)))
411 (`diff-index
412 (setq next-stage 'ls-files-unknown)
413 (while (re-search-forward
414 ":\\([0-7]\\{6\\}\\) \\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\(\\([ADMUT]\\)\0\\([^\0]+\\)\\|\\([CR]\\)[0-9]*\0\\([^\0]+\\)\0\\([^\0]+\\)\\)\0"
415 nil t 1)
416 (let ((old-perm (string-to-number (match-string 1) 8))
417 (new-perm (string-to-number (match-string 2) 8))
418 (state (or (match-string 4) (match-string 6)))
419 (name (or (match-string 5) (match-string 7)))
420 (new-name (match-string 8)))
421 (if new-name ; Copy or rename.
422 (if (eq ?C (string-to-char state))
423 (push (list new-name 'added
424 (vc-git-create-extra-fileinfo old-perm new-perm
425 'copy name))
426 result)
427 (push (list name 'removed
428 (vc-git-create-extra-fileinfo 0 0
429 'rename new-name))
430 result)
431 (push (list new-name 'added
432 (vc-git-create-extra-fileinfo old-perm new-perm
433 'rename name))
434 result))
435 (push (list name (vc-git--state-code state)
436 (vc-git-create-extra-fileinfo old-perm new-perm))
437 result))))))
438 (when result
439 (setq result (nreverse result))
440 (when files
441 (dolist (entry result) (setq files (delete (car entry) files)))
442 (unless files (setq next-stage nil))))
443 (when (or result (not next-stage))
444 (funcall update-function result next-stage))
445 (when next-stage
446 (vc-git-dir-status-goto-stage next-stage files update-function))))
448 ;; Follows vc-git-command (or vc-do-async-command), which uses vc-do-command
449 ;; from vc-dispatcher.
450 (declare-function vc-exec-after "vc-dispatcher" (code))
451 ;; Follows vc-exec-after.
452 (declare-function vc-set-async-update "vc-dispatcher" (process-buffer))
454 (defun vc-git-dir-status-goto-stage (stage files update-function)
455 (erase-buffer)
456 (pcase stage
457 (`update-index
458 (if files
459 (vc-git-command (current-buffer) 'async files "add" "--refresh" "--")
460 (vc-git-command (current-buffer) 'async nil
461 "update-index" "--refresh")))
462 (`ls-files-added
463 (vc-git-command (current-buffer) 'async files
464 "ls-files" "-z" "-c" "-s" "--"))
465 (`ls-files-up-to-date
466 (vc-git-command (current-buffer) 'async files
467 "ls-files" "-z" "-c" "-s" "--"))
468 (`ls-files-unknown
469 (vc-git-command (current-buffer) 'async files
470 "ls-files" "-z" "-o" "--directory"
471 "--no-empty-directory" "--exclude-standard" "--"))
472 (`ls-files-ignored
473 (vc-git-command (current-buffer) 'async files
474 "ls-files" "-z" "-o" "-i" "--directory"
475 "--no-empty-directory" "--exclude-standard" "--"))
476 ;; --relative added in Git 1.5.5.
477 (`diff-index
478 (vc-git-command (current-buffer) 'async files
479 "diff-index" "--relative" "-z" "-M" "HEAD" "--")))
480 (vc-exec-after
481 `(vc-git-after-dir-status-stage ',stage ',files ',update-function)))
483 (defun vc-git-dir-status (_dir update-function)
484 "Return a list of (FILE STATE EXTRA) entries for DIR."
485 ;; Further things that would have to be fixed later:
486 ;; - how to handle unregistered directories
487 ;; - how to support vc-dir on a subdir of the project tree
488 (vc-git-dir-status-goto-stage 'update-index nil update-function))
490 (defun vc-git-dir-status-files (_dir files _default-state update-function)
491 "Return a list of (FILE STATE EXTRA) entries for FILES in DIR."
492 (vc-git-dir-status-goto-stage 'update-index files update-function))
494 (defvar vc-git-stash-map
495 (let ((map (make-sparse-keymap)))
496 ;; Turn off vc-dir marking
497 (define-key map [mouse-2] 'ignore)
499 (define-key map [down-mouse-3] 'vc-git-stash-menu)
500 (define-key map "\C-k" 'vc-git-stash-delete-at-point)
501 (define-key map "=" 'vc-git-stash-show-at-point)
502 (define-key map "\C-m" 'vc-git-stash-show-at-point)
503 (define-key map "A" 'vc-git-stash-apply-at-point)
504 (define-key map "P" 'vc-git-stash-pop-at-point)
505 (define-key map "S" 'vc-git-stash-snapshot)
506 map))
508 (defvar vc-git-stash-menu-map
509 (let ((map (make-sparse-keymap "Git Stash")))
510 (define-key map [de]
511 '(menu-item "Delete Stash" vc-git-stash-delete-at-point
512 :help "Delete the current stash"))
513 (define-key map [ap]
514 '(menu-item "Apply Stash" vc-git-stash-apply-at-point
515 :help "Apply the current stash and keep it in the stash list"))
516 (define-key map [po]
517 '(menu-item "Apply and Remove Stash (Pop)" vc-git-stash-pop-at-point
518 :help "Apply the current stash and remove it"))
519 (define-key map [sh]
520 '(menu-item "Show Stash" vc-git-stash-show-at-point
521 :help "Show the contents of the current stash"))
522 map))
524 (defun vc-git-dir-extra-headers (_dir)
525 (let ((str (with-output-to-string
526 (with-current-buffer standard-output
527 (vc-git--out-ok "symbolic-ref" "HEAD"))))
528 (stash (vc-git-stash-list))
529 (stash-help-echo "Use M-x vc-git-stash to create stashes.")
530 branch remote remote-url)
531 (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
532 (progn
533 (setq branch (match-string 2 str))
534 (setq remote
535 (with-output-to-string
536 (with-current-buffer standard-output
537 (vc-git--out-ok "config"
538 (concat "branch." branch ".remote")))))
539 (when (string-match "\\([^\n]+\\)" remote)
540 (setq remote (match-string 1 remote)))
541 (when remote
542 (setq remote-url
543 (with-output-to-string
544 (with-current-buffer standard-output
545 (vc-git--out-ok "config"
546 (concat "remote." remote ".url"))))))
547 (when (string-match "\\([^\n]+\\)" remote-url)
548 (setq remote-url (match-string 1 remote-url))))
549 (setq branch "not (detached HEAD)"))
550 ;; FIXME: maybe use a different face when nothing is stashed.
551 (concat
552 (propertize "Branch : " 'face 'font-lock-type-face)
553 (propertize branch
554 'face 'font-lock-variable-name-face)
555 (when remote
556 (concat
557 "\n"
558 (propertize "Remote : " 'face 'font-lock-type-face)
559 (propertize remote-url
560 'face 'font-lock-variable-name-face)))
561 "\n"
562 (if stash
563 (concat
564 (propertize "Stash :\n" 'face 'font-lock-type-face
565 'help-echo stash-help-echo)
566 (mapconcat
567 (lambda (x)
568 (propertize x
569 'face 'font-lock-variable-name-face
570 'mouse-face 'highlight
571 'help-echo "mouse-3: Show stash menu\nRET: Show stash\nA: Apply stash\nP: Apply and remove stash (pop)\nC-k: Delete stash"
572 'keymap vc-git-stash-map))
573 stash "\n"))
574 (concat
575 (propertize "Stash : " 'face 'font-lock-type-face
576 'help-echo stash-help-echo)
577 (propertize "Nothing stashed"
578 'help-echo stash-help-echo
579 'face 'font-lock-variable-name-face))))))
581 (defun vc-git-branches ()
582 "Return the existing branches, as a list of strings.
583 The car of the list is the current branch."
584 (with-temp-buffer
585 (vc-git--call t "branch")
586 (goto-char (point-min))
587 (let (current-branch branches)
588 (while (not (eobp))
589 (when (looking-at "^\\([ *]\\) \\(.+\\)$")
590 (if (string-equal (match-string 1) "*")
591 (setq current-branch (match-string 2))
592 (push (match-string 2) branches)))
593 (forward-line 1))
594 (cons current-branch (nreverse branches)))))
596 ;;; STATE-CHANGING FUNCTIONS
598 (defun vc-git-create-repo ()
599 "Create a new Git repository."
600 (vc-git-command nil 0 nil "init"))
602 (defun vc-git-register (files &optional _rev _comment)
603 "Register FILES into the git version-control system."
604 (let (flist dlist)
605 (dolist (crt files)
606 (if (file-directory-p crt)
607 (push crt dlist)
608 (push crt flist)))
609 (when flist
610 (vc-git-command nil 0 flist "update-index" "--add" "--"))
611 (when dlist
612 (vc-git-command nil 0 dlist "add"))))
614 (defalias 'vc-git-responsible-p 'vc-git-root)
616 (defun vc-git-unregister (file)
617 (vc-git-command nil 0 file "rm" "-f" "--cached" "--"))
619 (declare-function log-edit-mode "log-edit" ())
620 (declare-function log-edit-toggle-header "log-edit" (header value))
621 (declare-function log-edit-extract-headers "log-edit" (headers string))
623 (defun vc-git-log-edit-toggle-signoff ()
624 "Toggle whether to add the \"Signed-off-by\" line at the end of
625 the commit message."
626 (interactive)
627 (log-edit-toggle-header "Sign-Off" "yes"))
629 (defun vc-git-log-edit-toggle-amend ()
630 "Toggle whether this will amend the previous commit.
631 If toggling on, also insert its message into the buffer."
632 (interactive)
633 (when (log-edit-toggle-header "Amend" "yes")
634 (goto-char (point-max))
635 (unless (bolp) (insert "\n"))
636 (insert (with-output-to-string
637 (vc-git-command
638 standard-output 1 nil
639 "log" "--max-count=1" "--pretty=format:%B" "HEAD")))))
641 (defvar vc-git-log-edit-mode-map
642 (let ((map (make-sparse-keymap "Git-Log-Edit")))
643 (define-key map "\C-c\C-s" 'vc-git-log-edit-toggle-signoff)
644 (define-key map "\C-c\C-e" 'vc-git-log-edit-toggle-amend)
645 map))
647 (define-derived-mode vc-git-log-edit-mode log-edit-mode "Log-Edit/git"
648 "Major mode for editing Git log messages.
649 It is based on `log-edit-mode', and has Git-specific extensions.")
651 (defun vc-git-checkin (files _rev comment)
652 (let ((coding-system-for-write vc-git-commits-coding-system))
653 (cl-flet ((boolean-arg-fn
654 (argument)
655 (lambda (value) (when (equal value "yes") (list argument)))))
656 (apply 'vc-git-command nil 0 files
657 (nconc (list "commit" "-m")
658 (log-edit-extract-headers
659 `(("Author" . "--author")
660 ("Date" . "--date")
661 ("Amend" . ,(boolean-arg-fn "--amend"))
662 ("Sign-Off" . ,(boolean-arg-fn "--signoff")))
663 comment)
664 (list "--only" "--"))))))
666 (defun vc-git-find-revision (file rev buffer)
667 (let* (process-file-side-effects
668 (coding-system-for-read 'binary)
669 (coding-system-for-write 'binary)
670 (fullname
671 (let ((fn (vc-git--run-command-string
672 file "ls-files" "-z" "--full-name" "--")))
673 ;; ls-files does not return anything when looking for a
674 ;; revision of a file that has been renamed or removed.
675 (if (string= fn "")
676 (file-relative-name file (vc-git-root default-directory))
677 (substring fn 0 -1)))))
678 (vc-git-command
679 buffer 0
681 "cat-file" "blob" (concat (if rev rev "HEAD") ":" fullname))))
683 (defun vc-git-ignore (file &optional directory remove)
684 "Ignore FILE under Git.
685 If DIRECTORY is non-nil, the repository to use will be deduced by
686 DIRECTORY; if REMOVE is non-nil, remove FILE from ignored files."
687 (let (gitignore)
688 (if directory
689 (setq gitignore (vc-git-find-ignore-file directory))
690 (setq gitignore (vc-git-find-ignore-file default-directory)))
691 (if remove
692 (vc--remove-regexp file gitignore)
693 (vc--add-line file gitignore))))
695 (defun vc-git-ignore-completion-table (file)
696 "Return the list of ignored files."
697 (vc--read-lines (vc-git-find-ignore-file file)))
699 (defun vc-git-find-ignore-file (file)
700 "Return the root directory of the repository of FILE."
701 (expand-file-name ".gitignore"
702 (vc-git-root file)))
704 (defun vc-git-checkout (file &optional _editable rev)
705 (vc-git-command nil 0 file "checkout" (or rev "HEAD")))
707 (defun vc-git-revert (file &optional contents-done)
708 "Revert FILE to the version stored in the git repository."
709 (if contents-done
710 (vc-git-command nil 0 file "update-index" "--")
711 (vc-git-command nil 0 file "reset" "-q" "--")
712 (vc-git-command nil nil file "checkout" "-q" "--")))
714 (defvar vc-git-error-regexp-alist
715 '(("^ \\(.+\\) |" 1 nil nil 0))
716 "Value of `compilation-error-regexp-alist' in *vc-git* buffers.")
718 (defun vc-git-pull (prompt)
719 "Pull changes into the current Git branch.
720 Normally, this runs \"git pull\". If PROMPT is non-nil, prompt
721 for the Git command to run."
722 (let* ((root (vc-git-root default-directory))
723 (buffer (format "*vc-git : %s*" (expand-file-name root)))
724 (command "pull")
725 (git-program vc-git-program)
726 args)
727 ;; If necessary, prompt for the exact command.
728 (when prompt
729 (setq args (split-string
730 (read-shell-command "Git pull command: "
731 (format "%s pull" git-program)
732 'vc-git-history)
733 " " t))
734 (setq git-program (car args)
735 command (cadr args)
736 args (cddr args)))
737 (apply 'vc-do-async-command buffer root git-program command args)
738 (with-current-buffer buffer (vc-exec-after '(vc-compilation-mode 'git)))
739 (vc-set-async-update buffer)))
741 (defun vc-git-merge-branch ()
742 "Merge changes into the current Git branch.
743 This prompts for a branch to merge from."
744 (let* ((root (vc-git-root default-directory))
745 (buffer (format "*vc-git : %s*" (expand-file-name root)))
746 (branches (cdr (vc-git-branches)))
747 (merge-source
748 (completing-read "Merge from branch: "
749 (if (or (member "FETCH_HEAD" branches)
750 (not (file-readable-p
751 (expand-file-name ".git/FETCH_HEAD"
752 root))))
753 branches
754 (cons "FETCH_HEAD" branches))
755 nil t)))
756 (apply 'vc-do-async-command buffer root vc-git-program "merge"
757 (list merge-source))
758 (with-current-buffer buffer (vc-exec-after '(vc-compilation-mode 'git)))
759 (vc-set-async-update buffer)))
761 ;;; HISTORY FUNCTIONS
763 (autoload 'vc-setup-buffer "vc-dispatcher")
765 (defun vc-git-print-log (files buffer &optional shortlog start-revision limit)
766 "Print commit log associated with FILES into specified BUFFER.
767 If SHORTLOG is non-nil, use a short format based on `vc-git-root-log-format'.
768 \(This requires at least Git version 1.5.6, for the --graph option.)
769 If START-REVISION is non-nil, it is the newest revision to show.
770 If LIMIT is non-nil, show no more than this many entries."
771 (let ((coding-system-for-read vc-git-commits-coding-system))
772 ;; `vc-do-command' creates the buffer, but we need it before running
773 ;; the command.
774 (vc-setup-buffer buffer)
775 ;; If the buffer exists from a previous invocation it might be
776 ;; read-only.
777 (let ((inhibit-read-only t))
778 (with-current-buffer
779 buffer
780 (apply 'vc-git-command buffer
781 'async files
782 (append
783 '("log" "--no-color")
784 (when shortlog
785 `("--graph" "--decorate" "--date=short"
786 ,(format "--pretty=tformat:%s"
787 (car vc-git-root-log-format))
788 "--abbrev-commit"))
789 (when limit (list "-n" (format "%s" limit)))
790 (when start-revision (list start-revision))
791 '("--")))))))
793 (defun vc-git-log-outgoing (buffer remote-location)
794 (interactive)
795 (vc-git-command
796 buffer 0 nil
797 "log"
798 "--no-color" "--graph" "--decorate" "--date=short"
799 (format "--pretty=tformat:%s" (car vc-git-root-log-format))
800 "--abbrev-commit"
801 (concat (if (string= remote-location "")
802 "@{upstream}"
803 remote-location)
804 "..HEAD")))
806 (defun vc-git-log-incoming (buffer remote-location)
807 (interactive)
808 (vc-git-command nil 0 nil "fetch")
809 (vc-git-command
810 buffer 0 nil
811 "log"
812 "--no-color" "--graph" "--decorate" "--date=short"
813 (format "--pretty=tformat:%s" (car vc-git-root-log-format))
814 "--abbrev-commit"
815 (concat "HEAD.." (if (string= remote-location "")
816 "@{upstream}"
817 remote-location))))
819 (defvar log-view-message-re)
820 (defvar log-view-file-re)
821 (defvar log-view-font-lock-keywords)
822 (defvar log-view-per-file-logs)
823 (defvar log-view-expanded-log-entry-function)
825 (define-derived-mode vc-git-log-view-mode log-view-mode "Git-Log-View"
826 (require 'add-log) ;; We need the faces add-log.
827 ;; Don't have file markers, so use impossible regexp.
828 (set (make-local-variable 'log-view-file-re) "\\`a\\`")
829 (set (make-local-variable 'log-view-per-file-logs) nil)
830 (set (make-local-variable 'log-view-message-re)
831 (if (not (eq vc-log-view-type 'long))
832 (cadr vc-git-root-log-format)
833 "^commit *\\([0-9a-z]+\\)"))
834 ;; Allow expanding short log entries
835 (when (eq vc-log-view-type 'short)
836 (setq truncate-lines t)
837 (set (make-local-variable 'log-view-expanded-log-entry-function)
838 'vc-git-expanded-log-entry))
839 (set (make-local-variable 'log-view-font-lock-keywords)
840 (if (not (eq vc-log-view-type 'long))
841 (list (cons (nth 1 vc-git-root-log-format)
842 (nth 2 vc-git-root-log-format)))
843 (append
844 `((,log-view-message-re (1 'change-log-acknowledgment)))
845 ;; Handle the case:
846 ;; user: foo@bar
847 '(("^Author:[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
848 (1 'change-log-email))
849 ;; Handle the case:
850 ;; user: FirstName LastName <foo@bar>
851 ("^Author:[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
852 (1 'change-log-name)
853 (2 'change-log-email))
854 ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
855 (1 'change-log-name))
856 ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
857 (1 'change-log-name)
858 (2 'change-log-email))
859 ("^Merge: \\([0-9a-z]+\\) \\([0-9a-z]+\\)"
860 (1 'change-log-acknowledgment)
861 (2 'change-log-acknowledgment))
862 ("^Date: \\(.+\\)" (1 'change-log-date))
863 ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message)))))))
866 (defun vc-git-show-log-entry (revision)
867 "Move to the log entry for REVISION.
868 REVISION may have the form BRANCH, BRANCH~N,
869 or BRANCH^ (where \"^\" can be repeated)."
870 (goto-char (point-min))
871 (prog1
872 (when revision
873 (search-forward
874 (format "\ncommit %s" revision) nil t
875 (cond ((string-match "~\\([0-9]\\)\\'" revision)
876 (1+ (string-to-number (match-string 1 revision))))
877 ((string-match "\\^+\\'" revision)
878 (1+ (length (match-string 0 revision))))
879 (t nil))))
880 (beginning-of-line)))
882 (defun vc-git-expanded-log-entry (revision)
883 (with-temp-buffer
884 (apply 'vc-git-command t nil nil (list "log" revision "-1"))
885 (goto-char (point-min))
886 (unless (eobp)
887 ;; Indent the expanded log entry.
888 (indent-region (point-min) (point-max) 2)
889 (buffer-string))))
891 (autoload 'vc-switches "vc")
893 (defun vc-git-diff (files &optional rev1 rev2 buffer)
894 "Get a difference report using Git between two revisions of FILES."
895 (let (process-file-side-effects)
896 (apply #'vc-git-command (or buffer "*vc-diff*") 1 files
897 (if (and rev1 rev2) "diff-tree" "diff-index")
898 "--exit-code"
899 (append (vc-switches 'git 'diff)
900 (list "-p" (or rev1 "HEAD") rev2 "--")))))
902 (defun vc-git-revision-table (_files)
903 ;; What about `files'?!? --Stef
904 (let (process-file-side-effects
905 (table (list "HEAD")))
906 (with-temp-buffer
907 (vc-git-command t nil nil "for-each-ref" "--format=%(refname)")
908 (goto-char (point-min))
909 (while (re-search-forward "^refs/\\(heads\\|tags\\|remotes\\)/\\(.*\\)$"
910 nil t)
911 (push (match-string 2) table)))
912 table))
914 (defun vc-git-revision-completion-table (files)
915 (letrec ((table (lazy-completion-table
916 table (lambda () (vc-git-revision-table files)))))
917 table))
919 (defun vc-git-annotate-command (file buf &optional rev)
920 (let ((name (file-relative-name file)))
921 (vc-git-command buf 'async nil "blame" "--date=iso" "-C" "-C" rev "--" name)))
923 (declare-function vc-annotate-convert-time "vc-annotate" (time))
925 (defun vc-git-annotate-time ()
926 (and (re-search-forward "[0-9a-f]+[^()]+(.* \\([0-9]+\\)-\\([0-9]+\\)-\\([0-9]+\\) \\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\) \\([-+0-9]+\\) +[0-9]+) " nil t)
927 (vc-annotate-convert-time
928 (apply #'encode-time (mapcar (lambda (match)
929 (string-to-number (match-string match)))
930 '(6 5 4 3 2 1 7))))))
932 (defun vc-git-annotate-extract-revision-at-line ()
933 (save-excursion
934 (move-beginning-of-line 1)
935 (when (looking-at "\\([0-9a-f^][0-9a-f]+\\) \\(\\([^(]+\\) \\)?")
936 (let ((revision (match-string-no-properties 1)))
937 (if (match-beginning 2)
938 (let ((fname (match-string-no-properties 3)))
939 ;; Remove trailing whitespace from the file name.
940 (when (string-match " +\\'" fname)
941 (setq fname (substring fname 0 (match-beginning 0))))
942 (cons revision
943 (expand-file-name fname (vc-git-root default-directory))))
944 revision)))))
946 ;;; TAG SYSTEM
948 (defun vc-git-create-tag (dir name branchp)
949 (let ((default-directory dir))
950 (and (vc-git-command nil 0 nil "update-index" "--refresh")
951 (if branchp
952 (vc-git-command nil 0 nil "checkout" "-b" name)
953 (vc-git-command nil 0 nil "tag" name)))))
955 (defun vc-git-retrieve-tag (dir name _update)
956 (let ((default-directory dir))
957 (vc-git-command nil 0 nil "checkout" name)
958 ;; FIXME: update buffers if `update' is true
962 ;;; MISCELLANEOUS
964 (defun vc-git-previous-revision (file rev)
965 "Git-specific version of `vc-previous-revision'."
966 (if file
967 (let* ((fname (file-relative-name file))
968 (prev-rev (with-temp-buffer
969 (and
970 (vc-git--out-ok "rev-list" "-2" rev "--" fname)
971 (goto-char (point-max))
972 (bolp)
973 (zerop (forward-line -1))
974 (not (bobp))
975 (buffer-substring-no-properties
976 (point)
977 (1- (point-max)))))))
978 (or (vc-git-symbolic-commit prev-rev) prev-rev))
979 (vc-git--rev-parse (concat rev "^"))))
981 (defun vc-git--rev-parse (rev)
982 (with-temp-buffer
983 (and
984 (vc-git--out-ok "rev-parse" rev)
985 (buffer-substring-no-properties (point-min) (+ (point-min) 40)))))
987 (defun vc-git-next-revision (file rev)
988 "Git-specific version of `vc-next-revision'."
989 (let* ((default-directory (file-name-directory
990 (expand-file-name file)))
991 (file (file-name-nondirectory file))
992 (current-rev
993 (with-temp-buffer
994 (and
995 (vc-git--out-ok "rev-list" "-1" rev "--" file)
996 (goto-char (point-max))
997 (bolp)
998 (zerop (forward-line -1))
999 (bobp)
1000 (buffer-substring-no-properties
1001 (point)
1002 (1- (point-max))))))
1003 (next-rev
1004 (and current-rev
1005 (with-temp-buffer
1006 (and
1007 (vc-git--out-ok "rev-list" "HEAD" "--" file)
1008 (goto-char (point-min))
1009 (search-forward current-rev nil t)
1010 (zerop (forward-line -1))
1011 (buffer-substring-no-properties
1012 (point)
1013 (progn (forward-line 1) (1- (point)))))))))
1014 (or (vc-git-symbolic-commit next-rev) next-rev)))
1016 (defun vc-git-delete-file (file)
1017 (vc-git-command nil 0 file "rm" "-f" "--"))
1019 (defun vc-git-rename-file (old new)
1020 (vc-git-command nil 0 (list old new) "mv" "-f" "--"))
1022 (defvar vc-git-extra-menu-map
1023 (let ((map (make-sparse-keymap)))
1024 (define-key map [git-grep]
1025 '(menu-item "Git grep..." vc-git-grep
1026 :help "Run the `git grep' command"))
1027 (define-key map [git-sn]
1028 '(menu-item "Stash a Snapshot" vc-git-stash-snapshot
1029 :help "Stash the current state of the tree and keep the current state"))
1030 (define-key map [git-st]
1031 '(menu-item "Create Stash..." vc-git-stash
1032 :help "Stash away changes"))
1033 (define-key map [git-ss]
1034 '(menu-item "Show Stash..." vc-git-stash-show
1035 :help "Show stash contents"))
1036 map))
1038 (defun vc-git-extra-menu () vc-git-extra-menu-map)
1040 (defun vc-git-extra-status-menu () vc-git-extra-menu-map)
1042 (defun vc-git-root (file)
1043 (or (vc-file-getprop file 'git-root)
1044 (vc-file-setprop file 'git-root (vc-find-root file ".git"))))
1046 ;; grep-compute-defaults autoloads grep.
1047 (declare-function grep-read-regexp "grep" ())
1048 (declare-function grep-read-files "grep" (regexp))
1049 (declare-function grep-expand-template "grep"
1050 (template &optional regexp files dir excl))
1052 ;; Derived from `lgrep'.
1053 (defun vc-git-grep (regexp &optional files dir)
1054 "Run git grep, searching for REGEXP in FILES in directory DIR.
1055 The search is limited to file names matching shell pattern FILES.
1056 FILES may use abbreviations defined in `grep-files-aliases', e.g.
1057 entering `ch' is equivalent to `*.[ch]'.
1059 With \\[universal-argument] prefix, you can edit the constructed shell command line
1060 before it is executed.
1061 With two \\[universal-argument] prefixes, directly edit and run `grep-command'.
1063 Collect output in a buffer. While git grep runs asynchronously, you
1064 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
1065 in the grep output buffer,
1066 to go to the lines where grep found matches.
1068 This command shares argument histories with \\[rgrep] and \\[grep]."
1069 (interactive
1070 (progn
1071 (grep-compute-defaults)
1072 (cond
1073 ((equal current-prefix-arg '(16))
1074 (list (read-from-minibuffer "Run: " "git grep"
1075 nil nil 'grep-history)
1076 nil))
1077 (t (let* ((regexp (grep-read-regexp))
1078 (files (grep-read-files regexp))
1079 (dir (read-directory-name "In directory: "
1080 nil default-directory t)))
1081 (list regexp files dir))))))
1082 (require 'grep)
1083 (when (and (stringp regexp) (> (length regexp) 0))
1084 (let ((command regexp))
1085 (if (null files)
1086 (if (string= command "git grep")
1087 (setq command nil))
1088 (setq dir (file-name-as-directory (expand-file-name dir)))
1089 (setq command
1090 (grep-expand-template "git grep -n -e <R> -- <F>"
1091 regexp files))
1092 (when command
1093 (if (equal current-prefix-arg '(4))
1094 (setq command
1095 (read-from-minibuffer "Confirm: "
1096 command nil nil 'grep-history))
1097 (add-to-history 'grep-history command))))
1098 (when command
1099 (let ((default-directory dir)
1100 (compilation-environment (cons "PAGER=" compilation-environment)))
1101 ;; Setting process-setup-function makes exit-message-function work
1102 ;; even when async processes aren't supported.
1103 (compilation-start command 'grep-mode))
1104 (if (eq next-error-last-buffer (current-buffer))
1105 (setq default-directory dir))))))
1107 ;; Everywhere but here, follows vc-git-command, which uses vc-do-command
1108 ;; from vc-dispatcher.
1109 (autoload 'vc-resynch-buffer "vc-dispatcher")
1111 (defun vc-git-stash (name)
1112 "Create a stash."
1113 (interactive "sStash name: ")
1114 (let ((root (vc-git-root default-directory)))
1115 (when root
1116 (vc-git--call nil "stash" "save" name)
1117 (vc-resynch-buffer root t t))))
1119 (defun vc-git-stash-show (name)
1120 "Show the contents of stash NAME."
1121 (interactive "sStash name: ")
1122 (vc-setup-buffer "*vc-git-stash*")
1123 (vc-git-command "*vc-git-stash*" 'async nil "stash" "show" "-p" name)
1124 (set-buffer "*vc-git-stash*")
1125 (diff-mode)
1126 (setq buffer-read-only t)
1127 (pop-to-buffer (current-buffer)))
1129 (defun vc-git-stash-apply (name)
1130 "Apply stash NAME."
1131 (interactive "sApply stash: ")
1132 (vc-git-command "*vc-git-stash*" 0 nil "stash" "apply" "-q" name)
1133 (vc-resynch-buffer (vc-git-root default-directory) t t))
1135 (defun vc-git-stash-pop (name)
1136 "Pop stash NAME."
1137 (interactive "sPop stash: ")
1138 (vc-git-command "*vc-git-stash*" 0 nil "stash" "pop" "-q" name)
1139 (vc-resynch-buffer (vc-git-root default-directory) t t))
1141 (defun vc-git-stash-snapshot ()
1142 "Create a stash with the current tree state."
1143 (interactive)
1144 (vc-git--call nil "stash" "save"
1145 (let ((ct (current-time)))
1146 (concat
1147 (format-time-string "Snapshot on %Y-%m-%d" ct)
1148 (format-time-string " at %H:%M" ct))))
1149 (vc-git-command "*vc-git-stash*" 0 nil "stash" "apply" "-q" "stash@{0}")
1150 (vc-resynch-buffer (vc-git-root default-directory) t t))
1152 (defun vc-git-stash-list ()
1153 (delete
1155 (split-string
1156 (replace-regexp-in-string
1157 "^stash@" " " (vc-git--run-command-string nil "stash" "list"))
1158 "\n")))
1160 (defun vc-git-stash-get-at-point (point)
1161 (save-excursion
1162 (goto-char point)
1163 (beginning-of-line)
1164 (if (looking-at "^ +\\({[0-9]+}\\):")
1165 (match-string 1)
1166 (error "Cannot find stash at point"))))
1168 ;; vc-git-stash-delete-at-point must be called from a vc-dir buffer.
1169 (declare-function vc-dir-refresh "vc-dir" ())
1171 (defun vc-git-stash-delete-at-point ()
1172 (interactive)
1173 (let ((stash (vc-git-stash-get-at-point (point))))
1174 (when (y-or-n-p (format "Remove stash %s ? " stash))
1175 (vc-git--run-command-string nil "stash" "drop" (format "stash@%s" stash))
1176 (vc-dir-refresh))))
1178 (defun vc-git-stash-show-at-point ()
1179 (interactive)
1180 (vc-git-stash-show (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1182 (defun vc-git-stash-apply-at-point ()
1183 (interactive)
1184 (vc-git-stash-apply (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1186 (defun vc-git-stash-pop-at-point ()
1187 (interactive)
1188 (vc-git-stash-pop (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1190 (defun vc-git-stash-menu (e)
1191 (interactive "e")
1192 (vc-dir-at-event e (popup-menu vc-git-stash-menu-map e)))
1195 ;;; Internal commands
1197 (defun vc-git-command (buffer okstatus file-or-list &rest flags)
1198 "A wrapper around `vc-do-command' for use in vc-git.el.
1199 The difference to vc-do-command is that this function always invokes
1200 `vc-git-program'."
1201 (apply 'vc-do-command (or buffer "*vc*") okstatus vc-git-program
1202 file-or-list (cons "--no-pager" flags)))
1204 (defun vc-git--empty-db-p ()
1205 "Check if the git db is empty (no commit done yet)."
1206 (let (process-file-side-effects)
1207 (not (eq 0 (vc-git--call nil "rev-parse" "--verify" "HEAD")))))
1209 (defun vc-git--call (buffer command &rest args)
1210 ;; We don't need to care the arguments. If there is a file name, it
1211 ;; is always a relative one. This works also for remote
1212 ;; directories. We enable `inhibit-null-byte-detection', otherwise
1213 ;; Tramp's eol conversion might be confused.
1214 (let ((inhibit-null-byte-detection t)
1215 (process-environment (cons "PAGER=" process-environment)))
1216 (apply 'process-file vc-git-program nil buffer nil command args)))
1218 (defun vc-git--out-ok (command &rest args)
1219 (zerop (apply 'vc-git--call '(t nil) command args)))
1221 (defun vc-git--run-command-string (file &rest args)
1222 "Run a git command on FILE and return its output as string.
1223 FILE can be nil."
1224 (let* ((ok t)
1225 (str (with-output-to-string
1226 (with-current-buffer standard-output
1227 (unless (apply 'vc-git--out-ok
1228 (if file
1229 (append args (list (file-relative-name
1230 file)))
1231 args))
1232 (setq ok nil))))))
1233 (and ok str)))
1235 (defun vc-git-symbolic-commit (commit)
1236 "Translate COMMIT string into symbolic form.
1237 Returns nil if not possible."
1238 (and commit
1239 (let ((name (with-temp-buffer
1240 (and
1241 (vc-git--out-ok "name-rev" "--name-only" commit)
1242 (goto-char (point-min))
1243 (= (forward-line 2) 1)
1244 (bolp)
1245 (buffer-substring-no-properties (point-min)
1246 (1- (point-max)))))))
1247 (and name (not (string= name "undefined")) name))))
1249 (provide 'vc-git)
1251 ;;; vc-git.el ends here