lisp/vc-hg.el

   1 ;;; vc-hg.el --- VC backend for the mercurial version control system
   2
   3 ;; Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5 ;; Author: Ivan Kanis
   6 ;; Keywords: tools
   7
   8 ;; This file is part of GNU Emacs.
   9
  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)
  13 ;; any later version.
  14
  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.
  19
  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.
  24
  25 ;;; Commentary:
  26
  27 ;; This is a mercurial version control backend
  28
  29 ;;; Thanks:
  30
  31 ;;; Bugs:
  32
  33 ;;; Installation:
  34
  35 ;;; Todo:
  36
  37 ;; Implement the rest of the vc interface. See the comment at the
  38 ;; beginning of vc.el. The current status is:
  39
  40 ;; FUNCTION NAME                               STATUS
  41 ;; BACKEND PROPERTIES
  42 ;; * revision-granularity                      OK
  43 ;; STATE-QUERYING FUNCTIONS
  44 ;; * registered (file)                         OK
  45 ;; * state (file)                              OK
  46 ;; - state-heuristic (file)                    ?? PROBABLY NOT NEEDED
  47 ;; - dir-state (dir)                           OK
  48 ;; * working-revision (file)                   OK
  49 ;; - latest-on-branch-p (file)                 ??
  50 ;; * checkout-model (file)                     OK
  51 ;; - workfile-unchanged-p (file)               OK
  52 ;; - mode-line-string (file)                   NOT NEEDED
  53 ;; - dired-state-info (file)                   OK
  54 ;; STATE-CHANGING FUNCTIONS
  55 ;; * register (files &optional rev comment)    OK
  56 ;; * create-repo ()                            OK
  57 ;; - init-revision ()                           NOT NEEDED
  58 ;; - responsible-p (file)                      OK
  59 ;; - could-register (file)                     OK
  60 ;; - receive-file (file rev)                   ?? PROBABLY NOT NEEDED
  61 ;; - unregister (file)                         COMMENTED OUT, MAY BE INCORRECT
  62 ;; * checkin (files rev comment)               OK
  63 ;; * find-revision (file rev buffer)            OK
  64 ;; * checkout (file &optional editable rev)    OK
  65 ;; * revert (file &optional contents-done)     OK
  66 ;; - rollback (files)                          ?? PROBABLY NOT NEEDED
  67 ;; - merge (file rev1 rev2)                    NEEDED
  68 ;; - merge-news (file)                         NEEDED
  69 ;; - steal-lock (file &optional revision)       NOT NEEDED
  70 ;; HISTORY FUNCTIONS
  71 ;; * print-log (files &optional buffer)        OK
  72 ;; - log-view-mode ()                          OK
  73 ;; - show-log-entry (revision)                  NOT NEEDED, DEFAULT IS GOOD
  74 ;; - wash-log (file)                           ??
  75 ;; - logentry-check ()                         NOT NEEDED
  76 ;; - comment-history (file)                    NOT NEEDED
  77 ;; - update-changelog (files)                  NOT NEEDED
  78 ;; * diff (files &optional rev1 rev2 buffer)   OK
  79 ;; - revision-completion-table (files)         OK?
  80 ;; - annotate-command (file buf &optional rev) OK
  81 ;; - annotate-time ()                          OK
  82 ;; - annotate-current-time ()                  ?? NOT NEEDED
  83 ;; - annotate-extract-revision-at-line ()      OK
  84 ;; SNAPSHOT SYSTEM
  85 ;; - create-snapshot (dir name branchp)        NEEDED (probably branch?)
  86 ;; - assign-name (file name)                   NOT NEEDED
  87 ;; - retrieve-snapshot (dir name update)       ?? NEEDED??
  88 ;; MISCELLANEOUS
  89 ;; - make-version-backups-p (file)             ??
  90 ;; - repository-hostname (dirname)             ??
  91 ;; - previous-revision (file rev)               OK
  92 ;; - next-revision (file rev)                   OK
  93 ;; - check-headers ()                          ??
  94 ;; - clear-headers ()                          ??
  95 ;; - delete-file (file)                        TEST IT
  96 ;; - rename-file (old new)                     OK
  97 ;; - find-file-hook ()                         PROBABLY NOT NEEDED
  98 ;; - find-file-not-found-hook ()               PROBABLY NOT NEEDED
  99
 100 ;; Implement Stefan Monnier's advice:
 101 ;; vc-hg-registered and vc-hg-state
 102 ;; Both of those functions should be super extra careful to fail gracefully in
 103 ;; unexpected circumstances. The reason this is important is that any error
 104 ;; there will prevent the user from even looking at the file :-(
 105 ;; Ideally, just like in vc-arch and vc-cvs, checking that the file is under
 106 ;; mercurial's control and extracting the current revision should be done
 107 ;; without even using `hg' (this way even if you don't have `hg' installed,
 108 ;; Emacs is able to tell you this file is under mercurial's control).
 109
 110 ;;; History:
 111 ;;
 112
 113 ;;; Code:
 114
 115 (eval-when-compile
 116   (require 'cl)
 117   (require 'vc))
 118
 119 ;;; Customization options
 120
 121 (defcustom vc-hg-global-switches nil
 122   "*Global switches to pass to any Hg command."
 123   :type '(choice (const :tag "None" nil)
 124          (string :tag "Argument String")
 125          (repeat :tag "Argument List"
 126              :value ("")
 127              string))
 128   :version "22.2"
 129   :group 'vc)
 130
 131 \f
 132 ;;; Properties of the backend
 133
 134 (defun vc-hg-revision-granularity ()
 135      'repository)
 136
 137 ;;; State querying functions
 138
 139 ;;;###autoload (defun vc-hg-registered (file)
 140 ;;;###autoload   "Return non-nil if FILE is registered with hg."
 141 ;;;###autoload   (if (vc-find-root file ".hg")       ; short cut
 142 ;;;###autoload       (progn
 143 ;;;###autoload         (load "vc-hg")
 144 ;;;###autoload         (vc-hg-registered file))))
 145
 146 ;; Modelled after the similar function in vc-bzr.el
 147 (defun vc-hg-registered (file)
 148   "Return non-nil if FILE is registered with hg."
 149   (when (vc-hg-root file)           ; short cut
 150     (let ((state (vc-hg-state file)))  ; expensive
 151       (vc-file-setprop file 'vc-state state)
 152       (not (memq state '(ignored unregistered))))))
 153
 154 (defun vc-hg-state (file)
 155   "Hg-specific version of `vc-state'."
 156   (let*
 157       ((status nil)
 158        (out
 159         (with-output-to-string
 160           (with-current-buffer
 161               standard-output
 162             (setq status
 163                   (condition-case nil
 164                       ;; Ignore all errors.
 165                       (call-process
 166                        "hg" nil t nil "--cwd" (file-name-directory file)
 167                        "status" "-A" (file-name-nondirectory file))
 168                     ;; Some problem happened.  E.g. We can't find an `hg'
 169                     ;; executable.
 170                     (error nil)))))))
 171     (when (eq 0 status)
 172         (when (null (string-match ".*: No such file or directory$" out))
 173           (let ((state (aref out 0)))
 174             (cond
 175              ((eq state ?=) 'up-to-date)
 176              ((eq state ?A) 'edited)
 177              ((eq state ?M) 'edited)
 178              ((eq state ?I) 'ignored)
 179              ((eq state ?R) 'unregistered)
 180              ((eq state ??) 'unregistered)
 181              ((eq state ?C) 'up-to-date) ;; Older mercurials use this
 182              (t 'up-to-date)))))))
 183
 184 (defun vc-hg-dir-state (dir)
 185   (with-temp-buffer
 186     (buffer-disable-undo)               ;; Because these buffers can get huge
 187     (vc-hg-command (current-buffer) nil dir "status" "-A")
 188     (goto-char (point-min))
 189     (let ((status-char nil)
 190           (file nil))
 191       (while (not (eobp))
 192         (setq status-char (char-after))
 193         (setq file
 194               (expand-file-name
 195                (buffer-substring-no-properties (+ (point) 2)
 196                                                (line-end-position))))
 197         (cond
 198          ;; State flag for a clean file is now C, might change to =.
 199          ;; The rest of the possible states in "hg status" output:
 200          ;;      ! = deleted, but still tracked
 201          ;; should not show up in vc-dired, so don't deal with them
 202          ;; here.
 203
 204          ;; Mercurial up to 0.9.5 used C, = is used now.
 205          ((or (eq status-char ?=) (eq status-char ?C))
 206           (vc-file-setprop file 'vc-backend 'Hg)
 207           (vc-file-setprop file 'vc-state 'up-to-date))
 208          ((eq status-char ?A)
 209           (vc-file-setprop file 'vc-backend 'Hg)
 210           (vc-file-setprop file 'vc-working-revision "0")
 211           (vc-file-setprop file 'vc-state 'added))
 212          ((eq status-char ?R)
 213           (vc-file-setprop file 'vc-backend 'Hg)
 214           (vc-file-setprop file 'vc-state 'removed))
 215          ((eq status-char ?M)
 216           (vc-file-setprop file 'vc-backend 'Hg)
 217           (vc-file-setprop file 'vc-state 'edited))
 218          ((eq status-char ?I)
 219           (vc-file-setprop file 'vc-backend 'Hg)
 220           (vc-file-setprop file 'vc-state 'ignored))
 221          ((eq status-char ??)
 222           (vc-file-setprop file 'vc-backend 'none)
 223           (vc-file-setprop file 'vc-state 'unregistered))
 224          ((eq status-char ?!)
 225           nil)
 226          (t     ;; Presently C, might change to = in 0.9.6
 227           (vc-file-setprop file 'vc-backend 'Hg)
 228           (vc-file-setprop file 'vc-state 'up-to-date)))
 229         (forward-line)))))
 230
 231 (defun vc-hg-working-revision (file)
 232   "Hg-specific version of `vc-working-revision'."
 233   (let*
 234       ((status nil)
 235        (out
 236         (with-output-to-string
 237           (with-current-buffer
 238               standard-output
 239             (setq status
 240                   (condition-case nil
 241                       ;; Ignore all errors.
 242                       (call-process
 243                        "hg" nil t nil "--cwd" (file-name-directory file)
 244                        "log" "-l1" (file-name-nondirectory file))
 245                     ;; Some problem happened.  E.g. We can't find an `hg'
 246                     ;; executable.
 247                     (error nil)))))))
 248     (when (eq 0 status)
 249       (if (string-match "changeset: *\\([0-9]*\\)" out)
 250           (match-string 1 out)
 251         "0"))))
 252
 253 ;;; History functions
 254
 255 (defun vc-hg-print-log (files &optional buffer)
 256   "Get change log associated with FILES."
 257   ;; `log-view-mode' needs to have the file names in order to function
 258   ;; correctly. "hg log" does not print it, so we insert it here by
 259   ;; hand.
 260
 261   ;; `vc-do-command' creates the buffer, but we need it before running
 262   ;; the command.
 263   (vc-setup-buffer buffer)
 264   ;; If the buffer exists from a previous invocation it might be
 265   ;; read-only.
 266   (let ((inhibit-read-only t))
 267     ;; We need to loop and call "hg log" on each file separately.
 268     ;; "hg log" with multiple file arguments mashes all the logs
 269     ;; together.  Ironically enough, this puts us back near CVS
 270     ;; which can't generate proper fileset logs either.
 271     (dolist (file files)
 272       (with-current-buffer
 273           buffer
 274         (insert "Working file: " file "\n"))    ;; Like RCS/CVS.
 275       (vc-hg-command buffer 0 file "log"))))
 276
 277 (defvar log-view-message-re)
 278 (defvar log-view-file-re)
 279 (defvar log-view-font-lock-keywords)
 280
 281 (define-derived-mode vc-hg-log-view-mode log-view-mode "Hg-Log-View"
 282   (require 'add-log) ;; we need the add-log faces
 283   (set (make-local-variable 'log-view-file-re) "^Working file:[ \t]+\\(.+\\)")
 284   (set (make-local-variable 'log-view-message-re)
 285        "^changeset:[ \t]*\\([0-9]+\\):\\(.+\\)")
 286   (set (make-local-variable 'log-view-font-lock-keywords)
 287        (append
 288         log-view-font-lock-keywords
 289         '(
 290           ;; Handle the case:
 291           ;; user: FirstName LastName <foo@bar>
 292           ("^user:[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
 293            (1 'change-log-name)
 294            (2 'change-log-email))
 295           ;; Handle the cases:
 296           ;; user: foo@bar
 297           ;; and
 298           ;; user: foo
 299           ("^user:[ \t]+\\([A-Za-z0-9_.+-]+\\(?:@[A-Za-z0-9_.-]+\\)?\\)"
 300            (1 'change-log-email))
 301           ("^date: \\(.+\\)" (1 'change-log-date))
 302           ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message))))))
 303
 304 (defun vc-hg-diff (files &optional oldvers newvers buffer)
 305   "Get a difference report using hg between two revisions of FILES."
 306   (let ((working (vc-working-revision (car files))))
 307     (if (and (equal oldvers working) (not newvers))
 308         (setq oldvers nil))
 309     (if (and (not oldvers) newvers)
 310         (setq oldvers working))
 311     (apply #'vc-hg-command (or buffer "*vc-diff*") nil
 312            (mapcar (lambda (file) (file-name-nondirectory file)) files)
 313            "--cwd" (file-name-directory (car files))
 314            "diff"
 315            (append
 316             (if oldvers
 317                 (if newvers
 318                     (list "-r" oldvers "-r" newvers)
 319                   (list "-r" oldvers))
 320               (list ""))))))
 321
 322 (defun vc-hg-revision-table (files)
 323   (let ((default-directory (file-name-directory (car files))))
 324     (with-temp-buffer
 325       (vc-hg-command t nil files "log" "--template" "{rev} ")
 326       (split-string
 327        (buffer-substring-no-properties (point-min) (point-max))))))
 328
 329 ;; Modelled after the similar function in vc-cvs.el
 330 (defun vc-hg-revision-completion-table (files)
 331   (lexical-let ((files files)
 332                 table)
 333     (setq table (lazy-completion-table
 334                  table (lambda () (vc-hg-revision-table files))))
 335     table))
 336
 337 (defun vc-hg-annotate-command (file buffer &optional revision)
 338   "Execute \"hg annotate\" on FILE, inserting the contents in BUFFER.
 339 Optional arg REVISION is a revision to annotate from."
 340   (vc-hg-command buffer 0 file "annotate" "-d" "-n" (if revision (concat "-r" revision)))
 341   (with-current-buffer buffer
 342     (goto-char (point-min))
 343     (re-search-forward "^[0-9]")
 344     (delete-region (point-min) (1- (point)))))
 345
 346
 347 ;; The format for one line output by "hg annotate -d -n" looks like this:
 348 ;;215 Wed Jun 20 21:22:58 2007 -0700: CONTENTS
 349 ;; i.e: VERSION_NUMBER DATE: CONTENTS
 350 (defconst vc-hg-annotate-re "^[ \t]*\\([0-9]+\\) \\(.\\{30\\}\\): ")
 351
 352 (defun vc-hg-annotate-time ()
 353   (when (looking-at vc-hg-annotate-re)
 354     (goto-char (match-end 0))
 355     (vc-annotate-convert-time
 356      (date-to-time (match-string-no-properties 2)))))
 357
 358 (defun vc-hg-annotate-extract-revision-at-line ()
 359   (save-excursion
 360     (beginning-of-line)
 361     (if (looking-at vc-hg-annotate-re) (match-string-no-properties 1))))
 362
 363 (defun vc-hg-previous-revision (file rev)
 364   (let ((newrev (1- (string-to-number rev))))
 365     (when (>= newrev 0)
 366       (number-to-string newrev))))
 367
 368 (defun vc-hg-next-revision (file rev)
 369   (let ((newrev (1+ (string-to-number rev)))
 370         (tip-revision
 371          (with-temp-buffer
 372            (vc-hg-command t 0 nil "tip")
 373            (goto-char (point-min))
 374            (re-search-forward "^changeset:[ \t]*\\([0-9]+\\):")
 375            (string-to-number (match-string-no-properties 1)))))
 376     ;; We don't want to exceed the maximum possible revision number, ie
 377     ;; the tip revision.
 378     (when (<= newrev tip-revision)
 379       (number-to-string newrev))))
 380
 381 ;; Modelled after the similar function in vc-bzr.el
 382 (defun vc-hg-delete-file (file)
 383   "Delete FILE and delete it in the hg repository."
 384   (condition-case ()
 385       (delete-file file)
 386     (file-error nil))
 387   (vc-hg-command nil 0 file "remove" "--after" "--force"))
 388
 389 ;; Modelled after the similar function in vc-bzr.el
 390 (defun vc-hg-rename-file (old new)
 391   "Rename file from OLD to NEW using `hg mv'."
 392   (vc-hg-command nil 0 new old "mv"))
 393
 394 (defun vc-hg-register (files &optional rev comment)
 395   "Register FILES under hg.
 396 REV is ignored.
 397 COMMENT is ignored."
 398   (vc-hg-command nil 0 files "add"))
 399
 400 (defun vc-hg-create-repo ()
 401   "Create a new Mercurial repository."
 402   (vc-hg-command nil 0 nil "init"))
 403
 404 (defalias 'vc-hg-responsible-p 'vc-hg-root)
 405
 406 ;; Modelled after the similar function in vc-bzr.el
 407 (defun vc-hg-could-register (file)
 408   "Return non-nil if FILE could be registered under hg."
 409   (and (vc-hg-responsible-p file)      ; shortcut
 410        (condition-case ()
 411            (with-temp-buffer
 412              (vc-hg-command t nil file "add" "--dry-run"))
 413              ;; The command succeeds with no output if file is
 414              ;; registered.
 415          (error))))
 416
 417 ;; XXX This would remove the file. Is that correct?
 418 ;; (defun vc-hg-unregister (file)
 419 ;;   "Unregister FILE from hg."
 420 ;;   (vc-hg-command nil nil file "remove"))
 421
 422 (defun vc-hg-checkin (files rev comment)
 423   "Hg-specific version of `vc-backend-checkin'.
 424 REV is ignored."
 425   (vc-hg-command nil 0 files  "commit" "-m" comment))
 426
 427 (defun vc-hg-find-revision (file rev buffer)
 428   (let ((coding-system-for-read 'binary)
 429         (coding-system-for-write 'binary))
 430     (if rev
 431         (vc-hg-command buffer 0 file "cat" "-r" rev)
 432       (vc-hg-command buffer 0 file "cat"))))
 433
 434 ;; Modelled after the similar function in vc-bzr.el
 435 (defun vc-hg-checkout (file &optional editable rev)
 436   "Retrieve a revision of FILE.
 437 EDITABLE is ignored.
 438 REV is the revision to check out into WORKFILE."
 439   (let ((coding-system-for-read 'binary)
 440         (coding-system-for-write 'binary))
 441   (with-current-buffer (or (get-file-buffer file) (current-buffer))
 442     (if rev
 443         (vc-hg-command t 0 file "cat" "-r" rev)
 444       (vc-hg-command t 0 file "cat")))))
 445
 446 (defun vc-hg-checkout-model (file)
 447   'implicit)
 448
 449 ;; Modelled after the similar function in vc-bzr.el
 450 (defun vc-hg-workfile-unchanged-p (file)
 451   (eq 'up-to-date (vc-hg-state file)))
 452
 453 (defun vc-hg-dired-state-info (file)
 454   "Hg-specific version of `vc-dired-state-info'."
 455   (let ((hg-state (vc-state file)))
 456     (if (eq hg-state 'edited)
 457         (if (equal (vc-working-revision file) "0")
 458             "(added)" "(modified)")
 459       ;; fall back to the default VC representation
 460       (vc-default-dired-state-info 'Hg file))))
 461
 462 ;; Modelled after the similar function in vc-bzr.el
 463 (defun vc-hg-revert (file &optional contents-done)
 464   (unless contents-done
 465     (with-temp-buffer (vc-hg-command t 0 file "revert"))))
 466
 467 ;;; Hg specific functionality.
 468
 469 ;;; XXX This functionality is experimental/work in progress. It might
 470 ;;; change without notice.
 471 (defvar vc-hg-extra-menu-map
 472   (let ((map (make-sparse-keymap)))
 473     (define-key map [incoming] '(menu-item "Show incoming" vc-hg-incoming))
 474     (define-key map [outgoing] '(menu-item "Show outgoing" vc-hg-outgoing))
 475     map))
 476
 477 (defun vc-hg-extra-menu () vc-hg-extra-menu-map)
 478
 479 (define-derived-mode vc-hg-outgoing-mode vc-hg-log-view-mode "Hg-Outgoing")
 480
 481 (define-derived-mode vc-hg-incoming-mode vc-hg-log-view-mode "Hg-Incoming")
 482
 483
 484 ;; XXX Experimental function for the vc-dired replacement.
 485 (defun vc-hg-dir-status (dir)
 486   "Return a list of conses (file . state) for DIR."
 487   (with-temp-buffer
 488     (vc-hg-command (current-buffer) nil dir "status")
 489     (goto-char (point-min))
 490     (let ((status-char nil)
 491           (file nil)
 492           (translation '((?= . up-to-date)
 493                          (?C . up-to-date)
 494                          (?A . added)
 495                          (?R . removed)
 496                          (?M . edited)
 497                          (?I . ignored)
 498                          (?! . deleted)
 499                          (?? . unregistered)))
 500           (translated nil)
 501           (result nil))
 502       (while (not (eobp))
 503         (setq status-char (char-after))
 504         (setq file
 505               (buffer-substring-no-properties (+ (point) 2)
 506                                                (line-end-position)))
 507         (setq translated (assoc status-char translation))
 508         (when (and translated (not (eq (cdr translated) 'up-to-date)))
 509           (push (cons file (cdr translated)) result))
 510         (forward-line))
 511       result)))
 512
 513 ;; XXX this adds another top level menu, instead figure out how to
 514 ;; replace the Log-View menu.
 515 (easy-menu-define log-view-mode-menu vc-hg-outgoing-mode-map
 516   "Hg-outgoing Display Menu"
 517   `("Hg-outgoing"
 518     ["Push selected"  vc-hg-push]))
 519
 520 (easy-menu-define log-view-mode-menu vc-hg-incoming-mode-map
 521   "Hg-incoming Display Menu"
 522   `("Hg-incoming"
 523     ["Pull selected"  vc-hg-pull]))
 524
 525 (defun vc-hg-outgoing ()
 526   (interactive)
 527   (let ((bname "*Hg outgoing*"))
 528     (vc-hg-command bname 0 nil "outgoing" "-n")
 529     (pop-to-buffer bname)
 530     (vc-hg-outgoing-mode)))
 531
 532 (defun vc-hg-incoming ()
 533   (interactive)
 534   (let ((bname "*Hg incoming*"))
 535     (vc-hg-command bname 0 nil "incoming" "-n")
 536     (pop-to-buffer bname)
 537     (vc-hg-incoming-mode)))
 538
 539 (declare-function log-view-get-marked "log-view" ())
 540
 541 ;; XXX maybe also add key bindings for these functions.
 542 (defun vc-hg-push ()
 543   (interactive)
 544   (let ((marked-list (log-view-get-marked)))
 545     (if marked-list
 546         (vc-hg-command
 547          nil 0 nil
 548          (cons "push"
 549                (apply 'nconc
 550                       (mapcar (lambda (arg) (list "-r" arg)) marked-list))))
 551          (error "No log entries selected for push"))))
 552
 553 (defun vc-hg-pull ()
 554   (interactive)
 555   (let ((marked-list (log-view-get-marked)))
 556     (if marked-list
 557         (vc-hg-command
 558          nil 0 nil
 559          (cons "pull"
 560                (apply 'nconc
 561                       (mapcar (lambda (arg) (list "-r" arg)) marked-list))))
 562       (error "No log entries selected for pull"))))
 563
 564 ;;; Internal functions
 565
 566 (defun vc-hg-command (buffer okstatus file-or-list &rest flags)
 567   "A wrapper around `vc-do-command' for use in vc-hg.el.
 568 The difference to vc-do-command is that this function always invokes `hg',
 569 and that it passes `vc-hg-global-switches' to it before FLAGS."
 570   (apply 'vc-do-command buffer okstatus "hg" file-or-list
 571          (if (stringp vc-hg-global-switches)
 572              (cons vc-hg-global-switches flags)
 573            (append vc-hg-global-switches
 574                    flags))))
 575
 576 (defun vc-hg-root (file)
 577   (vc-find-root file ".hg"))
 578
 579 (provide 'vc-hg)
 580
 581 ;; arch-tag: bd094dc5-715a-434f-a331-37b9fb7cd954
 582 ;;; vc-hg.el ends here