[ SEA-GHOST MINI SHELL]

"""Utilities for CVS administration."""

import string
import os
import time
import md5
import fnmatch

if not hasattr(time, 'timezone'):
    time.timezone = 0

class File:

    """Represent a file's status.

    Instance variables:

    file -- the filename (no slashes), None if uninitialized
    lseen -- true if the data for the local file is up to date
    eseen -- true if the data from the CVS/Entries entry is up to date
             (this implies that the entry must be written back)
    rseen -- true if the data for the remote file is up to date
    proxy -- RCSProxy instance used to contact the server, or None

    Note that lseen and rseen don't necessary mean that a local
    or remote file *exists* -- they indicate that we've checked it.
    However, eseen means that this instance corresponds to an
    entry in the CVS/Entries file.

    If lseen is true:

    lsum -- checksum of the local file, None if no local file
    lctime -- ctime of the local file, None if no local file
    lmtime -- mtime of the local file, None if no local file

    If eseen is true:

    erev -- revision, None if this is a no revision (not '0')
    enew -- true if this is an uncommitted added file
    edeleted -- true if this is an uncommitted removed file
    ectime -- ctime of last local file corresponding to erev
    emtime -- mtime of last local file corresponding to erev
    extra -- 5th string from CVS/Entries file

    If rseen is true:

    rrev -- revision of head, None if non-existent
    rsum -- checksum of that revision, Non if non-existent

    If eseen and rseen are both true:

    esum -- checksum of revision erev, None if no revision

    Note
    """

    def __init__(self, file = None):
        if file and '/' in file:
            raise ValueError, "no slash allowed in file"
        self.file = file
        self.lseen = self.eseen = self.rseen = 0
        self.proxy = None

    def __cmp__(self, other):
        return cmp(self.file, other.file)

    def getlocal(self):
        try:
            self.lmtime, self.lctime = os.stat(self.file)[-2:]
        except os.error:
            self.lmtime = self.lctime = self.lsum = None
        else:
            self.lsum = md5.new(open(self.file).read()).digest()
        self.lseen = 1

    def getentry(self, line):
        words = string.splitfields(line, '/')
        if self.file and words[1] != self.file:
            raise ValueError, "file name mismatch"
        self.file = words[1]
        self.erev = words[2]
        self.edeleted = 0
        self.enew = 0
        self.ectime = self.emtime = None
        if self.erev[:1] == '-':
            self.edeleted = 1
            self.erev = self.erev[1:]
        if self.erev == '0':
            self.erev = None
            self.enew = 1
        else:
            dates = words[3]
            self.ectime = unctime(dates[:24])
            self.emtime = unctime(dates[25:])
        self.extra = words[4]
        if self.rseen:
            self.getesum()
        self.eseen = 1

    def getremote(self, proxy = None):
        if proxy:
            self.proxy = proxy
        try:
            self.rrev = self.proxy.head(self.file)
        except (os.error, IOError):
            self.rrev = None
        if self.rrev:
            self.rsum = self.proxy.sum(self.file)
        else:
            self.rsum = None
        if self.eseen:
            self.getesum()
        self.rseen = 1

    def getesum(self):
        if self.erev == self.rrev:
            self.esum = self.rsum
        elif self.erev:
            name = (self.file, self.erev)
            self.esum = self.proxy.sum(name)
        else:
            self.esum = None

    def putentry(self):
        """Return a line suitable for inclusion in CVS/Entries.

        The returned line is terminated by a newline.
        If no entry should be written for this file,
        return "".
        """
        if not self.eseen:
            return ""

        rev = self.erev or '0'
        if self.edeleted:
            rev = '-' + rev
        if self.enew:
            dates = 'Initial ' + self.file
        else:
            dates = gmctime(self.ectime) + ' ' + \
                    gmctime(self.emtime)
        return "/%s/%s/%s/%s/\n" % (
                self.file,
                rev,
                dates,
                self.extra)

    def report(self):
        print '-'*50
        def r(key, repr=repr, self=self):
            try:
                value = repr(getattr(self, key))
            except AttributeError:
                value = "?"
            print "%-15s:" % key, value
        r("file")
        if self.lseen:
            r("lsum", hexify)
            r("lctime", gmctime)
            r("lmtime", gmctime)
        if self.eseen:
            r("erev")
            r("enew")
            r("edeleted")
            r("ectime", gmctime)
            r("emtime", gmctime)
        if self.rseen:
            r("rrev")
            r("rsum", hexify)
            if self.eseen:
                r("esum", hexify)


