ClearCase

I always “ct setview my-view-name” before run emacs, ‘cause don’t know find out how to see my dynamic view without this. Then if i need to change dynamic-view then i exit emacs and do “ct setview my-another-view-name” and rerun emacs. Is there any way around this silly process? I tried menu “tools > clearcase > start dynamic view” (which is “vc-clearcase-start-view” command) but no effect. I’m clearcase newbie and using vc-clearcase(v1.95) --JoonhwanLee

The setview command will start a subshell, and the subshell will have the dynamic view set. Any process started from that subshell will have that view, but any parent processes will not. The real bottom line is that you cannot set a dynamic view from any text editor or IDE. This is not a limitation of emacs + vc-clearcase.

Also, in my experience the setview command is not that useful. The only use is to get the current view name back using the pwv. Of course, in emacs you can edit files in different views, so there is no concept of current view at emacs level. vc-clearcase.el tracks the current view of each individual file and you can find it using vc-clearcase-what-view-tag, bound to C-x v t. If you edit the same file in different views, it might be useful to the uniquify.el library, with the uniquify-buffer-name-style set to post-forward. When you edit the same file in different views, emacs will append the view name to the buffer name of the file, this is really useful to know which file you are actually editing.

HINT: I usually create a symbolic link in my home directory to the project(s) I’m working on, for example, ~/v/my-project is linked to /view/{my-view-tag}/vobs/{vob-tag}/path-to-my-project. Much easier to access the version controlled files.

--AlexHarsanyi

Well, it looks like your makefile contains a hard coded path. It is a bad idea to have a hard coded path in a Makefile or any script. I would suggest to change the makefile to use only relative paths, but if you cannot do that, you are stuck with the “setview” command. You see, the “setview” command will make /vobs/something point to your view in the new shell that “setview” started. At the same time, a different user can have /vobs/something point to his view in the new shell that his “setview” started. You cannot do that with symbolic links. A symbolic link will point to the same destination no matter which user is looking at it.

None of the projects I worked on (and some were pretty large) depended on absolute paths. You could put the source code tree in any directory and the project would build fine. I suggested using symbolic links only to save some typing when opening a file name, not to organize your build system.

To summarize: your build system depends on “setview” and the only way to avoid using “setview” is to change your buildsystem.

--AlexHarsanyi

I use Kevin Esler’s clearcase.el with cvs gnu emacs (or 21.3) on ms windows 2000 and have problems with encoding of the comments. We have the check-in comments in the source-files, and if I have a used RETURN in my comment, I get ^M on all lines but the breaked comment line. Is it possible to avoid this? Is the buffer somehow encoded with the wrong buffer-file-coding-system?

--Mats

According to ECB doc, we might be able to use ecb with clearcase vc backend. I’m trying to do this.

As of today(2007-07-04), AlexandruHarsanyi’s vc-clearcase.el, vc-clearcase-dir-state func has not been implemented. I’m trying to use vc-clearcase backend within ecb package and need this func. how about using like this.

(defun vc-clearcase-dir-state (dir)
  (let ((fdir (expand-file-name dir))
		pwv )
	(if (string-match "\\*\\*[ ]*NONE[ ]*\\*\\*"
				  (shell-command-to-string 
				   (concat "cd "
						   fdir
						   "; cleartool pwv -short -wdview")))
		nil t)))

I’m still a newbiew in both elisp and clearcase … but it seems to me that it’s not that hard.

I just had a look at the ECB documentation and it looks like what it needs is a function which identifies if a directory is managed by ClearCase or not. Your original implementation is almost correct except you gave it the wrong name, ‘vc-clearcase-dir-state’ is supposed to do much more than identify if a directory is under ClearCase or not.

The only problem with your implementation (apart from the name of the function) is that you need to return ‘CLEARCASE instead of t if the directory is managed by ClearCase. I believe this is what ECB needs:

