"""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()