class CVS:

    """Represent the contents of a CVS admin file (and more).

    Class variables:

    FileClass -- the class to be instantiated for entries
                 (this should be derived from class File above)
    IgnoreList -- shell patterns for local files to be ignored

    Instance variables:

    entries -- a dictionary containing File instances keyed by
               their file name
    proxy -- an RCSProxy instance, or None
    """

    FileClass = File

    IgnoreList = ['.*', '@*', ',*', '*~', '*.o', '*.a', '*.so', '*.pyc']

    def __init__(self):
        self.entries = {}
        self.proxy = None

    def setproxy(self, proxy):
        if proxy is self.proxy:
            return
        self.proxy = proxy
        for e in self.entries.values():
            e.rseen = 0

    def getentries(self):
        """Read the contents of CVS/Entries"""
        self.entries = {}
        f = self.cvsopen("Entries")
        while 1:
            line = f.readline()
            if not line: break
            e = self.FileClass()
            e.getentry(line)
            self.entries[e.file] = e
        f.close()

    def putentries(self):
        """Write CVS/Entries back"""
        f = self.cvsopen("Entries", 'w')
        for e in self.values():
            f.write(e.putentry())
        f.close()

    def getlocalfiles(self):
        list = self.entries.keys()
        addlist = os.listdir(os.curdir)
        for name in addlist:
            if name in list:
                continue
            if not self.ignored(name):
                list.append(name)
        list.sort()
        for file in list:
            try:
                e = self.entries[file]
            except KeyError:
                e = self.entries[file] = self.FileClass(file)
            e.getlocal()

    def getremotefiles(self, proxy = None):
        if proxy:
            self.proxy = proxy
        if not self.proxy:
            raise RuntimeError, "no RCS proxy"
        addlist = self.proxy.listfiles()
        for file in addlist:
            try:
                e = self.entries[file]
            except KeyError:
                e = self.entries[file] = self.FileClass(file)
            e.getremote(self.proxy)

    def report(self):
        for e in self.values():
            e.report()
        print '-'*50

    def keys(self):
        keys = self.entries.keys()
        keys.sort()
        return keys

    def values(self):
        def value(key, self=self):
            return self.entries[key]
        return map(value, self.keys())

    def items(self):
        def item(key, self=self):
            return (key, self.entries[key])
        return map(item, self.keys())

    def cvsexists(self, file):
        file = os.path.join("CVS", file)
        return os.path.exists(file)

    def cvsopen(self, file, mode = 'r'):
        file = os.path.join("CVS", file)
        if 'r' not in mode:
            self.backup(file)
        return open(file, mode)

    def backup(self, file):
        if os.path.isfile(file):
            bfile = file + '~'
            try: os.unlink(bfile)
            except os.error: pass
            os.rename(file, bfile)

    def ignored(self, file):
        if os.path.isdir(file): return True
        for pat in self.IgnoreList:
            if fnmatch.fnmatch(file, pat): return True
        return False


# hexify and unhexify are useful to print MD5 checksums in hex format

hexify_format = '%02x' * 16
def hexify(sum):
    "Return a hex representation of a 16-byte string (e.g. an MD5 digest)"
    if sum is None:
        return "None"
    return hexify_format % tuple(map(ord, sum))

def unhexify(hexsum):
    "Return the original from a hexified string"
    if hexsum == "None":
        return None
    sum = ''
    for i in range(0, len(hexsum), 2):
        sum = sum + chr(string.atoi(hexsum[i:i+2], 16))
    return sum


unctime_monthmap = {}
def unctime(date):
    if date == "None": return None
    if not unctime_monthmap:
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        i = 0
        for m in months:
            i = i+1
            unctime_monthmap[m] = i
    words = string.split(date) # Day Mon DD HH:MM:SS YEAR
    year = string.atoi(words[4])
    month = unctime_monthmap[words[1]]
    day = string.atoi(words[2])
    [hh, mm, ss] = map(string.atoi, string.splitfields(words[3], ':'))
    ss = ss - time.timezone
    return time.mktime((year, month, day, hh, mm, ss, 0, 0, 0))

def gmctime(t):
    if t is None: return "None"
    return time.asctime(time.gmtime(t))

def test_unctime():
    now = int(time.time())
    t = time.gmtime(now)
    at = time.asctime(t)
    print 'GMT', now, at
    print 'timezone', time.timezone
    print 'local', time.ctime(now)
    u = unctime(at)
    print 'unctime()', u
    gu = time.gmtime(u)
    print '->', gu
    print time.asctime(gu)

def test():
    x = CVS()
    x.getentries()
    x.getlocalfiles()
##      x.report()
    import rcsclient
    proxy = rcsclient.openrcsclient()
    x.getremotefiles(proxy)
    x.report()


if __name__ == "__main__":
    test()