changeset 81307:a5186dc625d4

*** empty log message ***

--- a/lisp/ChangeLog	Mon Jun 11 18:41:09 2007 +0000
+++ b/lisp/ChangeLog	Mon Jun 11 20:00:35 2007 +0000
@@ -1,3 +1,7 @@
[phone]  Riccardo Murri  <[e-mail]>
+
+	* vc-bzr.el: New file.
+
 2007-06-11  Stefan Monnier  <[e-mail]>
 
 	* vc-svn.el (vc-svn-program): New var.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/vc-bzr.el	Mon Jun 11 20:00:35 2007 +0000
@@ -0,0 +1,565 @@
+;;; vc-bzr.el --- VC backend for the bzr revision control system
+
+;; Copyright (C) 2006, 2007  Free Software Foundation, Inc.
+
+;; NOTE: THIS IS A MODIFIED VERSION OF Dave Love's vc-bzr.el,
+;; which you can find at: http://www.loveshack.ukfsn.org/emacs/vc-bzr.el
+;; I could not get in touch with Dave Love by email, so 
+;; I am releasing my changes separately. -- Riccardo
+
+;; Author: Dave Love <[e-mail]>, Riccardo Murri <[e-mail]>
+;; Keywords: tools
+;; Created: Sept 2006
+;; Version: 2007-01-17
+;; URL: http://launchpad.net/vc-bzr
+
+;; This file 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 2, or (at your option)
+;; any later version.
+
+;; This file 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+
+;;; Commentary:
+
+;; NOTE: THIS IS A MODIFIED VERSION OF Dave Love's vc-bzr.el,
+;; which you can find at: http://www.loveshack.ukfsn.org/emacs/vc-bzr.el
+
+;; See <URL:http://bazaar-vcs.org/> concerning bzr.
+
+;; Load this library to register bzr support in VC.  The support is
+;; preliminary and incomplete, adapted from my darcs version.  Lightly
+;; exercised with bzr 0.8 and Emacs 21, and bzr 0.11 on Emacs 22.  See
+;; various Fixmes below.
+
+;; This should be suitable for direct inclusion in Emacs if someone
+;; can persuade rms.
+
+
+;;; Code:
+
+(eval-when-compile
+  (require 'vc))                        ; for vc-exec-after
+
+(defgroup vc-bzr nil
+  "VC bzr backend."
+;;   :version "22"
+  :group 'vc)
+
+(defcustom vc-bzr-program "bzr"
+  "*Name of the bzr command (excluding any arguments)."
+  :group 'vc-bzr
+  :type 'string)
+
+;; Fixme: there's probably no call for this.
+(defcustom vc-bzr-program-args nil
+  "*List of global arguments to pass to `vc-bzr-program'."
+  :group 'vc-bzr
+  :type '(repeat string))
+
+(defcustom vc-bzr-diff-switches nil
+  "*String/list of strings specifying extra switches for bzr diff under VC."
+  :type '(choice (const :tag "None" nil)
+                 (string :tag "Argument String")
+                 (repeat :tag "Argument List" :value ("") string))
+  :group 'vc-bzr)
+
+(defvar vc-bzr-version nil
+  "Internal use.")
+
+;; Could be used for compatibility checks if bzr changes.
+(defun vc-bzr-version ()
+  "Return a three-numeric element list with components of the bzr version.
+This is of the form (X Y Z) for revision X.Y.Z.  The elements are zero
+if running `vc-bzr-program' doesn't produce the expected output."
+  (if vc-bzr-version
+      vc-bzr-version
+    (let ((s (shell-command-to-string
+              (concat (shell-quote-argument vc-bzr-program) " --version"))))
+      (if (string-match "\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)$" s)
+          (setq vc-bzr-version (list (string-to-number (match-string 1 s))
+                                     (string-to-number (match-string 2 s))
+                                     (string-to-number (match-string 3 s))))
+        '(0 0 0)))))
+
+(defun vc-bzr-at-least-version (vers)
+  "Return t if the bzr command reports being a least version VERS.
+First argument VERS is a list of the form (X Y Z), as returned by `vc-bzr-version'."
+  (version-list-<= vers (vc-bzr-version)))
+
+;; XXX: vc-do-command is tailored for RCS and assumes that command-line
+;; options precede the file name (ci -something file); with bzr, we need
+; to pass options *after* the subcommand, e.g. bzr ls --versioned.
+(defun vc-bzr-do-command* (buffer okstatus command &rest args)
+  "Execute bzr COMMAND, notifying user and checking for errors.
+This is a wrapper around `vc-do-command', which see for detailed
+explanation of arguments BUFFER, OKSTATUS and COMMAND.
+
+If the optional list of ARGS is present, its elements are
+appended to the command line, in the order given.
+
+Unlike `vc-do-command', this has no way of telling which elements
+in ARGS are file names and which are command-line options, so be
+sure to pass absolute file names if needed.  On the other hand,
+you can mix options and file names in any order."
+  (apply 'vc-do-command buffer okstatus command nil args))
+
+(cond
+ ((vc-bzr-at-least-version '(0 9))
+  ;; since v0.9, bzr supports removing the progress indicators
+  ;; by setting environment variable BZR_PROGRESS_BAR to "none".
+  (defun vc-bzr-command (bzr-command buffer okstatus file &rest args)
+    "Wrapper round `vc-do-command' using `vc-bzr-program' as COMMAND.
+Invoke the bzr command adding `BZR_PROGRESS_BAR=none' to the environment."
+    (let ((process-environment (cons "BZR_PROGRESS_BAR=none" process-environment)))
+      (apply 'vc-do-command buffer okstatus vc-bzr-program
+             file bzr-command (append vc-bzr-program-args args))))
+  
+  (defun vc-bzr-command* (bzr-command buffer okstatus file &rest args)
+    "Wrapper round `vc-bzr-do-command*' using `vc-bzr-program' as COMMAND.
+Invoke the bzr command adding `BZR_PROGRESS_BAR=none' to the environment.
+First argument BZR-COMMAND is passed as the first optional argument to
+`vc-bzr-do-command*'."
+    (let ((process-environment (cons "BZR_PROGRESS_BAR=none" process-environment)))
+      (apply 'vc-bzr-do-command* buffer okstatus vc-bzr-program
+             bzr-command (append vc-bzr-program-args args)))))
+  
+ (t
+  ;; for older versions, we fall back to washing the log buffer
+  ;; when all output has been gathered.
+  (defun vc-bzr-command (command buffer okstatus file &rest args) 
+    "Wrapper round `vc-do-command' using `vc-bzr-program' as COMMAND."
+    ;; Note:  The ^Ms from the progress-indicator stuff that bzr prints
+    ;; on stderr cause auto-detection of a mac coding system on the
+    ;; stream for async output.  bzr ought to be fixed to be able to
+    ;; suppress this.  See also `vc-bzr-post-command-function'.  (We
+    ;; can't sink the stderr output in `vc-do-command'.)
+    (apply 'vc-do-command buffer okstatus vc-bzr-program
+           file command (append vc-bzr-program-args args)))
+
+  (defun vc-bzr-command* (command buffer okstatus &rest args) 
+    "Wrapper round `vc-bzr-do-command*' using `vc-bzr-program' as COMMAND."
+    (apply 'vc-bzr-do-command* buffer okstatus vc-bzr-program
+           command file (append vc-bzr-program-args args)))
+
+  (defun vc-bzr-post-command-function (command file flags)
+    "`vc-post-command-functions' function to remove progress messages."
+    ;; Note that using this requires that the vc command is run
+    ;; synchronously.  Otherwise, the ^Ms in the leading progress
+    ;; message on stdout cause the stream to be interpreted as having
+    ;; DOS line endings, losing the ^Ms, so the search fails.  I don't
+    ;; know how this works under Windows.
+    (when (equal command vc-bzr-program)
+      (save-excursion
+        (goto-char (point-min))
+        (if (looking-at "^\\(\r.*\r\\)[^\r]+$")
+            (replace-match "" nil nil nil 1)))
+      (save-excursion
+        (goto-char (point-min))
+        ;; This is inserted by bzr 0.11 `log', at least
+        (while (looking-at "read knit.*\n")
+          (replace-match "")))))
+
+  (add-hook 'vc-post-command-functions 'vc-bzr-post-command-function)))
+
+;; Fixme:  If we're only interested in status messages, we only need
+;; to set LC_MESSAGES, and we might need finer control of this.  This
+;; is moot anyhow, since bzr doesn't appear to be localized at all
+;; (yet?).
+(eval-when-compile
+(defmacro vc-bzr-with-c-locale (&rest body)
+  "Run BODY with LC_ALL=C in the process environment.
+This ensures that messages to be matched come out as expected."
+  `(let ((process-environment (cons "LC_ALL=C" process-environment)))
+     ,@body)))
+(put 'vc-bzr-with-c-locale 'edebug-form-spec t)
+(put 'vc-bzr-with-c-locale 'lisp-indent-function 0)
+
+(defun vc-bzr-bzr-dir (file)
+  "Return the .bzr directory in the hierarchy above FILE.
+Return nil if there isn't one."
+  (setq file (expand-file-name file))
+  (let ((dir (if (file-directory-p file)
+                 file
+               (file-name-directory file)))
+        bzr)
+    (catch 'found
+      (while t
+        (setq bzr (expand-file-name ".bzr" dir)) ; fixme: "_bzr" on Doze??
+        (if (file-directory-p bzr)
+            (throw 'found (file-name-as-directory bzr)))
+        (if (equal "" (file-name-nondirectory (directory-file-name dir)))
+            (throw 'found nil)
+          (setq dir (file-name-directory (directory-file-name dir))))))))
+
+(defun vc-bzr-registered (file)
+  "Return non-nil if FILE is registered with bzr."
+  (if (vc-bzr-bzr-dir file)             ; short cut
+      (vc-bzr-state file)))             ; expensive
+
+(defun vc-bzr-state (file)
+  (let (ret state conflicts pending-merges)
+    (with-temp-buffer
+      (cd (file-name-directory file))
+      (setq ret (vc-bzr-with-c-locale (vc-bzr-command "status" t 255 file)))
+      (goto-char 1)
+      (save-excursion
+        (when (re-search-forward "^conflicts:" nil t)
+          (message "Warning -- conflicts in bzr branch")))
+      (save-excursion
+        (when (re-search-forward "^pending merges:" nil t)
+          (message "Warning -- pending merges in bzr branch")))
+      (setq state
+            (cond ((not (equal ret 0)) nil)
+                  ((looking-at "added\\|renamed\\|modified\\|removed") 'edited)
+                  ;; Fixme:  Also get this in a non-registered sub-directory.
+                  ((looking-at "^$") 'up-to-date)
+                  ;; if we're seeing this as first line of text,
+                  ;; then the status is up-to-date, 
+                  ;; but bzr output only gives the warning to users.
+                  ((looking-at "conflicts\\|pending") 'up-to-date)
+                  ((looking-at "unknown\\|ignored") nil)
+                  (t (error "Unrecognized output from `bzr status'"))))
+      (when (or conflicts pending-merges)
+        (message 
+         (concat "Warning -- "
+                 (if conflicts "conflicts ")
+                 (if (and conflicts pending-merges) "and ")
+                 (if pending-merges "pending merges ")
+                 "in bzr branch")))
+      (when state
+        (vc-file-setprop file 'vc-workfile-version
+                         (vc-bzr-workfile-version file))
+        (vc-file-setprop file 'vc-state state))
+      state)))
+
+(defun vc-bzr-workfile-unchanged-p (file)
+  (eq 'up-to-date (vc-bzr-state file)))
+
+(defun vc-bzr-workfile-version (file)
+  (with-temp-buffer
+    (vc-bzr-command "revno" t 0 file)
+    (goto-char 1)
+    (buffer-substring 1 (line-end-position))))
+
+(defun vc-bzr-checkout-model (file)
+  'implicit)
+
+(defun vc-bzr-register (file &optional rev comment)
+  "Register FILE under bzr.
+Signal an error unless REV is nil.
+COMMENT is ignored."
+  (if rev (error "Can't register explicit version with bzr"))
+  (vc-bzr-command "add" nil 0 file))
+
+;; Could run `bzr status' in the directory and see if it succeeds, but
+;; that's relatively expensive.
+(defun vc-bzr-responsible-p (file)
+  "Return non-nil if FILE is (potentially) controlled by bzr.
+The criterion is that there is a `.bzr' directory in the same
+or a superior directory."
+  (vc-bzr-bzr-dir file))
+
+(defun vc-bzr-could-register (file)
+  "Return non-nil if FILE could be registered under bzr."
+  (and (vc-bzr-responsible-p file)      ; shortcut
+       (condition-case ()
+           (with-temp-buffer
+             (vc-bzr-command "add" t 0 file "--dry-run")
+             ;; The command succeeds with no output if file is
+             ;; registered (in bzr 0.8).
+             (goto-char 1)
+             (looking-at "added "))
+         (error))))
+
+(defun vc-bzr-unregister (file)
+  "Unregister FILE from bzr."
+  (vc-bzr-command "remove" nil 0 file))
+
+(defun vc-bzr-checkin (file rev comment)
+  "Check FILE in to bzr with log message COMMENT.
+REV non-nil gets an error."
+  (if rev (error "Can't check in a specific version with bzr"))
+  (vc-bzr-command "commit" nil 0 file "-m" comment))
+
+(defun vc-bzr-checkout (file &optional editable rev destfile)
+  "Checkout revision REV of FILE from bzr to DESTFILE.
+EDITABLE is ignored."
+  (unless destfile
+    (setq destfile (vc-version-backup-file-name file rev)))
+  (let ((coding-system-for-read 'binary)
+        (coding-system-for-write 'binary))
+  (with-temp-file destfile
+    (if rev
+        (vc-bzr-command "cat" t 0 file "-r" rev)
+      (vc-bzr-command "cat" t 0 file)))))
+
+(defun vc-bzr-revert (file &optional contents-done)
+  (unless contents-done
+    (with-temp-buffer (vc-bzr-command "revert" t 'async file))))
+
+(eval-when-compile
+  (defvar log-view-message-re)
+  (defvar log-view-file-re)
+  (defvar log-view-font-lock-keywords)
+  (defvar log-view-current-tag-function))
+
+;; Grim hack to account for lack of an extension mechanism for
+;; log-view.  Should be fixed in VC...
+(defun vc-bzr-view-log-function ()
+  "To be added to `log-view-mode-hook' to set variables for bzr output.
+Removes itself after running."
+  (remove-hook 'log-view-mode-hook 'vc-bzr-view-log-function)
+  (require 'add-log)
+  ;; Don't have file markers, so use impossible regexp.
+  (set (make-local-variable 'log-view-file-re) "\\'\\`")
+  (set (make-local-variable 'log-view-message-re) "^ *-+\n *\\(revno: [0-9]+\\|merged: .+\\)")
+  (set (make-local-variable 'log-view-font-lock-keywords)
+       `(("^ *committer: \
+\\([^<(]+?\\)[  ]*[(<]\\([A-Za-z0-9_.-]+@[A-Za-z0-9_.-]+\\)[>)]"
+          nil nil
+          (1 'change-log-name-face nil t)
+          (2 'change-log-email-face nil t)
+          (3 'change-log-email-face nil t))
+         ("^ *timestamp: \\(.*\\)" (1 'change-log-date-face))
+         (,log-view-message-re . 'log-view-message-face)
+;;       ("^  \\(.*\\)$" (1 'log-view-message-face))
+         )))
+
+(defun vc-bzr-print-log (file &optional buffer) ; get buffer arg in Emacs 22
+  "Get bzr change log for FILE into specified BUFFER."
+  ;; Fixme: VC needs a hook to sort out the mode for the buffer, or at
+  ;; least set the regexps right.
+  ;; Fixme: This might need the locale fixing up if things like `revno'
+  ;; got localized, but certainly it shouldn't use LC_ALL=C.
+  ;; NB.  Can't be async -- see `vc-bzr-post-command-function'.
+  (vc-bzr-command "log" buffer 0 file)
+  (add-hook 'log-view-mode-hook 'vc-bzr-view-log-function))
+
+(defun vc-bzr-show-log-entry (version)
+  "Find entry for patch name VERSION in bzr change log buffer."
+  (goto-char (point-min))
+  (let (case-fold-search)
+    (if (re-search-forward (concat "^-+\nrevno: " version "$") nil t)
+        (beginning-of-line 0)
+      (goto-char (point-min)))))
+
+;; Fixem: vc-bzr-wash-log
+
+(autoload 'vc-diff-switches-list "vc" nil nil t)
+
+(defun vc-bzr-diff (file &optional rev1 rev2 buffer)
+  "VC bzr backend for diff."
+  (let ((working (vc-workfile-version file)))
+    (if (and (equal rev1 working) (not rev2))
+        (setq rev1 nil))
+    (if (and (not rev1) rev2)
+        (setq rev1 working))
+    ;; NB.  Can't be async -- see `vc-bzr-post-command-function'.
+    ;; bzr diff produces condition code 1 for some reason.
+    (apply #'vc-bzr-command "diff" (or buffer "*vc-diff*") 1 file
+           "--diff-options" (mapconcat 'identity (vc-diff-switches-list bzr)
+                                       " ")
+           (when rev1
+             (if rev2
+                 (list "-r" (format "%s..%s" rev1 rev2))
+               (list "-r" rev1))))))
+
+(defalias 'vc-bzr-diff-tree 'vc-bzr-diff)
+
+;; Fixme: implement vc-bzr-dir-state, vc-bzr-dired-state-info
+
+;; Fixme: vc-{next,previous}-version need fixing in vc.el to deal with
+;; straight integer versions.
+
+(defun vc-bzr-delete-file (file)
+  "Delete FILE and delete it in the bzr repository."
+  (condition-case ()
+      (delete-file file)
+    (file-error nil))
+  (vc-bzr-command "remove" nil 0 file))
+
+(defun vc-bzr-rename-file (old new)
+  "Rename file from OLD to NEW using `bzr mv'."
+  (vc-bzr-command "mv" nil 0 new old))
+
+(defvar vc-bzr-annotation-table nil
+  "Internal use.")
+(make-variable-buffer-local 'vc-bzr-annotation-table)
+
+(defun vc-bzr-annotate-command (file buffer &optional version)
+  "Prepare BUFFER for `vc-annotate' on FILE.
+Each line is tagged with the revision number, which has a `help-echo'
+property containing author and date information."
+  (apply #'vc-bzr-command "annotate" buffer 0 file "-l" "--all"
+         (if version (list "-r" version)))
+  (with-current-buffer buffer
+    ;; Store the tags for the annotated source lines in a hash table
+    ;; to allow saving space by sharing the text properties.
+    (setq vc-bzr-annotation-table (make-hash-table :test 'equal))
+    (goto-char (point-min))
+    (while (re-search-forward "^\\( *[0-9]+\\) \\(.+\\) +\\([0-9]\\{8\\}\\) |"
+                              nil t)
+      (let* ((rev (match-string 1))
+             (author (match-string 2))
+             (date (match-string 3))
+             (key (match-string 0))
+             (tag (gethash key vc-bzr-annotation-table)))
+        (unless tag
+          (save-match-data
+            (string-match " +\\'" author)
+            (setq author (substring author 0 (match-beginning 0))))
+          (setq tag (propertize rev 'help-echo (concat "Author: " author
+                                                       ", date: " date)
+                                'mouse-face 'highlight))
+          (puthash key tag vc-bzr-annotation-table))
+        (replace-match "")
+        (insert tag " |")))))
+
+;; Definition from Emacs 22
+(unless (fboundp 'vc-annotate-convert-time)
+(defun vc-annotate-convert-time (time)
+  "Convert a time value to a floating-point number of days.
+The argument TIME is a list as returned by `current-time' or
+`encode-time', only the first two elements of that list are considered."
+  (/ (+ (* (float (car time)) (lsh 1 16)) (cadr time)) 24 3600)))
+
+(defun vc-bzr-annotate-time ()
+  (when (re-search-forward "^ *[0-9]+ |" nil t)
+    (let ((prop (get-text-property (line-beginning-position) 'help-echo)))
+      (string-match "[0-9]+\\'" prop)
+      (vc-annotate-convert-time
+       (encode-time 0 0 0
+                    (string-to-number (substring (match-string 0 prop) 6 8))
+                    (string-to-number (substring (match-string 0 prop) 4 6))
+                    (string-to-number (substring (match-string 0 prop) 0 4))
+                    )))))
+
+(defun vc-bzr-annotate-extract-revision-at-line ()
+  "Return revision for current line of annoation buffer, or nil.
+Return nil if current line isn't annotated."
+  (save-excursion
+    (beginning-of-line)
+    (if (looking-at " *\\([0-9]+\\) | ")
+        (match-string-no-properties 1))))
+
+;; Not needed for Emacs 22
+(defun vc-bzr-annotate-difference (point)
+  (let ((next-time (vc-bzr-annotate-time)))
+    (if next-time
+        (- (vc-annotate-convert-time (current-time)) next-time))))
+
+;; FIXME: `bzr root' will return the real path to the repository root,
+;; that is, it can differ from the buffer's current directory name
+;; if there are any symbolic links.
+(defun vc-bzr-root (dir)
+  "Return the root directory of the bzr repository containing DIR."
+  (substring 
+   (shell-command-to-string (concat vc-bzr-program " root " dir)) 0 -1))
+
+;; TODO: it would be nice to mark the conflicted files in  VC Dired,
+;; and implement a command to run ediff and `bzr resolve' once the 
+;; changes have been merged.
+(defun vc-bzr-dir-state (dir &optional localp)
+  "Find the VC state of all files in DIR.
+Optional argument LOCALP is always ignored."
+  (let (at-start bzr-root-directory current-bzr-state current-vc-state)
+    ;; check that DIR is a bzr repository
+    (set 'bzr-root-directory (vc-bzr-root dir))
+    (unless (string-match "^/" bzr-root-directory)
+      (error "Cannot find bzr repository for directory `%s'" dir))
+    ;; `bzr ls --versioned' lists all versioned files;
+    ;; assume they are up-to-date, unless we are given
+    ;; evidence of the contrary.
+    (set 'at-start t)
+    (with-temp-buffer
+      (vc-bzr-command* "ls" t 0 "--versioned" "--non-recursive")
+      (goto-char (point-min))
+      (while (or at-start 
+                 (eq 0 (forward-line)))
+        (set 'at-start nil)
+        (let ((file (expand-file-name
+                     (buffer-substring-no-properties 
+                      (line-beginning-position) (line-end-position))
+                     bzr-root-directory)))
+          (vc-file-setprop file 'vc-state 'up-to-date)
+          ;; XXX: is this correct? what happens if one 
+          ;; mixes different SCMs in the same dir?
+          (vc-file-setprop file 'vc-backend 'BZR))))
+    ;; `bzr status' reports on added/modified/renamed and unknown/ignored files
+    (set 'at-start t)
+    (with-temp-buffer 
+      (vc-bzr-with-c-locale (vc-bzr-command "status" t 0 nil))
+      (goto-char (point-min))
+      (while (or at-start 
+                 (eq 0 (forward-line)))
+        (set 'at-start nil)
+        (cond 
+         ((looking-at "^added") 
+          (set 'current-vc-state 'edited)
+          (set 'current-bzr-state 'added))
+         ((looking-at "^modified") 
+          (set 'current-vc-state 'edited)
+          (set 'current-bzr-state 'modified))
+         ((looking-at "^renamed") 
+          (set 'current-vc-state 'edited)
+          (set 'current-bzr-state 'renamed))
+         ((looking-at "^\\(unknown\\|ignored\\)")
+          (set 'current-vc-state nil)
+          (set 'current-bzr-state 'not-versioned))
+         ((looking-at "  ")
+          ;; file names are indented by two spaces
+          (when current-vc-state
+            (let ((file (expand-file-name
+                         (buffer-substring-no-properties
+                          (match-end 0) (line-end-position))
+                         bzr-root-directory)))
+              (vc-file-setprop file 'vc-state current-vc-state)
+              (vc-file-setprop file 'vc-bzr-state current-bzr-state)
+              (when (eq 'added current-bzr-state)
+                (vc-file-setprop file 'vc-workfile-version "0"))))
+          (when (eq 'not-versioned current-bzr-state)
+            (let ((file (expand-file-name
+                         (buffer-substring-no-properties
+                          (match-end 0) (line-end-position))
+                         bzr-root-directory)))
+              (vc-file-setprop file 'vc-backend 'none)
+              (vc-file-setprop file 'vc-state nil))))
+         (t
+          ;; skip this part of `bzr status' output
+          (set 'current-vc-state nil)
+          (set 'current-bzr-state nil)))))))
+
+(defun vc-bzr-dired-state-info (file)
+  "Bzr-specific version of `vc-dired-state-info'."
+  (if (eq 'edited (vc-state file))
+      (let ((bzr-state (vc-file-getprop file 'vc-bzr-state)))
+        (if bzr-state
+            (concat "(" (symbol-name bzr-state) ")")
+          ;; else fall back to default vc representation
+          (vc-default-dired-state-info 'BZR file)))))
+
+;; In case of just `(load "vc-bzr")', but that's probably the wrong
+;; way to do it.
+(add-to-list 'vc-handled-backends 'BZR)
+
+(eval-after-load "vc"
+  '(add-to-list 'vc-directory-exclusion-list ".bzr" t))
+
+(defconst vc-bzr-unload-hook
+  (lambda ()
+    (setq vc-handled-backends (delq 'BZR vc-handled-backends))
+    (remove-hook 'vc-post-command-functions 'vc-bzr-post-command-function)))
+
+(provide 'vc-bzr)
+;; arch-tag: 8101bad8-4e92-4e7d-85ae-d8e08b4e7c06
+;;; vc-bzr.el ends here