missed it in the back ends.
"Register FILE under bzr.
Signal an error unless REV is nil.
COMMENT is ignored."
- (if rev (error "Can't register explicit version with bzr"))
+ (if rev (error "Can't register explicit revision with bzr"))
(vc-bzr-command "add" nil 0 files))
;; Could run `bzr status' in the directory and see if it succeeds, but
(defun vc-bzr-checkin (files 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"))
+ (if rev (error "Can't check in a specific revision with bzr"))
(vc-bzr-command "commit" nil 0 files "-m" comment))
(defun vc-bzr-checkout (file &optional editable rev destfile)
(unless (fboundp 'vc-default-log-view-mode)
(add-hook 'log-view-mode-hook 'vc-bzr-log-view-mode)))
-(defun vc-bzr-show-log-entry (version)
- "Find entry for patch name VERSION in bzr change log buffer."
+(defun vc-bzr-show-log-entry (revision)
+ "Find entry for patch name REVISION in bzr change log buffer."
(goto-char (point-min))
(let (case-fold-search)
- (if (re-search-forward (concat "^-+\nrevno: " version "$") nil t)
+ (if (re-search-forward (concat "^-+\nrevno: " revision "$") nil t)
(beginning-of-line 0)
(goto-char (point-min)))))
(defalias 'vc-bzr-diff-tree 'vc-bzr-diff)
-;; FIXME: vc-{next,previous}-version need fixing in vc.el to deal with
-;; straight integer versions.
+;; FIXME: vc-{next,previous}-revision need fixing in vc.el to deal with
+;; straight integer revisions.
(defun vc-bzr-delete-file (file)
"Delete FILE and delete it in the bzr repository."
"Internal use.")
(make-variable-buffer-local 'vc-bzr-annotation-table)
-(defun vc-bzr-annotate-command (file buffer &optional version)
+(defun vc-bzr-annotate-command (file buffer &optional revision)
"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 "--long" "--all"
- (if version (list "-r" version)))
+ (if revision (list "-r" revision)))
(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.
;; wouldn't be identified as a merge by git,
;; so it's probably not a good idea.
;; - merge-news (file) see `merge'
-;; - steal-lock (file &optional version) NOT NEEDED
+;; - steal-lock (file &optional revision) NOT NEEDED
;; HISTORY FUNCTIONS
;; * print-log (files &optional buffer) OK
;; - log-view-mode () OK
-;; - show-log-entry (version) NOT NEEDED, DEFAULT IS GOOD
+;; - show-log-entry (revision) NOT NEEDED, DEFAULT IS GOOD
;; - wash-log (file) COULD BE SUPPORTED
;; - logentry-check () NOT NEEDED
;; - comment-history (file) ??
;; MISCELLANEOUS
;; - make-version-backups-p (file) NOT NEEDED
;; - repository-hostname (dirname) NOT NEEDED
-;; - previous-version (file rev) OK
-;; - next-version (file rev) OK
+;; - previous-revision (file rev) OK
+;; - next-revision (file rev) OK
;; - check-headers () COULD BE SUPPORTED
;; - clear-headers () NOT NEEDED
;; - delete-file (file) OK
;;; MISCELLANEOUS
-(defun vc-git-previous-version (file rev)
- "Git-specific version of `vc-previous-version'."
+(defun vc-git-previous-revision (file rev)
+ "Git-specific version of `vc-previous-revision'."
(let ((default-directory (file-name-directory (expand-file-name file)))
(file (file-name-nondirectory file)))
(vc-git-symbolic-commit
(point)
(1- (point-max))))))))
-(defun vc-git-next-version (file rev)
- "Git-specific version of `vc-next-version'."
+(defun vc-git-next-revision (file rev)
+ "Git-specific version of `vc-next-revision'."
(let* ((default-directory (file-name-directory
(expand-file-name file)))
(file (file-name-nondirectory file))
;; - rollback (files) ?? PROBABLY NOT NEEDED
;; - merge (file rev1 rev2) NEEDED
;; - merge-news (file) NEEDED
-;; - steal-lock (file &optional version) NOT NEEDED
+;; - steal-lock (file &optional revision) NOT NEEDED
;; HISTORY FUNCTIONS
;; * print-log (files &optional buffer) OK
;; - log-view-mode () OK
-;; - show-log-entry (version) NOT NEEDED, DEFAULT IS GOOD
+;; - show-log-entry (revision) NOT NEEDED, DEFAULT IS GOOD
;; - wash-log (file) ??
;; - logentry-check () NOT NEEDED
;; - comment-history (file) NOT NEEDED
;; MISCELLANEOUS
;; - make-version-backups-p (file) ??
;; - repository-hostname (dirname) ??
-;; - previous-version (file rev) OK
-;; - next-version (file rev) OK
+;; - previous-revision (file rev) OK
+;; - next-revision (file rev) OK
;; - check-headers () ??
;; - clear-headers () ??
;; - delete-file (file) TEST IT
("^summary:[ \t]+\\(.+\\)" (1 'log-view-message))))))
(defun vc-hg-diff (files &optional oldvers newvers buffer)
- "Get a difference report using hg between two versions of FILES."
+ "Get a difference report using hg between two revisions of FILES."
(let ((working (vc-working-revision (car files))))
(if (and (equal oldvers working) (not newvers))
(setq oldvers nil))
(defun vc-hg-diff-tree (file &optional oldvers newvers buffer)
(vc-hg-diff (list file) oldvers newvers buffer))
-(defun vc-hg-annotate-command (file buffer &optional version)
+(defun vc-hg-annotate-command (file buffer &optional revision)
"Execute \"hg annotate\" on FILE, inserting the contents in BUFFER.
-Optional arg VERSION is a version to annotate from."
- (vc-hg-command buffer 0 file "annotate" "-d" "-n" (if version (concat "-r" version)))
+Optional arg REVISION is a revision to annotate from."
+ (vc-hg-command buffer 0 file "annotate" "-d" "-n" (if revision (concat "-r" revision)))
(with-current-buffer buffer
(goto-char (point-min))
(re-search-forward "^[0-9]")
(beginning-of-line)
(if (looking-at vc-hg-annotate-re) (match-string-no-properties 1))))
-(defun vc-hg-previous-version (file rev)
+(defun vc-hg-previous-revision (file rev)
(let ((newrev (1- (string-to-number rev))))
(when (>= newrev 0)
(number-to-string newrev))))
-(defun vc-hg-next-version (file rev)
+(defun vc-hg-next-revision (file rev)
(let ((newrev (1+ (string-to-number rev)))
- (tip-version
+ (tip-revision
(with-temp-buffer
(vc-hg-command t 0 nil "tip")
(goto-char (point-min))
(re-search-forward "^changeset:[ \t]*\\([0-9]+\\):")
(string-to-number (match-string-no-properties 1)))))
- ;; We don't want to exceed the maximum possible version number, ie
- ;; the tip version.
- (when (<= newrev tip-version)
+ ;; We don't want to exceed the maximum possible revision number, ie
+ ;; the tip revision.
+ (when (<= newrev tip-revision)
(number-to-string newrev))))
;; Modelled after the similar function in vc-bzr.el
(defun vc-mcvs-checkin (files rev comment)
"Meta-CVS-specific version of `vc-backend-checkin'."
- (unless (or (not rev) (vc-mcvs-valid-version-number-p rev))
+ (unless (or (not rev) (vc-mcvs-valid-revision-number-p rev))
(if (not (vc-mcvs-valid-symbolic-tag-name-p rev))
(error "%s is not a valid symbolic tag name" rev)
;; If the input revision is a valid symbolic tag name, we create it
(goto-char (point-min))
(shrink-window-if-larger-than-buffer)
(error "Check-in failed"))))
- ;; Single-file commit? Then update the version by parsing the buffer.
+ ;; Single-file commit? Then update the revision by parsing the buffer.
;; Otherwise we can't necessarily tell what goes with what; clear
;; its properties so they have to be refetched.
(if (= (length files) 1)
(vc-mcvs-command nil 0 file "edit")
(set-file-modes file (logior (file-modes file) 128))
(if (equal file buffer-file-name) (toggle-read-only -1))))
- ;; Check out a particular version (or recreate the file).
+ ;; Check out a particular revision (or recreate the file).
(vc-file-setprop file 'vc-working-revision nil)
(apply 'vc-mcvs-command nil 0 file
(if editable "-w")
(vc-mcvs-command nil 0 new "move" (file-relative-name old)))
(defun vc-mcvs-revert (file &optional contents-done)
- "Revert FILE to the version it was based on."
+ "Revert FILE to the working revision it was based on."
(vc-default-revert 'MCVS file contents-done)
(unless (eq (vc-checkout-model file) 'implicit)
(if vc-mcvs-use-edit
;; Make the file read-only by switching off all w-bits
(set-file-modes file (logand (file-modes file) 3950)))))
-(defun vc-mcvs-merge (file first-version &optional second-version)
+(defun vc-mcvs-merge (file first-revision &optional second-revision)
"Merge changes into current working copy of FILE.
-The changes are between FIRST-VERSION and SECOND-VERSION."
+The changes are between FIRST-REVISION and SECOND-REVISION."
(vc-mcvs-command nil 0 file
"update" "-kk"
- (concat "-j" first-version)
- (concat "-j" second-version))
+ (concat "-j" first-revision)
+ (concat "-j" second-revision))
(vc-file-setprop file 'vc-state 'edited)
(with-current-buffer (get-buffer "*vc*")
(goto-char (point-min))
;; file properties accordingly.
(with-current-buffer (get-buffer "*vc*")
(goto-char (point-min))
- ;; get new workfile version
+ ;; get new working revision
(if (re-search-forward
"^Merging differences between [0-9.]* and \\([0-9.]*\\) into" nil t)
(vc-file-setprop file 'vc-working-revision (match-string 1))
files "log")))
(defun vc-mcvs-diff (files &optional oldvers newvers buffer)
- "Get a difference report using Meta-CVS between two versions of FILES."
+ "Get a difference report using Meta-CVS between two revisions of FILES."
(let* ((async (and (not vc-disable-async-diff)
(vc-stay-local-p files)
(fboundp 'start-process)))
(and rev2 (concat "-r" rev2))
(vc-switches 'MCVS 'diff)))))
-(defun vc-mcvs-annotate-command (file buffer &optional version)
+(defun vc-mcvs-annotate-command (file buffer &optional revision)
"Execute \"mcvs annotate\" on FILE, inserting the contents in BUFFER.
-Optional arg VERSION is a version to annotate from."
+Optional arg REVISION is a revision to annotate from."
(vc-mcvs-command
buffer
(if (and (vc-stay-local-p file) (fboundp 'start-process)) 'async 0)
- file "annotate" (if version (concat "-r" version)))
+ file "annotate" (if revision (concat "-r" revision)))
(with-current-buffer buffer
(goto-char (point-min))
(re-search-forward "^[0-9]")
;;;
(defun vc-mcvs-create-snapshot (dir name branchp)
- "Assign to DIR's current version a given NAME.
+ "Assign to DIR's current revision a given NAME.
If BRANCHP is non-nil, the name is created as a branch (and the current
workspace is immediately moved to that new branch)."
(if (not branchp)
(forward-line 1))))
(defalias 'vc-mcvs-valid-symbolic-tag-name-p 'vc-cvs-valid-symbolic-tag-name-p)
-(defalias 'vc-mcvs-valid-version-number-p 'vc-cvs-valid-version-number-p)
+(defalias 'vc-mcvs-valid-revision-number-p 'vc-cvs-valid-revision-number-p)
(provide 'vc-mcvs)
'(("^[ |]+Author: \\(.*\\)" (1 'change-log-email))
("^[ |]+Date: \\(.*\\)" (1 'change-log-date-face))))))
-;; (defun vc-mtn-show-log-entry (version)
+;; (defun vc-mtn-show-log-entry (revision)
;; )
(defun vc-mtn-wash-log (file))
(defun vc-sccs-working-revision (file)
"SCCS-specific version of `vc-working-revision'."
(with-temp-buffer
- ;; The workfile version is always the latest version number.
+ ;; The working revision is always the latest revision number.
;; To find this number, search the entire delta table,
;; rather than just the first entry, because the
- ;; first entry might be a deleted ("R") version.
+ ;; first entry might be a deleted ("R") revision.
(vc-insert-file (vc-name file) "^\001e\n\001[^s]")
(vc-parse-buffer "^\001d D \\([^ ]+\\)" 1)))
(vc-switches 'SCCS 'checkout)))
(defun vc-sccs-checkout (file &optional editable rev)
- "Retrieve a copy of a saved version of SCCS controlled FILE.
+ "Retrieve a copy of a saved revision of SCCS controlled FILE.
EDITABLE non-nil means that the file should be writable and
locked. REV is the revision to check out."
(let ((file-buffer (get-file-buffer file))
switches))))
(message "Checking out %s...done" file)))
-(defun vc-sccs-cancel-version (files)
+(defun vc-sccs-rollback (files)
"Roll back, undoing the most recent checkins of FILES."
(if (not files)
(error "SCCS backend doesn't support directory-level rollback."))
"Revert FILE to the version it was based on."
(vc-do-command nil 0 "unget" (vc-name file))
(vc-do-command nil 0 "get" (vc-name file))
- ;; Checking out explicit versions is not supported under SCCS, yet.
- ;; We always "revert" to the latest version; therefore
+ ;; Checking out explicit revisions is not supported under SCCS, yet.
+ ;; We always "revert" to the latest revision; therefore
;; vc-working-revision is cleared here so that it gets recomputed.
(vc-file-setprop file 'vc-working-revision nil))
;;;
(defun vc-sccs-assign-name (file name)
- "Assign to FILE's latest version a given NAME."
+ "Assign to FILE's latest revision a given NAME."
(vc-sccs-add-triple name file (vc-working-revision file)))
\f
(defun vc-sccs-parse-locks ()
"Parse SCCS locks in current buffer.
-The result is a list of the form ((VERSION . USER) (VERSION . USER) ...)."
+The result is a list of the form ((REVISION . USER) (REVISION . USER) ...)."
(let (master-locks)
(goto-char (point-min))
(while (re-search-forward "^\\([0-9.]+\\) [0-9.]+ \\([^ ]+\\) .*\n?"
(kill-buffer (current-buffer))))
(defun vc-sccs-lookup-triple (file name)
- "Return the numeric version corresponding to a named snapshot of FILE.
-If NAME is nil or a version number string it's just passed through."
+ "Return the numeric revision corresponding to a named snapshot of FILE.
+If NAME is nil or a revision number string it's just passed through."
(if (or (null name)
(let ((firstchar (aref name 0)))
(and (>= firstchar ?0) (<= firstchar ?9))))
((eq svn-state 'needs-patch) "(patch)")
((eq svn-state 'needs-merge) "(merge)"))))
-(defun vc-svn-previous-version (file rev)
+(defun vc-svn-previous-revision (file rev)
(let ((newrev (1- (string-to-number rev))))
(when (< 0 newrev)
(number-to-string newrev))))
-(defun vc-svn-next-version (file rev)
+(defun vc-svn-next-revision (file rev)
(let ((newrev (1+ (string-to-number rev))))
- ;; The "workfile version" is an uneasy conceptual fit under Subversion;
+ ;; The "working revision" is an uneasy conceptual fit under Subversion;
;; we use it as the upper bound until a better idea comes along. If the
;; workfile version W coincides with the tree's latest revision R, then
;; this check prevents a "no such revision: R+1" error. Otherwise, it
;; file properties accordingly.
(with-current-buffer (get-buffer "*vc*")
(goto-char (point-min))
- ;; get new workfile version
+ ;; get new working revision
(if (re-search-forward
"^\\(Updated to\\|At\\) revision \\([0-9]+\\)" nil t)
(vc-file-setprop file 'vc-working-revision (match-string 2))
buffer
(if (and (= (length files) 1) (vc-stay-local-p (car files)) (fboundp 'start-process)) 'async 0)
files "log"
- ;; By default Subversion only shows the log upto the working version,
+ ;; By default Subversion only shows the log upto the working revision,
;; whereas we also want the log of the subsequent commits. At least
;; that's what the vc-cvs.el code does.
"-rHEAD:0")))
nil)
(defun vc-svn-diff (files &optional oldvers newvers buffer)
- "Get a difference report using SVN between two versions of fileset FILES."
+ "Get a difference report using SVN between two revisions of fileset FILES."
(and oldvers
(catch 'no
(dolist (f files)
;;;
(defun vc-svn-create-snapshot (dir name branchp)
- "Assign to DIR's current version a given NAME.
+ "Assign to DIR's current revision a given NAME.
If BRANCHP is non-nil, the name is created as a branch (and the current
workspace is immediately moved to that new branch).
NAME is assumed to be a URL."
(and (string-match "^[a-zA-Z]" tag)
(not (string-match "[^a-z0-9A-Z-_]" tag))))
-(defun vc-svn-valid-version-number-p (tag)
- "Return non-nil if TAG is a valid version number."
+(defun vc-svn-valid-revision-number-p (tag)
+ "Return non-nil if TAG is a valid revision number."
(and (string-match "^[0-9]" tag)
(not (string-match "[^0-9]" tag))))
HCoop / bpt / emacs.git / commitdiff