(defun ecb-vc-dir-managed-by-CLEARCASE (dir)
  (let ((default-directory dir))
    (unless (string-match 
             "\\*\\* NONE \\*\\*"
             (shell-command-to-string "cleartool pwv -wdview -short"))
      'CLEARCASE)))

(add-to-list 'ecb-vc-supported-backends 'ecb-vc-dir-managed-by-CLEARCASE)

I have tested the above function and it identifies ClearCase directories correctly. I have not tested it in ECB, since I don’t use it.

--AlexHarsanyi.

Whenever i’m working on multiple files checked out and need to check in them at once, i still using shell command not visiting all buffers and c-x v v to make work brief. But using shell, i collect all pathname of files checked out and this make me feel there must be better way. Is there a better way for this?

--JoonhwanLee

If i’m in the case of checking in all checked out files in my private view, i don’t use c-x v v but use shell command(<pre>cleartool ci -c `mylsco`</pre>, where mylsco is a alias for listing all checked out files in my private view by me). But, sometimes, i have to checked in some of checked out files and in this case, i just have to visit every file and c-x v v. After reading above Alex’s comment, i thought there could be function who can show checked out files in current view in dired-mode. If so, we could select some of them and do something using M-!.

maybe..

(defun joon:cc-mylsco-dired (curr-view-tag)
  "hacked from `find-dired' defun. my lschecout of clearcase objects...and show them in dired mode"
  (interactive
   (list
    (ah-clearcase-read-view-tag
     "view for mylsco-dired: "
     ;; get an initial view-tag if possible.
     (let ((file (buffer-file-name (current-buffer))))
       (when (and file (vc-clearcase-registered file))
		 (ah-clearcase-fprop-view-tag (ah-clearcase-file-fprop file)))))))
  (let* ((dir (concat "/view/" curr-view-tag "/vobs/opal/"))
		 (dired-buffers dired-buffers)
		(mylsco-cmd (concat "cleartool lsco -cview -all -short "  dir))
		(relpath-filter-cmd (concat "sed -e 's/\\/view\\/" curr-view-tag "//p' -e 's/\\/vobs\\/opal\\///p'")))
    ;; Expand DIR ("" means default-directory), and make sure it has a
    ;; trailing slash.
    ;; Check that it's really a directory.
    (or (file-directory-p dir)
		(error "non-existing directory: %s" dir))
    (switch-to-buffer (get-buffer-create (concat "mylsco@" dir)))

    ;; See if there's still a `find' running, and offer to kill
    ;; it first, if it is.
    (let ((find (get-buffer-process (current-buffer))))
      (when find
		(if (or (not (eq (process-status find) 'run))
				(yes-or-no-p "A `find' process is running; kill it? "))
			(condition-case nil
				(progn
				  (interrupt-process find)
				  (sit-for 1)
				  (delete-process find))
			  (error nil))
		  (error "Cannot have two processes in `%s' at once" (buffer-name)))))

    (widen)
    (kill-all-local-variables)
    (setq buffer-read-only nil)
    (erase-buffer)
	(setq default-directory dir)
    ;; Start the find process.
    (shell-command (concat "ls " (cdr find-ls-option) " `"
						   mylsco-cmd 
						   "` | "
						   relpath-filter-cmd
						   "&")
				   (current-buffer))
    ;; The next statement will bomb in classic dired (no optional arg allowed)
    (dired-mode dir (cdr find-ls-option))
    (let ((map (make-sparse-keymap)))
      (set-keymap-parent map (current-local-map))
      (define-key map "\C-c\C-k" 'kill-find)
      (use-local-map map))
    (make-local-variable 'dired-sort-inhibit)
    (setq dired-sort-inhibit t)
    (set (make-local-variable 'revert-buffer-function)
		 `(lambda (ignore-auto noconfirm)
			(joon:cc-mylsco-dired ,curr-view-tag)))
    ;; Set subdir-alist so that Tree Dired will work:
    (if (fboundp 'dired-simple-subdir-alist)
		;; will work even with nested dired format (dired-nstd.el,v 1.15
		;; and later)
		(dired-simple-subdir-alist)
      ;; else we have an ancient tree dired (or classic dired, where
      ;; this does no harm)
      (set (make-local-variable 'dired-subdir-alist)
		   (list (cons default-directory (point-min-marker)))))
    (set (make-local-variable 'dired-subdir-switches) find-ls-subdir-switches)
    (setq buffer-read-only nil)
    ;; Subdir headlerline must come first because the first marker in
    ;; subdir-alist points there.
    (insert "  " dir ":\n")
    ;; Make second line a ``find'' line in analogy to the ``total'' or
    ;; ``wildcard'' line.
    (insert "  " mylsco-cmd "\n")
    (setq buffer-read-only t)
    (let ((proc (get-buffer-process (current-buffer))))
      (set-process-filter proc (function find-dired-filter))
      (set-process-sentinel proc (function find-dired-sentinel))
      ;; Initialize the process marker; it is used by the filter.
      (move-marker (process-mark proc) 1 (current-buffer)))
    (setq mode-line-process '(":%s"))))

When M-x joon:cc-mylsco-dired while opening any source under clearcase, i can easily see all checked out files in dired mode, and select some of them and <pre>M-! cleartool ci -ptime -c ‘###bgz#1234 hacked the find-dired’ *</pre>. With the tailing ‘*’, all files are checked in ‘pseudo-atomically’. There can be caveat in my above implementation for doing this ‘cause i’m just novice in elisp. Maybe we can still go further by adding defun that can do check in like c-x v v way(showing <pre>vc-log</pre> buffer to get user’s check in comment) for this dired buffer.

When I configure ClearCase to use a third party diffing tool (e.g. Beyond Compare) it breaks support doing diffs in both vc-clearcase.el and clearcase.el. I modified

C:\Program Files\Rational\ClearCase\lib\mgrs\map

as described here:

http://www.scootersoftware.com/support.php?c=kb_vcs.php

Is there a way to fix this so that I can have the best of both worlds?