Adding clearcase, find libs

clearcase.el

@@ -0,0 +1,87 @@
+;;; --------------------------------------------------------------------
+;;; clearcase utils
+;;; --------------------------------------------------------------------
+
+(defun clt-lsvtree ()
+  "Run clt lsvtree -g on the current buffer's file"
+  (interactive)
+  (shell-command (concat "clt lsvtree -g \"" (buffer-file-name) "\" &")))
+
+(defun clt-diff ()
+  "Run clt lsvtree -g on the current buffer's file"
+  (interactive)
+  (shell-command (concat "clt diff -g -predecessor \"" (buffer-file-name) "\" &")))
+
+(defun clt-co ()
+  "Checkout the current buffer's file"
+  (interactive)
+  (when (= 0 (shell-command (concat "clt co -nc \"" (buffer-file-name) "\"")))
+    (revert-buffer)))
+
+(defun clt-ci (comment)
+  "Checkin the current buffer's file"
+  (interactive "sComment: ")
+  (let* ((c (if (and comment (> (length comment) 0)) comment nil))
+         (cmd (concat "clt ci " 
+                      (if c (concat "-c \"" c "\" ") "-nc ")
+                      (buffer-file-name))))
+    (when (= 0 (shell-command cmd))
+    (revert-buffer t t))))
+
+(defun clt-unco ()
+  "Uncheckout the current buffer's file"
+  (interactive)
+  (when (= 0 (shell-command (concat "clt unco -keep \"" (buffer-file-name) "\"")))
+    (revert-buffer)))
+
+(defun clt-ls ()
+  "See clearcase status of the current buffer's file"
+  (interactive)
+  (shell-command (concat "clt ls -long " (buffer-file-name) " &")))
+
+(defun clt-annotate ()
+  "Who wrote this horrible, horrible code?"
+  (interactive)
+  (shell-command (concat "clt annotate " (buffer-file-name) " "))
+  (find-file (concat (buffer-file-name) ".ann")))
+
+(defun clt-lsco ()
+  "List checkouts on current branch. Uses current-directory."
+  (interactive)
+  (shell-command "clt lsco -cvi -avo -sh" "*checkouts*"))
+
+(defun clt-made-on-this-branch ()
+  "List files versions made in this branch."
+  (interactive)
+  ;; TODO: fragile: assumes branch name is 3rd line in config spec
+  (shell-command "clt catcs | head -3 | tail -1 | sed 's/^# *//' | xargs -IBRANCH clt find -avobs -branch 'brtype(BRANCH)' -print -nxname" "*made-on-this-branch*"))
+
+(defun clt-lspriv () 
+  "List private files starting from current directory"
+  (interactive)
+  (shell-command "clt lsprivate . | egrep -v checkedout | egrep -v '#.*#' | egrep -v '*.class$'" "*private-files*"))
+
+(defun clt-explore () 
+  "Start clearexplorer in current directory"
+  (interactive)
+  (shell-command "clearexplorer . &" "*clt-explorer*"))
+
+(defun clt-pred ()
+  "List clearcase predecessor"
+  (interactive)
+  (let* ((cmd (concat "clt describe -fmt \"%En@@%PSn\n\" " (buffer-file-name)))
+         (pred (shell-command-to-string cmd))
+         (pred-len (length pred))
+         (predd (if (> pred-len 1) (substring pred 0 (- pred-len 1)) pred)))
+    (message "Predecessor is %s" predd)
+    predd))
+
+(defun clt-ediff () 
+  "Ediff to Clearcase predecessor"
+  (interactive)
+  (let ((pred (clt-pred)))
+    (message "Predecessor is %s" pred)
+    (if (file-exists-p pred)
+        (ediff-files pred (buffer-file-name)))))
+
+(provide 'clearcase)

host-kelma12755.el

@@ -2,7 +2,7 @@
 
 (require 'mk-project)
 (require 'cl)
-;(require 'clearcase)
+(require 'clearcase)
 
 (when (file-exists-p "~/.emacs.d/emacs-color-theme-solarized")
   (add-to-list 'custom-theme-load-path "~/.emacs.d/emacs-color-theme-solarized")

lib/find.el

@@ -0,0 +1,239 @@
+ ;;; find.el --- Build a valid find(1) command with sexps
+
+;; Copyright (C) 2008 Philip Jackson
+
+;; Author: Philip Jackson <[email protected]>
+;; Version: 0.1
+
+;; This file is not currently part of GNU Emacs.
+
+;; This program 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 program 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 this program ; see the file COPYING.  If not, write to
+;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; With this module you can build up a (hopefully) valid find(1)
+;; string ready for the command line. For example:
+
+;;     (find (prune (name ".svn" ".git" ".CVS"))
+;;           (and (or (name "*.pl" "*.pm" "*.t")
+;;                    (mtime "+1"))
+;;                (fstype "nfs" "ufs")))
+
+;; will become (un-wrapped):
+
+;;     "find '/home/phil/' \\( \\( -name '.svn' -or -name '.git' -or
+;;      -name '.CVS' \\) -prune -or -true \\) \\( \\( \\( -name '*.pl'
+;;      -or -name '*.pm' -or -name '*.t' \\) -or -mtime '+1' \\) -and \\(
+;;      -fstype 'nfs' -or -fstype 'ufs' \\) \\)"
+
+(defconst find-constituents
+  '((and . find-and)
+    (not . find-not)
+    (or  . find-or)
+
+    (a . find-and)
+    (n . find-not)
+    (o . find-or)
+
+    (prune . find-prune)
+
+    ;; switches
+    (L . (0))
+    (P . (0))
+    (H . (0))
+
+    ;; generic tests
+    (amin       . (1))
+    (anewer     . (1))
+    (atime      . (1))
+    (cmin       . (1))
+    (cnewer     . (1))
+    (ctime      . (1))
+    (empty      . (0))
+    (false      . (0))
+    (fstype     . (1))
+    (gid        . (1))
+    (group      . (1))
+    (ilname     . (1))
+    (iname      . (1))
+    (inum       . (1))
+    (iwholename . (1))
+    (iregex     . (1))
+    (links      . (1))
+    (lname      . (1))
+    (mmin       . (1))
+    (mtime      . (1))
+    (name       . (1))
+    (newer      . (1))
+    (nouser     . (0))
+    (nogroup    . (0))
+    (path       . (1))
+    (perm       . (0))
+    (regex      . (1))
+    (wholename  . (1))
+    (size       . (1))
+    (true       . (0))
+    (type       . (1))
+    (uid        . (1))
+    (used       . (1))
+    (user       . (1))
+    (xtype      . (nil))
+
+    ;; normal options (always true)
+    (depth                 . (0))
+    (maxdepth              . (1))
+    (mindepth              . (1))
+    (mount                 . (0))
+    (noleaf                . (0))
+    (xdev                  . (0))
+    (ignore_readdir_race   . (0))
+    (noignore_readdir_race . (0))
+
+    ;; actions
+    (delete  . (0))
+    (print0  . (0))
+    (printf  . (1))
+    (fprintf . (2))
+    (print   . (0))
+    (fprint0 . (1))
+    (fprint  . (1))
+    (ls      . (0))
+    (fls     . (1))
+    (prune   . (0))
+    (quit    . (0))
+
+    ;; these need to be terminated with a ;
+    (exec    . (1 find-command t))
+    (ok      . (1 find-command t))
+    (execdir . (1 find-command t))
+    (okdir   . (1 find-command t)))
+  "Holds details of each of the find options. The car of each
+alist is the name. The cdr is minimum args, the function used
+to join many occurences of the argument together, and whether or
+not to leave quotes off the string (non-nil means the string will
+be quoted).")
+
+;;;###autoload
+(defmacro find (&rest subfinds)
+  "Initiate the building of a find command. For exmple:
+
+  \(find \(prune \(name \".svn\" \".git\" \".CVS\"\)\)
+        \(and \(or \(name \"*.pl\" \"*.pm\" \"*.t\"\)
+                 \(mtime \"+1\"\)\)
+             \(fstype \"nfs\" \"ufs\"\)\)\)
+
+`default-directory' is used as the initial search path. The
+result is a string that should be ready for the command line."
+  (concat "find '" (expand-file-name default-directory) "' "
+          (cond
+            ((cdr subfinds)
+             (mapconcat 'find-to-string subfinds ""))
+            (t
+             (find-to-string (car subfinds))))))
+
+(defun find-and (form)
+  "And FORMs together, so:
+  \(and \(mtime \"+1\"\) \(name \"something\"\)\)
+will produce:
+  find . \\\( -mtime '+1' -and -name 'something' \\\)"
+  (if (< (length form) 2)
+      (find-to-string (car form))
+      (concat "\\( "
+              (mapconcat 'find-to-string form "-and ")
+              "\\) ")))
+
+(defun find-or (form)
+  "Or FORMs together, so:
+  \(or \(mtime \"+1\"\) \(name \"something\"\)\)
+will produce:
+  find . \\\( -mtime '+1' -or -name 'something' \\\)"
+  (if (< (length form) 2)
+      (find-to-string (car form))
+      (concat "\\( "
+              (mapconcat 'find-to-string form "-or ")
+              "\\) ")))
+
+(defun find-not (form)
+  "Or FORMs together and prefix with a -not, so:
+  \(not \(mtime \"+1\"\) \(name \"something\"\)\)
+will produce:
+  -not \\\( -mtime '+1' -or -name 'something' \\\)
+If you wanted the FORMs -and(ed) together instead then this would
+suffice:
+  \(not \(and \(mtime \"+1\"\) \(name \"something\"\)\)\)"
+  (concat "-not " (find-or (mapcar 'find-to-string form))))
+
+(defun find-prune (form)
+  "-or together FORM(s) postfix '-prune' and then -or that with a
+-true, so:
+  \(prune \(name \".svn\" \".git\"\)\) \(name \"*.pm\"\)
+will produce (unwrapped):
+  \\\( \\\( \\\( -name '.svn' -or -name '.git' \\\) /
+  -prune -or -true \\\) -and -name '*.pm' \\\)"
+  (find-or
+   (list
+    (concat (find-or (mapcar 'find-to-string form)) (find-generic "prune"))
+    (find-generic "true"))))
+
+(defun find-generic (option &optional oper argcount args noquotes)
+  "This function allows an arbitrary string to be used as a
+form. OPTION is the name of the form, OPER is the function used
+to either OR or AND multiple results together. ARGCOUNT is the
+minimum of args that OPTION can receive and ARGS are the
+arguments for OPTION."
+  (when (and (numberp argcount) (< (length args) argcount))
+    (error "'%s' needs at least %d arguments" option argcount))
+  (let ((oper (or oper 'find-or)))
+    (if (and args (length args))
+        ; oper (usually and/or) our args together
+        (funcall oper
+                 (mapcar (lambda (x)
+                           (concat "-" option
+                                   (if noquotes
+                                       (concat " " x " ")
+                                       (concat " '" x "' "))))
+                         args))
+        ; just one arg (like -delete)
+        (concat "-" option " "))))
+
+(defun find-command (form)
+  "For each item in FORM add a terminating semi-colon and turn
+them into valid switches. The result is -and(ed) together."
+  (find-and (mapcar (lambda (x)
+                      (concat (find-to-string x) "\\; "))
+                    form)))
+
+(defun find-to-string (form)
+  "Parse FORM to produce a set of valid find arguments."
+  (cond
+    ((stringp form)
+     form)
+    ((consp form)
+     (let ((option (cdr (assoc (car form) find-constituents))))
+       (cond
+         ((and (symbolp option) (fboundp option))
+          (funcall option (cdr form)))
+         ((consp option)
+          (let ((option (symbol-name (car form)))
+                (argcnt (car option))
+                (oper (cadr option))
+                (noquotes (car (cddr option))))
+            (find-to-string
+             (find-generic option oper argcnt (cdr form) noquotes))))
+         (t
+          (error "Sorry I don't know how to handle '%s'" (car form))))))))
+
+(provide 'find)