;;; pcvs.el -- A Front-end to CVS.
-;; Copyright (C) 1991-2000 Free Software Foundation, Inc.
+;; Copyright (C) 1991,92,93,94,95,95,97,98,99,2000 Free Software Foundation, Inc.
;; Author: (The PCL-CVS Trust) pcl-cvs@cyclic.com
;; (Per Cederqvist) ceder@lysator.liu.se
;; (Jim Blandy) jimb@cyclic.com
;; (Karl Fogel) kfogel@floss.red-bean.com
;; (Jim Kingdon) kingdon@cyclic.com
-;; (Stefan Monnier) monnier@cs.yale.edu
-;; (Greg Klanderman) greg@alphatech.com
-;; (Jari Aalto+mail.emacs) jari.aalto@poboxes.com
+;; (Stefan Monnier) monnier@cs.yale.edu
+;; (Greg Klanderman) greg@alphatech.com
+;; (Jari Aalto+mail.emacs) jari.aalto@poboxes.com
;; Maintainer: (Stefan Monnier) monnier+lists/cvs/pcl@flint.cs.yale.edu
;; Keywords: CVS, version control, release management
-;; Version: $Name: $
-;; Revision: $Id: pcvs.el,v 1.3 2000/05/10 22:28:36 monnier Exp $
+;; Revision: $Id: pcvs.el,v 1.25 2001/01/29 20:22:28 monnier Exp $
;; This file is part of GNU Emacs.
;; seamlessly (I also use VC).
;; To use PCL-CVS just use `M-x cvs-examine RET <dir> RET'.
-;; There used to be a TeXinfo manual, but it's now so out of date that
-;; it's not even worth looking at it.
+;; There is a TeXinfo manual, which can be helpful to get started.
+
+;;; Bugs:
+
+;; - can somehow ignore important messages like `co aborted' or
+;; or `co: output error: No space left on device'.
;;; Todo:
;; ******** FIX THE DOCUMENTATION *********
;;
-;; - proper `g' that passes safe args and uses either cvs-status or cvs-examine
+;; - rework the displaying of error messages.
+;; - use UP-TO-DATE rather than DEAD when cleaning before `examine'.
+;; - allow to flush messages only
+;; - allow to protect files like ChangeLog from flushing
+;; - automatically cvs-mode-insert files from find-file-hook
+;; (and don't flush them as long as they are visited)
+;; - query the user for cvs-get-marked (for some cmds or if nothing's selected)
+;; - don't return the first (resp last) FI if the cursor is before
+;; (resp after) it.
+;; - allow cvs-confirm-removals to force always confirmation.
+;; - cvs-checkout should ask for a revision (with completion).
+;; - removal confirmation should allow specifying another file name.
+;;
+;; - hide fileinfos without getting rid of them (will require ewok work).
;; - add toolbar entries
;; - marking
;; marking directories should jump to just after the dir.
;; allow (un)marking directories at a time with the mouse.
-;; marking with the mouse should not move point.
;; - liveness indicator
;; - indicate in docstring if the cmd understands the `b' prefix(es).
;; - call smerge-mode when opening CONFLICT files.
;; - checks out module, or alternately does update join
;; - does "cvs -n tag LAST_VENDOR" to find old files into *cvs*
;; cvs-export
-;; (with completion on tag names and hooks to
-;; help generate full releases)
+;; (with completion on tag names and hooks to help generate full releases)
;; - allow cvs-cmd-do to either clear the marks or not.
;; - display stickiness information. And current CVS/Tag as well.
;; - write 'cvs-mode-admin' to do arbitrary 'cvs admin' commands
;; - maybe poll/check CVS/Entries files to react to external `cvs' commands ?
;; - some kind of `cvs annotate' support ?
;; but vc-annotate can be used instead.
-;; - dynamic `g' mapping
-;; Make 'g', and perhaps other commands, use either cvs-update or
-;; cvs-examine depending on the read-only status of the cvs buffer, for
-;; instance.
+;; - proper `g' that passes safe args and uses either cvs-status or cvs-examine
+;; maybe also use cvs-update depending on I-don't-know-what.
;; - add message-levels so that we can hide some levels of messages
;;; Code:
(defvar cvs-from-vc nil "Bound to t inside VC advice.")
-;;;;
+;;;;
;;;; flags variables
-;;;;
+;;;;
(defun cvs-defaults (&rest defs)
(let ((defs (cvs-first defs cvs-shared-start)))
(append defs
- (make-list (- cvs-shared-start (length defs)) (first defs))
+ (make-list (- cvs-shared-start (length defs)) (car defs))
cvs-shared-flags)))
;; For cvs flags, we need to add "-f" to override the cvsrc settings
(defun cvs-menu (e)
"Popup the CVS menu."
(interactive "e")
- (mouse-set-point e)
- (x-popup-menu e cvs-menu-map))
+ (let ((cvs-minor-current-files
+ (list (ewoc-data (ewoc-locate
+ cvs-cookies (posn-point (event-end e)))))))
+ (popup-menu cvs-menu e)))
(defvar cvs-mode-line-process nil
"Mode-line control for displaying info on cvs process status.")
-;;;;
+;;;;
;;;; Query-Type-Descriptor for Tags
-;;;;
+;;;;
(autoload 'cvs-status-get-tags "cvs-status")
(defun cvs-tags-list ()
(defconst cvs-qtypedesc-tag
(cvs-qtypedesc-create 'identity 'identity 'cvs-tags-list 'cvs-tag-history))
-;;;;
+;;;;
(defun cvs-mode! (&optional -cvs-mode!-fun -cvs-mode!-noerror)
"Switch to the *cvs* buffer.
;; the selected window has not been changed by FUN
(select-window cvs-mode!-owin)))))))
-;;;;
+;;;;
;;;; Prefixes
-;;;;
+;;;;
(defvar cvs-branches (list cvs-vendor-branch "HEAD" "HEAD"))
(cvs-prefix-define cvs-branch-prefix
(cvs-prefix-get 'cvs-secondary-branch-prefix))))
(if branch (cons (concat (or arg "-r") branch) flags) flags)))
-;;;;
+;;;;
-(define-minor-mode
- cvs-minor-mode
- "
-This mode is used for buffers related to a main *cvs* buffer.
+(define-minor-mode cvs-minor-mode
+ "This mode is used for buffers related to a main *cvs* buffer.
All the `cvs-mode' buffer operations are simply rebound under
-the \\[cvs-mode-map] prefix.
-"
- nil " CVS")
+the \\[cvs-mode-map] prefix."
+ nil " CVS")
(put 'cvs-minor-mode 'permanent-local t)
from the current buffer."
(let* ((cvs-buf (current-buffer))
(info (cdr (assoc cmd cvs-buffer-name-alist)))
- (name (eval (first info)))
- (mode (second info))
+ (name (eval (nth 0 info)))
+ (mode (nth 1 info))
(dir default-directory)
(buf (cond
(name (cvs-get-buffer-create name))
(set (make-local-variable 'cvs-temp-buffer)
(cvs-get-buffer-create
(eval cvs-temp-buffer-name) 'noreuse))))))
-
+
;; handle the potential pre-existing process
(let ((proc (get-buffer-process buf)))
(when (and (not normal) (processp proc)
;;(set (make-local-variable 'cvs-temp-buffer) (cvs-temp-buffer))
(let ((cookies (ewoc-create 'cvs-fileinfo-pp "\n" "")))
(set (make-local-variable 'cvs-cookies) cookies)
- (make-local-hook 'kill-buffer-hook)
(add-hook 'kill-buffer-hook
(lambda ()
(ignore-errors (kill-buffer cvs-temp-buffer)))
(let ((procbuf (current-buffer))
(cvsbuf cvs-buffer)
(single-dir (or single-dir (eq cvs-execute-single-dir t))))
-
+
(set-buffer procbuf)
(goto-char (point-max))
(unless (bolp) (let ((inhibit-read-only t)) (insert "\n")))
(fi (car fis) (car fis)))
((not (and fis (string= dir (cvs-fileinfo->dir fi))))
(list dir files fis))))))
- (dir (first dir+files+rest))
- (files (second dir+files+rest))
- (rest (third dir+files+rest)))
-
+ (dir (nth 0 dir+files+rest))
+ (files (nth 1 dir+files+rest))
+ (rest (nth 2 dir+files+rest)))
+
;; setup the (current) process buffer
(set (make-local-variable 'cvs-postprocess)
(if (null rest)
postprocess
;; else, we have to register ourselves to be rerun on the rest
`(cvs-run-process ',args ',rest ',postprocess ',single-dir)))
- (make-local-hook 'kill-buffer-hook)
(add-hook 'kill-buffer-hook
(lambda ()
(let ((proc (get-buffer-process (current-buffer))))
(set-process-filter process 'cvs-update-filter)
(set-marker (process-mark process) (point-max))
(ignore-errors (process-send-eof process)) ;close its stdin to avoid hangs
-
+
;; now finish setting up the cvs-buffer
(set-buffer cvsbuf)
(setq cvs-mode-line-process (symbol-name (process-status process)))
(mapcar 'cvs-fileinfo->full-path fis))))
(str (if args (concat "-- Running " cvs-program " " arg " ...\n")
"\n")))
- (if nil (insert str) ;inline
+ (if nil (insert str) ;inline
;;(with-current-buffer cvs-buffer
- (let* ((prev-msg (car (ewoc-get-hf cvs-cookies)))
- (tin (ewoc-nth cvs-cookies 0)))
- ;; look for the first *real* fileinfo (to determine emptyness)
- (while
- (and tin
- (memq (cvs-fileinfo->type (ewoc-data tin))
- '(MESSAGE DIRCHANGE)))
- (setq tin (ewoc-next cvs-cookies tin)))
- ;; cleanup the prev-msg
- (when (string-match "Running \\(.*\\) ...\n" prev-msg)
- (setq prev-msg
- (concat
- "-- last cmd: "
- (match-string 1 prev-msg)
- " --")))
- ;; set the new header and footer
- (ewoc-set-hf cvs-cookies
- str (concat "\n--------------------- "
- (if tin "End" "Empty")
- " ---------------------\n"
- prev-msg))))))
+ (let* ((prev-msg (car (ewoc-get-hf cvs-cookies)))
+ (tin (ewoc-nth cvs-cookies 0)))
+ ;; look for the first *real* fileinfo (to determine emptyness)
+ (while
+ (and tin
+ (memq (cvs-fileinfo->type (ewoc-data tin))
+ '(MESSAGE DIRCHANGE)))
+ (setq tin (ewoc-next cvs-cookies tin)))
+ ;; cleanup the prev-msg
+ (when (string-match "Running \\(.*\\) ...\n" prev-msg)
+ (setq prev-msg
+ (concat
+ "-- last cmd: "
+ (match-string 1 prev-msg)
+ " --")))
+ ;; set the new header and footer
+ (ewoc-set-hf cvs-cookies
+ str (concat "\n--------------------- "
+ (if tin "End" "Empty")
+ " ---------------------\n"
+ prev-msg))))))
(defun cvs-sentinel (proc msg)
(cond
;; a trivial interaction, no need to move it
((or (eq style 'SIMPLE)
- (null (second interact))
- (stringp (second interact)))
+ (null (nth 1 interact))
+ (stringp (nth 1 interact)))
`(defun ,fun ,args ,docstring ,interact
(cvs-mode! (lambda () ,@body))))
;;;
(defun cvs-addto-collection (c fi &optional tin)
- "Add FI to C and return a tin.
+ "Add FI to C and return FI's corresponding tin.
FI is inserted in its proper place or maybe even merged with a preexisting
fileinfo if applicable.
TIN specifies an optional starting point."
(unless tin (setq tin (ewoc-nth c 0)))
(while (and tin (cvs-fileinfo< fi (ewoc-data tin)))
(setq tin (ewoc-prev c tin)))
- (if (null tin) (progn (ewoc-enter-first c fi) nil) ;empty collection
+ (if (null tin) (ewoc-enter-first c fi) ;empty collection
(assert (not (cvs-fileinfo< fi (ewoc-data tin))))
(let ((next-tin (ewoc-next c tin)))
(while (not (or (null next-tin)
(ewoc-enter-after c tin fi)
;; fi == tin
(cvs-fileinfo-update (ewoc-data tin) fi)
- (ewoc-invalidate c tin))
- tin)))
+ (ewoc-invalidate c tin)
+ tin))))
(defcustom cvs-cleanup-functions nil
"Functions to tweak the cleanup process.
;; keep the rest
(t (not (run-hook-with-args-until-success
'cvs-cleanup-functions fi))))))
-
+
;; mark dirs for removal
(when (and keep rm-dirs
(eq (cvs-fileinfo->type last-fi) 'DIRCHANGE)
:noexist t))
\f
-;;;;
+;;;;
;;;; The code for running a "cvs update" and friends in various ways.
-;;;;
+;;;;
(defun-cvs-mode (cvs-mode-revert-buffer . SIMPLE)
(&optional ignore-auto noconfirm)
- "Rerun cvs-examine on the current directory with the defauls flags."
+ "Rerun `cvs-examine' on the current directory with the default flags."
(interactive)
(cvs-examine default-directory t))
;; (tin-delete cookies
;; (tin-nth cookies 1)))
;; Check if CVS is waiting for a lock.
- (beginning-of-line 0) ;Move to beginning of last complete line.
+ (beginning-of-line 0) ;Move to beginning of last complete line.
(when (looking-at "^[ a-z]+: \\(.*waiting for .*lock in \\(.*\\)\\)$")
(let ((msg (match-string 1))
(lock (match-string 2)))
(cvs-create-fileinfo
'MESSAGE "" " "
(concat msg
- (substitute-command-keys
+ (substitute-command-keys
"\n\t(type \\[cvs-mode-delete-lock] to delete it)"))
:subtype 'TEMP))
(pop-to-buffer (current-buffer))
(error "Inconsistent %s in buffer %s" check (buffer-name buf)))))
-(defun-cvs-mode cvs-mode-quit ()
+(defun cvs-mode-quit ()
"Quit PCL-CVS, killing the *cvs* buffer."
(interactive)
(and (y-or-n-p "Quit pcl-cvs? ") (kill-buffer (current-buffer))))
"Display help for various PCL-CVS commands."
(interactive)
(if (eq last-command 'cvs-help)
- (describe-function 'cvs-mode) ; would need to use minor-mode for cvs-edit-mode
+ (describe-function 'cvs-mode) ; would need minor-mode for log-edit-mode
(message
(substitute-command-keys
"`\\[cvs-help]':help `\\[cvs-mode-add]':add `\\[cvs-mode-commit]':commit \
`\\[cvs-mode-remove]':remove `\\[cvs-mode-status]':status \
`\\[cvs-mode-undo]':undo"))))
-(defun cvs-mode-diff-help ()
- "Display help for various PCL-CVS diff commands."
- (interactive)
- (if (eq last-command 'cvs-mode-diff-help)
- (describe-function 'cvs-mode) ; no better docs for diff stuff?
- (message
- (substitute-command-keys
- "`\\[cvs-mode-diff]':diff `\\[cvs-mode-idiff]':idiff \
-`\\[cvs-mode-diff-head]':head `\\[cvs-mode-diff-vendor]':vendor \
-`\\[cvs-mode-diff-backup]':backup `\\[cvs-mode-idiff-other]':other \
-`\\[cvs-mode-imerge]':imerge"))))
-
;; Move around in the buffer
(defun-cvs-mode cvs-mode-previous-line (arg)
"Go to the previous line.
If a prefix argument is given, move by that many lines."
(interactive "p")
- (ewoc-goto-prev cvs-cookies (point) arg))
+ (ewoc-goto-prev cvs-cookies arg))
(defun-cvs-mode cvs-mode-next-line (arg)
"Go to the next line.
If a prefix argument is given, move by that many lines."
(interactive "p")
- (ewoc-goto-next cvs-cookies (point) arg))
+ (ewoc-goto-next cvs-cookies arg))
-;;;;
+;;;;
;;;; Mark handling
-;;;;
+;;;;
(defun-cvs-mode cvs-mode-mark (&optional arg)
"Mark the fileinfo on the current line.
If the fileinfo is a directory, all the contents of that directory are
marked instead. A directory can never be marked."
(interactive)
- (let* ((tin (ewoc-locate cvs-cookies (point)))
+ (let* ((tin (ewoc-locate cvs-cookies))
(fi (ewoc-data tin)))
(if (eq (cvs-fileinfo->type fi) 'DIRCHANGE)
;; it's a directory: let's mark all files inside
(when (cvs-dir-member-p f dir)
(setf (cvs-fileinfo->marked f)
(not (if (eq arg 'toggle) (cvs-fileinfo->marked f) arg)))
- t)) ;Tell cookie to redisplay this cookie.
+ t)) ;Tell cookie to redisplay this cookie.
cvs-cookies
(cvs-fileinfo->dir fi))
;; not a directory: just do the obvious
(defun cvs-mouse-toggle-mark (e)
"Toggle the mark of the entry under the mouse."
(interactive "e")
- (mouse-set-point e)
- (cvs-mode-mark 'toggle))
+ (save-excursion
+ (mouse-set-point e)
+ (cvs-mode-mark 'toggle)))
(defun-cvs-mode cvs-mode-unmark ()
"Unmark the fileinfo on the current line."
"Mark all files."
(interactive)
(ewoc-map (lambda (cookie)
- (unless (eq (cvs-fileinfo->type cookie) 'DIRCHANGE)
- (setf (cvs-fileinfo->marked cookie) t)))
- cvs-cookies))
+ (unless (eq (cvs-fileinfo->type cookie) 'DIRCHANGE)
+ (setf (cvs-fileinfo->marked cookie) t)))
+ cvs-cookies))
(defun-cvs-mode cvs-mode-mark-matching-files (regex)
"Mark all files matching REGEX."
(interactive "sMark files matching: ")
(ewoc-map (lambda (cookie)
- (when (and (not (eq (cvs-fileinfo->type cookie) 'DIRCHANGE))
- (string-match regex (cvs-fileinfo->file cookie)))
- (setf (cvs-fileinfo->marked cookie) t)))
- cvs-cookies))
+ (when (and (not (eq (cvs-fileinfo->type cookie) 'DIRCHANGE))
+ (string-match regex (cvs-fileinfo->file cookie)))
+ (setf (cvs-fileinfo->marked cookie) t)))
+ cvs-cookies))
(defun-cvs-mode cvs-mode-unmark-all-files ()
"Unmark all files.
they should always be unmarked."
(interactive)
(ewoc-map (lambda (cookie)
- (setf (cvs-fileinfo->marked cookie) nil)
- t)
- cvs-cookies))
+ (setf (cvs-fileinfo->marked cookie) nil)
+ t)
+ cvs-cookies))
(defun-cvs-mode cvs-mode-unmark-up ()
"Unmark the file on the previous line."
(interactive)
- (let ((tin (ewoc-goto-prev cvs-cookies (point) 1)))
+ (let ((tin (ewoc-goto-prev cvs-cookies 1)))
(when tin
(setf (cvs-fileinfo->marked (ewoc-data tin)) nil)
(ewoc-invalidate cvs-cookies tin))))
(mapcar 'cdr cvs-ignore-marks-alternatives)
(cvs-qtypedesc-create
(lambda (str) (cdr (assoc str cvs-ignore-marks-alternatives)))
- (lambda (obj) (caar (member* obj cvs-ignore-marks-alternatives :key 'cdr)))
+ (lambda (obj) (car (rassoc obj cvs-ignore-marks-alternatives)))
(lambda () cvs-ignore-marks-alternatives)
nil t))
-
+
(defun-cvs-mode cvs-mode-toggle-marks (arg)
"Toggle whether the next CVS command uses marks.
See `cvs-prefix-set' for further description of the behavior.
\\[universal-argument] 3 selects `toggle-marks'."
(interactive "P")
(cvs-prefix-set 'cvs-ignore-marks-modif arg))
-
+
(defun cvs-ignore-marks-p (cmd &optional read-only)
(let ((default (if (member cmd cvs-invert-ignore-marks)
(not cvs-default-ignore-marks)
Args: &optional IGNORE-MARKS IGNORE-CONTENTS."
(let ((fis nil))
- (dolist (fi (if (boundp 'cvs-minor-current-files)
+ (dolist (fi (if (and (boundp 'cvs-minor-current-files)
+ (consp cvs-minor-current-files))
(mapcar
(lambda (f)
- (let ((f (file-relative-name f)))
- (if (file-directory-p f)
- (cvs-create-fileinfo
- 'DIRCHANGE (file-name-as-directory f) "." "")
- (let ((dir (file-name-directory f))
- (file (file-name-nondirectory f)))
- (cvs-create-fileinfo
- 'UNKNOWN (or dir "") file "")))))
+ (if (cvs-fileinfo-p f) f
+ (let ((f (file-relative-name f)))
+ (if (file-directory-p f)
+ (cvs-create-fileinfo
+ 'DIRCHANGE (file-name-as-directory f) "." "")
+ (let ((dir (file-name-directory f))
+ (file (file-name-nondirectory f)))
+ (cvs-create-fileinfo
+ 'UNKNOWN (or dir "") file ""))))))
cvs-minor-current-files)
(or (and (not ignore-marks)
- (ewoc-collect cvs-cookies
- 'cvs-fileinfo->marked))
- (list (ewoc-data (ewoc-locate cvs-cookies (point)))))))
-
+ (ewoc-collect cvs-cookies 'cvs-fileinfo->marked))
+ (list (ewoc-data (ewoc-locate cvs-cookies))))))
+
(if (or ignore-contents (not (eq (cvs-fileinfo->type fi) 'DIRCHANGE)))
(push fi fis)
;; If a directory is selected, return members, if any.
(setq fis
- (append (ewoc-collect cvs-cookies
- 'cvs-dir-member-p
- (cvs-fileinfo->dir fi))
+ (append (ewoc-collect
+ cvs-cookies 'cvs-dir-member-p (cvs-fileinfo->dir fi))
fis))))
(nreverse fis)))
-(defun* cvs-mode-marked (filter &optional (cmd (symbol-name filter))
- &key read-only one file)
+(defun* cvs-mode-marked (filter &optional cmd
+ &key read-only one file noquery)
"Get the list of marked FIS.
CMD is used to determine whether to use the marks or not.
Only files for which FILTER is applicable are returned.
If READ-ONLY is non-nil, the current toggling is left intact.
If ONE is non-nil, marks are ignored and a single FI is returned.
If FILE is non-nil, directory entries won't be selected."
+ (unless cmd (setq cmd (symbol-name filter)))
(let* ((fis (cvs-get-marked (or one (cvs-ignore-marks-p cmd read-only))
- (and (not file)
- (cvs-applicable-p 'DIRCHANGE filter))))
+ (and (not file)
+ (cvs-applicable-p 'DIRCHANGE filter))))
(force (cvs-prefix-get 'cvs-force-command))
(fis (car (cvs-partition
(lambda (fi) (cvs-applicable-p fi (and (not force) filter)))
fis))))
- (cond
- ((null fis)
- (error "`%s' is not applicable to any of the selected files." filter))
- ((and one (cdr fis))
- (error "`%s' is only applicable to a single file." cmd))
- (one (car fis))
- (t fis))))
+ (when (and (or (null fis) (and one (cdr fis))) (not noquery))
+ (message (if (null fis)
+ "`%s' is not applicable to any of the selected files."
+ "`%s' is only applicable to a single file.") cmd)
+ (sit-for 1)
+ (setq fis (list (cvs-insert-file
+ (read-file-name (format "File to %s: " cmd))))))
+ (if one (car fis) fis)))
(defun cvs-enabledp (filter)
"Determine whether FILTER applies to at least one of the selected files."
- (ignore-errors (cvs-mode-marked filter nil :read-only t)))
+ (ignore-errors (cvs-mode-marked filter nil :read-only t :noquery t)))
(defun cvs-mode-files (&rest -cvs-mode-files-args)
(cvs-mode!
(apply 'cvs-mode-marked -cvs-mode-files-args)))))
;;;
-;;; Interface between CVS-Edit and PCL-CVS
+;;; Interface between Log-Edit and PCL-CVS
;;;
(defun cvs-mode-commit-setup ()
The user will be asked for a log message in a buffer.
The buffer's mode and name is determined by the \"message\" setting
of `cvs-buffer-name-alist'.
-The POSTPROC specified there (typically `cvs-edit') is then called,
+The POSTPROC specified there (typically `log-edit') is then called,
passing it the SETUP argument."
(interactive "P")
;; It seems that the save-excursion that happens if I use the better
;; form of `(cvs-mode! (lambda ...))' screws up a couple things which
- ;; end up being rather annoying (like cvs-edit-mode's message being
+ ;; end up being rather annoying (like log-edit-mode's message being
;; displayed in the wrong minibuffer).
(cvs-mode!)
- (pop-to-buffer (cvs-temp-buffer "message" 'normal 'nosetup))
- (set (make-local-variable 'cvs-minor-wrap-function) 'cvs-commit-minor-wrap)
- (let ((lbd list-buffers-directory)
- (setupfun (or (third (cdr (assoc "message" cvs-buffer-name-alist)))
- 'cvs-edit)))
- (funcall setupfun 'cvs-do-commit setup 'cvs-commit-filelist)
+ (let ((buf (cvs-temp-buffer "message" 'normal 'nosetup))
+ (lbd list-buffers-directory)
+ (setupfun (or (nth 2 (cdr (assoc "message" cvs-buffer-name-alist)))
+ 'log-edit)))
+ (funcall setupfun 'cvs-do-commit setup 'cvs-commit-filelist buf)
+ (set (make-local-variable 'cvs-minor-wrap-function) 'cvs-commit-minor-wrap)
(set (make-local-variable 'list-buffers-directory) lbd)))
(defun cvs-commit-minor-wrap (buf f)
(let ((cvs-ignore-marks-modif (cvs-mode-mark-get-modif "commit")))
(funcall f)))
-(defun cvs-commit-filelist () (cvs-mode-files 'commit nil :read-only t :file t))
+(defun cvs-commit-filelist ()
+ (cvs-mode-files 'commit nil :read-only t :file t :noquery t))
(defun cvs-do-commit (flags)
"Do the actual commit, using the current buffer as the log message."
(interactive (list (cvs-flags-query 'cvs-commit-flags "cvs commit flags")))
- (let ((msg (buffer-string)))
+ (let ((msg (buffer-substring-no-properties (point-min) (point-max))))
(cvs-mode!)
;;(pop-to-buffer cvs-buffer)
(cvs-mode-do "commit" (list* "-m" msg flags) 'commit)))
-;;;;
+;;;;
;;;; CVS Mode commands
-;;;;
+;;;;
(defun-cvs-mode (cvs-mode-insert . NOARGS) (file)
"Insert an entry for a specific file."
(interactive
- (list (read-file-name "File to insert: " nil nil nil
- (ignore-errors
- (cvs-fileinfo->dir
- (car (cvs-mode-marked nil nil :read-only t)))))))
+ (list (read-file-name "File to insert: "
+ ;; Can't use ignore-errors here because interactive
+ ;; specs aren't byte-compiled.
+ (condition-case nil
+ (file-name-as-directory
+ (expand-file-name
+ (cvs-fileinfo->dir
+ (car (cvs-mode-marked nil nil :read-only t)))))
+ (error nil)))))
+ (cvs-insert-file file))
+
+(defun cvs-insert-file (file)
+ "Insert FILE (and its contents if it's a dir) and return its FI."
(let ((file (file-relative-name (directory-file-name file))) last)
(dolist (fi (cvs-fileinfo-from-entries file))
- (setq last (cvs-addto-collection cvs-cookies fi last)))))
+ (setq last (cvs-addto-collection cvs-cookies fi last)))
+ ;; There should have been at least one entry.
+ (goto-char (ewoc-location last))
+ (ewoc-data last)))
+
+(defun cvs-mark-fis-dead (fis)
+ ;; Helper function, introduced because of the need for macro-expansion.
+ (dolist (fi fis)
+ (setf (cvs-fileinfo->type fi) 'DEAD)))
(defun-cvs-mode (cvs-mode-add . SIMPLE) (flags)
"Add marked files to the cvs repository.
`((cvs-run-process (list "-n" "update")
',dirs
'(cvs-parse-process t))
- (dolist (fi ',dirs) (setf (cvs-fileinfo->type fi) 'DEAD))))))
+ (cvs-mark-fis-dead ',dirs)))))
(cvs-mode-run "add" flags fis :postproc postproc))))
(defun-cvs-mode (cvs-mode-diff . DOUBLE) (flags)
(let* ((filter 'diff)
(marked (cvs-get-marked (cvs-ignore-marks-p "diff")))
;;(tins (cvs-filter-applicable filter marked))
- (fis (delete-if-not 'cvs-fileinfo->backup-file marked)))
+ (fis (car (cvs-partition 'cvs-fileinfo->backup-file marked))))
(unless (consp fis)
- (error "No files with a backup file selected!"))
+ (error "No files with a backup file selected!"))
;; let's extract some info into the environment for `buffer-name'
(let* ((dir (cvs-fileinfo->dir (car fis)))
(file (cvs-fileinfo->file (car fis))))
(let ((backup-file (cvs-fileinfo->backup-file fileinfo)))
(unless backup-file
(error "%s has no backup file." (cvs-fileinfo->full-path fileinfo)))
- (list backup-file (cvs-fileinfo->file fileinfo))))
+ (list backup-file (cvs-fileinfo->full-path fileinfo))))
;;
;; Emerge support
;;
;; Ediff support
-;;
+;;
(defvar ediff-after-quit-destination-buffer)
(defvar cvs-transient-buffers)
(dolist (tb tmp-bufs)
(when (and tb (buffer-live-p tb) (not (buffer-modified-p tb)))
(let ((win (get-buffer-window tb t)))
- (when win (delete-window win))
- (kill-buffer tb))))
+ (kill-buffer tb)
+ (when (window-live-p win) (ignore-errors (delete-window win))))))
;; switch back to the *cvs* buffer
(when (and cvs-buf (buffer-live-p cvs-buf)
(not (get-buffer-window cvs-buf t)))
(defun cvs-ediff-diff (b1 b2)
(let ((ediff-after-quit-destination-buffer (current-buffer))
(startup-hook '(cvs-ediff-startup-hook)))
- (ediff-buffers b1 b2 startup-hook 'ediff-revisions)))
+ (ediff-buffers b1 b2 startup-hook 'ediff-revision)))
(defun cvs-ediff-merge (b1 b2 base out)
(let ((ediff-after-quit-destination-buffer (current-buffer))
(defun cvs-retrieve-revision (fileinfo rev)
"Retrieve the given REVision of the file in FILEINFO into a new buffer."
- (save-excursion
- (let* ((file (cvs-fileinfo->full-path fileinfo))
- (buf (create-file-buffer (concat file "." rev))))
- (set-buffer buf)
- (message "Retrieving revision %s..." rev)
- (let ((res (call-process cvs-program nil t nil
- "-q" "update" "-p" "-r" rev file)))
- (when (and res (not (and (equal 0 res))))
- (error "Something went wrong retrieving revision %s: %s" rev res))
- (set-buffer-modified-p nil)
- (let ((buffer-file-name (expand-file-name file)))
- (after-find-file))
- (toggle-read-only 1)
- (message "Retrieving revision %s... Done" rev)
- buf))))
+ (let* ((file (cvs-fileinfo->full-path fileinfo))
+ (buffile (concat file "." rev)))
+ (or (find-buffer-visiting buffile)
+ (with-current-buffer (create-file-buffer buffile)
+ (message "Retrieving revision %s..." rev)
+ (let ((res (call-process cvs-program nil t nil
+ "-q" "update" "-p" "-r" rev file)))
+ (when (and res (not (and (equal 0 res))))
+ (error "Something went wrong retrieving revision %s: %s" rev res))
+ (set-buffer-modified-p nil)
+ (let ((buffer-file-name (expand-file-name file)))
+ (after-find-file))
+ (toggle-read-only 1)
+ (message "Retrieving revision %s... Done" rev)
+ (current-buffer))))))
(eval-and-compile (autoload 'smerge-ediff "smerge-mode"))
(rev2-buf (if rev2 (cvs-retrieve-revision fi rev2)))
;; this binding is used by cvs-ediff-startup-hook
(cvs-transient-buffers (list rev1-buf rev2-buf)))
- (funcall (car cvs-idiff-imerge-handlers)
- rev1-buf (or rev2-buf (find-file-noselect file))))))
+ (funcall (car cvs-idiff-imerge-handlers)
+ rev1-buf (or rev2-buf (find-file-noselect file))))))
(defun-cvs-mode (cvs-mode-idiff-other . NOARGS) ()
"Diff interactively current file to revisions."
(fis (cvs-mode-marked 'diff "idiff" :file t)))
(when (> (length fis) 2)
(error "idiff-other cannot be applied to more than 2 files at a time."))
- (let* ((fi1 (first fis))
+ (let* ((fi1 (car fis))
(rev1-buf (if rev1 (cvs-retrieve-revision fi1 rev1)
(find-file-noselect (cvs-fileinfo->full-path fi1))))
rev2-buf)
(if (cdr fis)
- (let ((fi2 (second fis)))
+ (let ((fi2 (nth 1 fis)))
(setq rev2-buf
(if rev2 (cvs-retrieve-revision fi2 rev2)
(find-file-noselect (cvs-fileinfo->full-path fi2)))))
"Mark a fileinfo xor its members (in case of a directory) as dead."
(if (eq (cvs-fileinfo->type fi) 'DIRCHANGE)
(dolist (fi (ewoc-collect c 'cvs-dir-member-p
- (cvs-fileinfo->dir fi)))
+ (cvs-fileinfo->dir fi)))
(setf (cvs-fileinfo->type fi) 'DEAD))
(setf (cvs-fileinfo->type fi) 'DEAD)))
(member cmd cvs-execute-single-dir)))
(parse (member cmd cvs-parse-known-commands))
(args (append cvsargs (list cmd) flags))
- (after-mode (third (cdr (assoc cmd cvs-buffer-name-alist)))))
+ (after-mode (nth 2 (cdr (assoc cmd cvs-buffer-name-alist)))))
(cvs-cleanup-collection cvs-cookies ;cleanup remaining messages
(eq cvs-auto-remove-handled 'delayed) nil t)
(when (fboundp after-mode)
(cvs-mode-run "status" (cons "-v" flags) (cvs-mode-marked nil "status")
:buf (cvs-temp-buffer "tree")
:dont-change-disc t
- :postproc '((cvs-status-trees))))
+ :postproc '((cvs-status-cvstrees))))
;; cvs log
(when (ignore-errors
(and buffer-read-only
(eq 'CVS (vc-backend buffer-file-name))
- (not (if (fboundp 'vc-editable-p)
- (vc-editable-p buffer-file-name)
- (vc-locking-user buffer-file-name)))))
+ (not (vc-editable-p buffer-file-name))))
;; CVSREAD=on special case
(vc-toggle-read-only))
(goto-char (point-max))
"Remove files.
Returns a list of FIS that should be `cvs remove'd."
(let* ((files (cvs-mode-marked filter cmd :file t :read-only t))
- (fis (delete-if (lambda (fi) (eq (cvs-fileinfo->type fi) 'UNKNOWN))
- (cvs-mode-marked filter cmd)))
+ (fis (cdr (cvs-partition (lambda (fi)
+ (eq (cvs-fileinfo->type fi) 'UNKNOWN))
+ (cvs-mode-marked filter cmd))))
(silent (or (not cvs-confirm-removals)
(cvs-every (lambda (fi)
(or (not (file-exists-p
(cvs-fileinfo->full-path fi)))
(cvs-applicable-p fi 'safe-rm)))
- files))))
+ files)))
+ (tmpbuf (cvs-temp-buffer)))
(when (and (not silent) (equal cvs-confirm-removals 'list))
- (save-excursion
- (pop-to-buffer (cvs-temp-buffer))
- (dolist (fi fis)
- (insert (cvs-fileinfo->full-path fi) "\n"))))
+ (with-current-buffer tmpbuf
+ (cvs-insert-strings (mapcar 'cvs-fileinfo->full-path fis))
+ (cvs-pop-to-buffer-same-frame (current-buffer))
+ (shrink-window-if-larger-than-buffer)))
(if (not (or silent
- (yes-or-no-p (format "Delete %d files? " (length files)))))
+ (unwind-protect
+ (yes-or-no-p (format "Delete %d files? " (length files)))
+ (cvs-bury-buffer tmpbuf cvs-buffer))))
(progn (message "Aborting") nil)
(dolist (fi files)
(let* ((type (cvs-fileinfo->type fi))
(cvs-flags-query 'cvs-tag-flags "tag flags")))
(cvs-mode-do "tag" (append '("-d") flags (list tag))
(when cvs-force-dir-tag 'tag)))
-
+
;; Byte compile files.
(let* ((fi (cvs-mode-marked nil nil :one t))
(default-directory (cvs-expand-dir-name (cvs-fileinfo->dir fi)))
(buffer-file-name (expand-file-name (cvs-fileinfo->file fi))))
- ;; This `save-excursion' is necessary because of interaction between
- ;; dynamic scoping and buffer-local variables:
- ;; the above binding of `buffer-file-name' has temporarily changed the
- ;; buffer-local variable (same thing for `default-directory'), so we
- ;; need to switch back to the original buffer before the unbinding
- ;; restores the old value.
- (save-excursion (add-change-log-entry-other-window))))
+ (kill-local-variable 'change-log-default-name)
+ (add-change-log-entry-other-window)))
;; interactive commands to set optional flags
(defun cvs-execute-single-file (fi extractor program constant-args)
"Internal function for `cvs-execute-single-file-list'."
- (let* ((cur-dir (cvs-fileinfo->dir fi))
- (default-directory (cvs-expand-dir-name cur-dir))
- (inhibit-read-only t)
- (arg-list (funcall extractor fi)))
-
+ (let* ((arg-list (funcall extractor fi))
+ (inhibit-read-only t))
+
;; Execute the command unless extractor returned t.
(when (listp arg-list)
(let* ((args (append constant-args arg-list)))
-
- (insert (format "=== cd %s\n=== %s %s\n\n"
- cur-dir program (cvs-strings->string args)))
-
+
+ (insert (format "=== %s %s\n\n"
+ program (cvs-strings->string args)))
+
;; FIXME: return the exit status?
(apply 'call-process program nil t t args)
(goto-char (point-max))))))
;; FIXME: make this run in the background ala cvs-run-process...
(defun cvs-execute-single-file-list (fis extractor program constant-args)
"Run PROGRAM on all elements on FIS.
-The PROGRAM will be called with pwd set to the directory the files
-reside in. CONSTANT-ARGS is a list of strings to pass as arguments to
-PROGRAM. The arguments given to the program will be CONSTANT-ARGS
-followed by the list that EXTRACTOR returns.
+CONSTANT-ARGS is a list of strings to pass as arguments to PROGRAM.
+The arguments given to the program will be CONSTANT-ARGS followed by
+the list that EXTRACTOR returns.
EXTRACTOR will be called once for each file on FIS. It is given
one argument, the cvs-fileinfo. It can return t, which means ignore
;; read-write changes) which is not changed by `commit'.
(buffer-modified-p buffer))
(with-current-buffer buffer
- (let ((cvs-buf-was-ro buffer-read-only))
- (ignore-errors
- ;; Ideally, we'd like to prevent changing the (minor) modes.
- ;; But we do want to reset the mode for some cases, most notably
- ;; VC. Maybe it'd better to reset VC explicitely ?
- (revert-buffer 'ignore-auto 'dont-ask)) ; 'preserve-modes
- ;; protect the buffer-read-only setting
- (if cvs-buf-was-ro (toggle-read-only 1))))))))
-
+ (ignore-errors
+ (revert-buffer 'ignore-auto 'dont-ask 'preserve-modes)
+ ;; `preserve-modes' avoids changing the (minor) modes. But we
+ ;; do want to reset the mode for VC, so we do it explicitly.
+ (vc-find-file-hook)
+ (when (eq (cvs-fileinfo->type fileinfo) 'CONFLICT)
+ (smerge-mode 1))))))))
\f
(defun cvs-change-cvsroot (newroot)
;;
;;;###autoload
-(defcustom cvs-dired-action 'cvs-examine
+(defcustom cvs-dired-action 'cvs-quickdir
"The action to be performed when opening a CVS directory.
Sensible values are `cvs-examine', `cvs-status' and `cvs-quickdir'."
:group 'pcl-cvs
;; hook into VC
;;
-(if (boundp 'vc-post-command-functions)
- ;; Hook into the new VC.
- (add-hook 'vc-post-command-functions
- (lambda (cmd file flags)
- (cvs-vc-command-advice (current-buffer) cmd (car flags))))
- ;; Hook into the old VC.
- (defadvice vc-simple-command (after pcl-cvs-vc activate)
- (cvs-vc-command-advice "*vc-info*" (ad-get-arg 1) (ad-get-arg 3)))
- (defadvice vc-do-command (after pcl-cvs-vc activate)
- (cvs-vc-command-advice (if (eq t (ad-get-arg 0)) (current-buffer)
- (or (ad-get-arg 0) "*vc*"))
- (ad-get-arg 2)
- (if (stringp (ad-get-arg 4))
- (ad-get-arg 4)
- (ad-get-arg 5)))))
-
-(defun cvs-vc-command-advice (buffer command cvscmd)
- (when (and (setq buffer (get-buffer buffer))
- (equal command "cvs")
+(add-hook 'vc-post-command-functions 'cvs-vc-command-advice)
+
+(defun cvs-vc-command-advice (command file flags)
+ (when (and (equal command "cvs")
;; don't parse output we don't understand.
- (member cvscmd cvs-parse-known-commands))
+ (member (car flags) cvs-parse-known-commands))
(save-excursion
- (let ((dir (with-current-buffer buffer default-directory))
+ (let ((buffer (current-buffer))
+ (dir default-directory)
(cvs-from-vc t))
(dolist (cvs-buf (buffer-list))
(set-buffer cvs-buf)
(add-hook 'after-save-hook 'cvs-mark-buffer-changed)
-;;
-;; hook into uniquify
-;;
-
-(defadvice uniquify-buffer-file-name (after pcl-cvs-uniquify activate)
- (or ad-return-value
- (save-excursion
- (set-buffer (ad-get-arg 0))
- (when (eq major-mode 'cvs-mode)
- (setq ad-return-value list-buffers-directory)))))
-
\f
(provide 'pcvs)
HCoop / bpt / emacs.git / blobdiff