1 ;;; vc-git.el --- VC backend for the git version control system
3 ;; Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
5 ;; Author: Alexandre Julliard <julliard@winehq.org>
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 3, or (at your option)
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
22 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 ;; Boston, MA 02110-1301, USA.
27 ;; This file contains a VC backend for the git version control
33 ;; To install: put this file on the load-path and add Git to the list
34 ;; of supported backends in `vc-handled-backends'; the following line,
35 ;; placed in your ~/.emacs, will accomplish this:
37 ;; (add-to-list 'vc-handled-backends 'Git)
40 ;; - check if more functions could use vc-git-command instead
42 ;; - changelog generation
44 ;; Implement the rest of the vc interface. See the comment at the
45 ;; beginning of vc.el. The current status is:
46 ;; ("??" means: "figure out what to do about it")
48 ;; FUNCTION NAME STATUS
50 ;; * revision-granularity OK
51 ;; STATE-QUERYING FUNCTIONS
52 ;; * registered (file) OK
54 ;; - state-heuristic (file) NOT NEEDED
55 ;; - dir-state (dir) OK
56 ;; * working-revision (file) OK
57 ;; - latest-on-branch-p (file) NOT NEEDED
58 ;; * checkout-model (file) OK
59 ;; - workfile-unchanged-p (file) OK
60 ;; - mode-line-string (file) OK
61 ;; - dired-state-info (file) OK
62 ;; STATE-CHANGING FUNCTIONS
63 ;; * create-repo () OK
64 ;; * register (files &optional rev comment) OK
65 ;; - init-revision (file) NOT NEEDED
66 ;; - responsible-p (file) OK
67 ;; - could-register (file) NOT NEEDED, DEFAULT IS GOOD
68 ;; - receive-file (file rev) NOT NEEDED
69 ;; - unregister (file) OK
70 ;; * checkin (files rev comment) OK
71 ;; * find-revision (file rev buffer) OK
72 ;; * checkout (file &optional editable rev) OK
73 ;; * revert (file &optional contents-done) OK
74 ;; - rollback (files) COULD BE SUPPORTED
75 ;; - merge (file rev1 rev2) It would be possible to merge changes into
76 ;; a single file, but when committing they
77 ;; wouldn't be identified as a merge by git,
78 ;; so it's probably not a good idea.
79 ;; - merge-news (file) see `merge'
80 ;; - steal-lock (file &optional revision) NOT NEEDED
82 ;; * print-log (files &optional buffer) OK
83 ;; - log-view-mode () OK
84 ;; - show-log-entry (revision) OK
85 ;; - wash-log (file) COULD BE SUPPORTED
86 ;; - logentry-check () NOT NEEDED
87 ;; - comment-history (file) ??
88 ;; - update-changelog (files) COULD BE SUPPORTED
89 ;; * diff (file &optional rev1 rev2 buffer) OK
90 ;; - revision-completion-table (files) NEEDED?
91 ;; - annotate-command (file buf &optional rev) OK
92 ;; - annotate-time () OK
93 ;; - annotate-current-time () NOT NEEDED
94 ;; - annotate-extract-revision-at-line () OK
96 ;; - create-snapshot (dir name branchp) OK
97 ;; - assign-name (file name) NOT NEEDED
98 ;; - retrieve-snapshot (dir name update) OK, needs to update buffers
100 ;; - make-version-backups-p (file) NOT NEEDED
101 ;; - repository-hostname (dirname) NOT NEEDED
102 ;; - previous-revision (file rev) OK
103 ;; - next-revision (file rev) OK
104 ;; - check-headers () COULD BE SUPPORTED
105 ;; - clear-headers () NOT NEEDED
106 ;; - delete-file (file) OK
107 ;; - rename-file (old new) OK
108 ;; - find-file-hook () NOT NEEDED
109 ;; - find-file-not-found-hook () NOT NEEDED
111 (eval-when-compile (require 'cl
) (require 'vc
) (require 'grep
))
113 (defvar git-commits-coding-system
'utf-8
114 "Default coding system for git commits.")
116 ;;; BACKEND PROPERTIES
118 (defun vc-git-revision-granularity ()
121 ;;; STATE-QUERYING FUNCTIONS
123 ;;;###autoload (defun vc-git-registered (file)
124 ;;;###autoload "Return non-nil if FILE is registered with git."
125 ;;;###autoload (if (vc-find-root file ".git") ; short cut
126 ;;;###autoload (progn
127 ;;;###autoload (load "vc-git")
128 ;;;###autoload (vc-git-registered file))))
130 (defun vc-git-registered (file)
131 "Check whether FILE is registered with git."
132 (when (vc-git-root file
)
134 (let* ((dir (file-name-directory file
))
135 (name (file-relative-name file dir
)))
138 (vc-git--out-ok "ls-files" "-c" "-z" "--" name
))
139 (let ((str (buffer-string)))
140 (and (> (length str
) (length name
))
141 (string= (substring str
0 (1+ (length name
)))
142 (concat name
"\0")))))))))
144 (defun vc-git--state-code (code)
145 "Convert from a string to a added/deleted/modified state."
146 (case (string-to-char code
)
150 (?U
'edited
) ;; FIXME
151 (?T
'edited
))) ;; FIXME
153 (defun vc-git-state (file)
154 "Git-specific version of `vc-state'."
155 ;; FIXME: This can't set 'ignored yet
156 (vc-git--call nil
"add" "--refresh" "--" (file-relative-name file
))
157 (let ((diff (vc-git--run-command-string file
"diff-index" "-z" "HEAD" "--")))
158 (if (and diff
(string-match ":[0-7]\\{6\\} [0-7]\\{6\\} [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\([ADMUT]\\)\0[^\0]+\0"
160 (vc-git--state-code (match-string 1 diff
))
161 (if (vc-git--empty-db-p) 'added
'up-to-date
))))
163 (defun vc-git--ls-files-state (state &rest args
)
164 "Set state to STATE on all files found with git-ls-files ARGS."
166 (apply 'vc-git-command
(current-buffer) nil nil
"ls-files" "-z" args
)
167 (goto-char (point-min))
168 (let ((start (point)))
169 (while (search-forward "\0" nil t
)
170 (let ((file (expand-file-name
171 (buffer-substring-no-properties start
(1- (point))))))
172 (vc-file-setprop file
'vc-backend
(if state
'Git
'none
))
173 (vc-file-setprop file
'vc-state state
))
174 (setq start
(point))))))
176 (defun vc-git-dir-state (dir)
177 "Git-specific version of `dir-state'."
178 (vc-git--ls-files-state 'up-to-date
"-c")
179 (vc-git--ls-files-state 'edited
"-m")
180 (vc-git--ls-files-state 'removed
"-d")
181 (vc-git--ls-files-state 'ignored
"-o" "-i" "--exclude-standard")
182 (vc-git--ls-files-state nil
"-o" "--exclude-standard"))
184 (defun vc-git-working-revision (file)
185 "Git-specific version of `vc-working-revision'."
186 (let ((str (with-output-to-string
187 (with-current-buffer standard-output
188 (vc-git--out-ok "symbolic-ref" "HEAD")))))
189 (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str
)
193 (defun vc-git-checkout-model (file)
196 (defun vc-git-workfile-unchanged-p (file)
197 (eq 'up-to-date
(vc-git-state file
)))
199 (defun vc-git-mode-line-string (file)
200 "Return string for placement into the modeline for FILE."
201 (let* ((branch (vc-git-working-revision file
))
202 (def-ml (vc-default-mode-line-string 'Git file
))
203 (help-echo (get-text-property 0 'help-echo def-ml
)))
204 (if (zerop (length branch
))
207 'help-echo
(concat help-echo
"\nNo current branch (detached HEAD)"))
209 'help-echo
(concat help-echo
"\nCurrent branch: " branch
)))))
211 ;; Variable used to keep the intermediate results for vc-git-status.
212 (defvar vc-git-status-result nil
)
214 (defun vc-git-after-dir-status-stage2 (update-function status-buffer
)
215 (goto-char (point-min))
216 (while (re-search-forward "\\([^\0]*?\\)\0" nil t
1)
217 (push (cons (match-string 1) 'unregistered
) vc-git-status-result
))
218 (funcall update-function
(nreverse vc-git-status-result
) status-buffer
)
219 ;; Remove the temporary buffer.
220 (kill-buffer (current-buffer)))
222 (defun vc-git-after-dir-status-stage1 (update-function status-buffer
)
223 (goto-char (point-min))
224 (while (re-search-forward
225 ":[0-7]\\{6\\} [0-7]\\{6\\} [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\([ADMUT]\\)\0\\([^\0]+\\)\0"
227 (let ((filename (match-string 2))
228 (status (vc-git--state-code (match-string 1))))
229 (push (cons filename status
) vc-git-status-result
)))
231 (vc-git-command (current-buffer) 'async nil
"ls-files" "-z" "-o"
232 "--directory" "--no-empty-directory" "--exclude-standard")
234 `(vc-git-after-dir-status-stage2 (quote ,update-function
) ,status-buffer
)))
236 (defun vc-git-after-dir-status-stage1-empty-db (update-function status-buffer
)
237 (goto-char (point-min))
238 (while (re-search-forward "\\([^\0]*?\\)\0" nil t
1)
239 (push (cons (match-string 1) 'added
) vc-git-status-result
))
241 (vc-git-command (current-buffer) 'async nil
"ls-files" "-z" "-o"
242 "--directory" "--no-empty-directory" "--exclude-standard")
244 `(vc-git-after-dir-status-stage2 (quote ,update-function
) ,status-buffer
)))
246 (defun vc-git-dir-status (dir update-function status-buffer
)
247 "Return a list of conses (file . state) for DIR."
248 ;; Further things that would have to be fixed later:
249 ;; - how to handle unregistered directories
250 ;; - how to support vc-status on a subdir of the project tree
253 (expand-file-name " *VC-Git* tmp status" dir
))
254 (set (make-local-variable 'vc-git-status-result
) nil
)
257 (if (vc-git--empty-db-p)
259 (vc-git-command (current-buffer) 'async nil
"ls-files" "-z" "-c")
261 `(vc-git-after-dir-status-stage1-empty-db (quote ,update-function
) ,status-buffer
)))
262 (vc-git-command (current-buffer) 'async nil
"diff-index" "-z" "HEAD")
264 `(vc-git-after-dir-status-stage1 (quote ,update-function
) ,status-buffer
)))
267 (defun vc-git-status-extra-headers (dir)
268 (let ((str (with-output-to-string
269 (with-current-buffer standard-output
270 (vc-git--out-ok "symbolic-ref" "HEAD")))))
272 (propertize "Branch : " 'face
'font-lock-type-face
)
274 (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str
)
276 "not (detached HEAD)")
277 'face
'font-lock-variable-name-face
))))
279 ;;; STATE-CHANGING FUNCTIONS
281 (defun vc-git-create-repo ()
282 "Create a new Git repository."
283 (vc-git-command nil
0 nil
"init"))
285 (defun vc-git-register (files &optional rev comment
)
286 "Register FILE into the git version-control system."
287 (vc-git-command nil
0 files
"update-index" "--add" "--"))
289 (defalias 'vc-git-responsible-p
'vc-git-root
)
291 (defun vc-git-unregister (file)
292 (vc-git-command nil
0 file
"rm" "-f" "--cached" "--"))
295 (defun vc-git-checkin (files rev comment
)
296 (let ((coding-system-for-write git-commits-coding-system
))
297 (vc-git-command nil
0 files
"commit" "-m" comment
"--only" "--")))
299 (defun vc-git-find-revision (file rev buffer
)
300 (let ((coding-system-for-read 'binary
)
301 (coding-system-for-write 'binary
)
303 (vc-git--run-command-string
304 file
"ls-files" "-z" "--full-name" "--")
308 (concat (if rev rev
"HEAD") ":" fullname
) "cat-file" "blob")))
310 (defun vc-git-checkout (file &optional editable rev
)
311 (vc-git-command nil
0 file
"checkout" (or rev
"HEAD")))
313 (defun vc-git-revert (file &optional contents-done
)
314 "Revert FILE to the version stored in the git repository."
316 (vc-git-command nil
0 file
"update-index" "--")
317 (vc-git-command nil
0 file
"checkout" "HEAD")))
319 ;;; HISTORY FUNCTIONS
321 (defun vc-git-print-log (files &optional buffer
)
322 "Get change log associated with FILES."
323 (let ((coding-system-for-read git-commits-coding-system
)
324 ;; Support both the old print-log interface that passes a
325 ;; single file, and the new one that passes a file list.
326 (flist (if (listp files
) files
(list files
))))
327 ;; `vc-do-command' creates the buffer, but we need it before running
329 (vc-setup-buffer buffer
)
330 ;; If the buffer exists from a previous invocation it might be
332 (let ((inhibit-read-only t
))
333 ;; XXX `log-view-mode' needs to have something to identify where
334 ;; the log for each individual file starts. It seems that by
335 ;; default git does not output this info. So loop here and call
336 ;; "git rev-list" on each file separately to make sure that each
337 ;; file gets a "File:" header before the corresponding
338 ;; log. Maybe there is a way to do this with one command...
342 (insert "File: " (file-name-nondirectory file
) "\n"))
343 (vc-git-command buffer
'async
(file-relative-name file
)
344 "rev-list" "--pretty" "HEAD" "--")))))
346 (defvar log-view-message-re
)
347 (defvar log-view-file-re
)
348 (defvar log-view-font-lock-keywords
)
350 (define-derived-mode vc-git-log-view-mode log-view-mode
"Git-Log-View"
351 (require 'add-log
) ;; we need the faces add-log
352 ;; Don't have file markers, so use impossible regexp.
353 (set (make-local-variable 'log-view-file-re
) "^File:[ \t]+\\(.+\\)")
354 (set (make-local-variable 'log-view-message-re
)
355 "^commit *\\([0-9a-z]+\\)")
356 (set (make-local-variable 'log-view-font-lock-keywords
)
358 `((,log-view-message-re
(1 'change-log-acknowledgement
))
359 (,log-view-file-re
(1 'change-log-file-face
)))
362 '(("^Author:[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
363 (1 'change-log-email
))
365 ;; user: FirstName LastName <foo@bar>
366 ("^Author:[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
368 (2 'change-log-email
))
369 ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
370 (1 'change-log-name
))
371 ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
373 (2 'change-log-email
))
374 ("^Merge: \\([0-9a-z]+\\) \\([0-9a-z]+\\)"
375 (1 'change-log-acknowledgement
)
376 (2 'change-log-acknowledgement
))
377 ("^Date: \\(.+\\)" (1 'change-log-date
))
378 ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message
))))))
380 (defun vc-git-show-log-entry (revision)
381 "Move to the log entry for REVISION.
382 REVISION may have the form BRANCH, BRANCH~N,
383 or BRANCH^ (where \"^\" can be repeated)."
384 (goto-char (point-min))
385 (search-forward "\ncommit" nil t
386 (cond ((string-match "~\\([0-9]\\)$" revision
)
387 (1+ (string-to-number (match-string 1 revision
))))
388 ((string-match "\\^+$" revision
)
389 (1+ (length (match-string 0 revision
))))
393 (defun vc-git-diff (files &optional rev1 rev2 buffer
)
394 (let ((buf (or buffer
"*vc-diff*")))
396 (vc-git-command buf
1 files
"diff-tree" "--exit-code" "-p"
398 (vc-git-command buf
1 files
"diff-index" "--exit-code" "-p"
399 (or rev1
"HEAD") "--"))))
401 (defun vc-git-revision-table (files)
402 ;; What about `files'?!? --Stef
403 (let ((table (list "HEAD")))
405 (vc-git-command t nil nil
"for-each-ref" "--format=%(refname)")
406 (goto-char (point-min))
407 (while (re-search-forward "^refs/\\(heads\\|tags\\)/\\(.*\\)$" nil t
)
408 (push (match-string 2) table
)))
411 (defun vc-git-revision-completion-table (files)
412 (lexical-let ((files files
)
414 (setq table
(lazy-completion-table
415 table
(lambda () (vc-git-revision-table files
))))
418 (defun vc-git-annotate-command (file buf
&optional rev
)
419 ;; FIXME: rev is ignored
420 (let ((name (file-relative-name file
)))
421 (vc-git-command buf
0 name
"blame" (if rev
(concat "-r" rev
)))))
423 (defun vc-git-annotate-time ()
424 (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
)
425 (vc-annotate-convert-time
426 (apply #'encode-time
(mapcar (lambda (match)
427 (string-to-number (match-string match
)))
428 '(6 5 4 3 2 1 7))))))
430 (defun vc-git-annotate-extract-revision-at-line ()
432 (move-beginning-of-line 1)
433 (and (looking-at "[0-9a-f^][0-9a-f]+")
434 (buffer-substring-no-properties (match-beginning 0) (match-end 0)))))
438 (defun vc-git-create-snapshot (dir name branchp
)
439 (let ((default-directory dir
))
440 (and (vc-git-command nil
0 nil
"update-index" "--refresh")
442 (vc-git-command nil
0 nil
"checkout" "-b" name
)
443 (vc-git-command nil
0 nil
"tag" name
)))))
445 (defun vc-git-retrieve-snapshot (dir name update
)
446 (let ((default-directory dir
))
447 (vc-git-command nil
0 nil
"checkout" name
)
448 ;; FIXME: update buffers if `update' is true
454 (defun vc-git-previous-revision (file rev
)
455 "Git-specific version of `vc-previous-revision'."
456 (let ((default-directory (file-name-directory (expand-file-name file
)))
457 (file (file-name-nondirectory file
)))
458 (vc-git-symbolic-commit
461 (vc-git--out-ok "rev-list" "-2" rev
"--" file
)
462 (goto-char (point-max))
464 (zerop (forward-line -
1))
466 (buffer-substring-no-properties
468 (1- (point-max))))))))
470 (defun vc-git-next-revision (file rev
)
471 "Git-specific version of `vc-next-revision'."
472 (let* ((default-directory (file-name-directory
473 (expand-file-name file
)))
474 (file (file-name-nondirectory file
))
478 (vc-git--out-ok "rev-list" "-1" rev
"--" file
)
479 (goto-char (point-max))
481 (zerop (forward-line -
1))
483 (buffer-substring-no-properties
485 (1- (point-max)))))))
487 (vc-git-symbolic-commit
490 (vc-git--out-ok "rev-list" "HEAD" "--" file
)
491 (goto-char (point-min))
492 (search-forward current-rev nil t
)
493 (zerop (forward-line -
1))
494 (buffer-substring-no-properties
496 (progn (forward-line 1) (1- (point))))))))))
498 (defun vc-git-delete-file (file)
499 (vc-git-command nil
0 file
"rm" "-f" "--"))
501 (defun vc-git-rename-file (old new
)
502 (vc-git-command nil
0 (list old new
) "mv" "-f" "--"))
504 (defvar vc-git-extra-menu-map
505 (let ((map (make-sparse-keymap)))
506 (define-key map
[git-grep
]
507 '(menu-item "Git grep..." vc-git-grep
508 :help
"Run the `git grep' command"))
511 (defun vc-git-extra-menu () vc-git-extra-menu-map
)
513 (defun vc-git-extra-status-menu () vc-git-extra-menu-map
)
515 ;; Derived from `lgrep'.
516 (defun vc-git-grep (regexp &optional files dir
)
517 "Run git grep, searching for REGEXP in FILES in directory DIR.
518 The search is limited to file names matching shell pattern FILES.
519 FILES may use abbreviations defined in `grep-files-aliases', e.g.
520 entering `ch' is equivalent to `*.[ch]'.
522 With \\[universal-argument] prefix, you can edit the constructed shell command line
523 before it is executed.
524 With two \\[universal-argument] prefixes, directly edit and run `grep-command'.
526 Collect output in a buffer. While git grep runs asynchronously, you
527 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
528 in the grep output buffer,
529 to go to the lines where grep found matches.
531 This command shares argument histories with \\[rgrep] and \\[grep]."
534 (grep-compute-defaults)
536 ((equal current-prefix-arg
'(16))
537 (list (read-from-minibuffer "Run: " "git grep"
538 nil nil
'grep-history
)
540 (t (let* ((regexp (grep-read-regexp))
541 (files (grep-read-files regexp
))
542 (dir (read-directory-name "In directory: "
543 nil default-directory t
)))
544 (list regexp files dir
))))))
546 (when (and (stringp regexp
) (> (length regexp
) 0))
547 (let ((command regexp
))
549 (if (string= command
"git grep")
551 (setq dir
(file-name-as-directory (expand-file-name dir
)))
553 (grep-expand-template "git grep -n -e <R> -- <F>" regexp files
))
555 (if (equal current-prefix-arg
'(4))
557 (read-from-minibuffer "Confirm: "
558 command nil nil
'grep-history
))
559 (add-to-history 'grep-history command
))))
561 (let ((default-directory dir
)
562 (compilation-environment '("PAGER=")))
563 ;; Setting process-setup-function makes exit-message-function work
564 ;; even when async processes aren't supported.
565 (compilation-start command
'grep-mode
))
566 (if (eq next-error-last-buffer
(current-buffer))
567 (setq default-directory dir
))))))
569 ;;; Internal commands
571 (defun vc-git-root (file)
572 (vc-find-root file
".git"))
574 (defun vc-git-command (buffer okstatus file-or-list
&rest flags
)
575 "A wrapper around `vc-do-command' for use in vc-git.el.
576 The difference to vc-do-command is that this function always invokes `git'."
577 (apply 'vc-do-command buffer okstatus
"git" file-or-list flags
))
579 (defun vc-git--empty-db-p ()
580 "Check if the git db is empty (no commit done yet)."
581 (not (eq 0 (vc-git--call nil
"rev-parse" "--verify" "HEAD"))))
583 (defun vc-git--call (buffer command
&rest args
)
584 ;; We don't need to care the arguments. If there is a file name, it
585 ;; is always a relative one. This works also for remote
587 (apply 'process-file
"git" nil buffer nil command args
))
589 (defun vc-git--out-ok (command &rest args
)
590 (zerop (apply 'vc-git--call
'(t nil
) command args
)))
592 (defun vc-git--run-command-string (file &rest args
)
593 "Run a git command on FILE and return its output as string."
595 (str (with-output-to-string
596 (with-current-buffer standard-output
597 (unless (apply 'vc-git--out-ok
598 (append args
(list (file-relative-name
603 (defun vc-git-symbolic-commit (commit)
604 "Translate COMMIT string into symbolic form.
605 Returns nil if not possible."
609 (vc-git--out-ok "name-rev" "--name-only" "--tags" commit
)
610 (goto-char (point-min))
611 (= (forward-line 2) 1)
613 (buffer-substring-no-properties (point-min) (1- (point-max)))))))
617 ;; arch-tag: bd10664a-0e5b-48f5-a877-6c17b135be12
618 ;;; vc-git.el ends here