#

# Mercurial built-in replacement for cvsps.

#

# Copyright 2008, Frank Kingswood <frank@kingswood-consulting.co.uk>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2, incorporated herein by reference.

import os

import re

import cPickle as pickle

from mercurial import util

from mercurial.i18n import _

def listsort(list, key):

    "helper to sort by key in Python 2.3"

    try:

        list.sort(key=key)

    except TypeError:

        list.sort(lambda l, r: cmp(key(l), key(r)))

class logentry(object):

    '''Class logentry has the following attributes:

        .author    - author name as CVS knows it

        .branch    - name of branch this revision is on

        .branches  - revision tuple of branches starting at this revision

        .comment   - commit message

        .date      - the commit date as a (time, tz) tuple

        .dead      - true if file revision is dead

        .file      - Name of file

        .lines     - a tuple (+lines, -lines) or None

        .parent    - Previous revision of this entry

        .rcs       - name of file as returned from CVS

        .revision  - revision number as tuple

        .tags      - list of tags on the file

        .synthetic - is this a synthetic "file ... added on ..." revision?

        .mergepoint- the branch that has been merged from

                     (if present in rlog output)

        .branchpoints- the branches that start at the current entry

    '''

    def __init__(self, **entries):

        self.__dict__.update(entries)

    def __repr__(self):

        return "<%s at 0x%x: %s %s>" % (self.__class__.__name__,

                                        id(self),

                                        self.file,

                                        ".".join(map(str, self.revision)))

class logerror(Exception):

    pass

def getrepopath(cvspath):

    """Return the repository path from a CVS path.

    >>> getrepopath('/foo/bar')

    '/foo/bar'

    >>> getrepopath('c:/foo/bar')

    'c:/foo/bar'

    >>> getrepopath(':pserver:10/foo/bar')

    '/foo/bar'

    >>> getrepopath(':pserver:10c:/foo/bar')

    '/foo/bar'

    >>> getrepopath(':pserver:/foo/bar')

    '/foo/bar'

    >>> getrepopath(':pserver:c:/foo/bar')

    'c:/foo/bar'

    >>> getrepopath(':pserver:truc@foo.bar:/foo/bar')

    '/foo/bar'

    >>> getrepopath(':pserver:truc@foo.bar:c:/foo/bar')

    'c:/foo/bar'

    """

    # According to CVS manual, CVS paths are expressed like:

    # [:method:][[user][:password]@]hostname[:[port]]/path/to/repository

    #

    # Unfortunately, Windows absolute paths start with a drive letter

    # like 'c:' making it harder to parse. Here we assume that drive

    # letters are only one character long and any CVS component before

    # the repository path is at least 2 characters long, and use this

    # to disambiguate.

    parts = cvspath.split(':')

    if len(parts) == 1:

        return parts[0]

    # Here there is an ambiguous case if we have a port number

    # immediately followed by a Windows driver letter. We assume this

    # never happens and decide it must be CVS path component,

    # therefore ignoring it.

    if len(parts[-2]) > 1:

        return parts[-1].lstrip('0123456789')

    return parts[-2] + ':' + parts[-1]

def createlog(ui, directory=None, root="", rlog=True, cache=None):

    '''Collect the CVS rlog'''

    # Because we store many duplicate commit log messages, reusing strings

    # saves a lot of memory and pickle storage space.

    _scache = {}

    def scache(s):

        "return a shared version of a string"

        return _scache.setdefault(s, s)

    ui.status(_('collecting CVS rlog\n'))

    log = []      # list of logentry objects containing the CVS state

    # patterns to match in CVS (r)log output, by state of use

    re_00 = re.compile('RCS file: (.+)$')

    re_01 = re.compile('cvs \\[r?log aborted\\]: (.+)$')

    re_02 = re.compile('cvs (r?log|server): (.+)\n$')

    re_03 = re.compile("(Cannot access.+CVSROOT)|"

                       "(can't create temporary directory.+)$")

    re_10 = re.compile('Working file: (.+)$')

    re_20 = re.compile('symbolic names:')

    re_30 = re.compile('\t(.+): ([\\d.]+)$')

    re_31 = re.compile('----------------------------$')

    re_32 = re.compile('======================================='

                       '======================================$')

    re_50 = re.compile('revision ([\\d.]+)(\s+locked by:\s+.+;)?$')

    re_60 = re.compile(r'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);'

                       r'(\s+lines:\s+(\+\d+)?\s+(-\d+)?;)?'

                       r'(.*mergepoint:\s+([^;]+);)?')

    re_70 = re.compile('branches: (.+);$')

    file_added_re = re.compile(r'file [^/]+ was (initially )?added on branch')

    prefix = ''   # leading path to strip of what we get from CVS

    if directory is None:

        # Current working directory

        # Get the real directory in the repository

        try:

            prefix = file(os.path.join('CVS','Repository')).read().strip()

            if prefix == ".":

                prefix = ""

            directory = prefix

        except IOError:

            raise logerror('Not a CVS sandbox')

        if prefix and not prefix.endswith(os.sep):

            prefix += os.sep

        # Use the Root file in the sandbox, if it exists

        try:

            root = file(os.path.join('CVS','Root')).read().strip()

        except IOError:

            pass

    if not root:

        root = os.environ.get('CVSROOT', '')

    # read log cache if one exists

    oldlog = []

    date = None

    if cache:

        cachedir = os.path.expanduser('~/.hg.cvsps')

        if not os.path.exists(cachedir):

            os.mkdir(cachedir)

        # The cvsps cache pickle needs a uniquified name, based on the

        # repository location. The address may have all sort of nasties

        # in it, slashes, colons and such. So here we take just the

        # alphanumerics, concatenated in a way that does not mix up the

        # various components, so that

        #    :pserver:user@server:/path

        # and

        #    /pserver/user/server/path

        # are mapped to different cache file names.

        cachefile = root.split(":") + [directory, "cache"]

        cachefile = ['-'.join(re.findall(r'\w+', s)) for s in cachefile if s]

        cachefile = os.path.join(cachedir,

                                 '.'.join([s for s in cachefile if s]))

    if cache == 'update':

        try:

            ui.note(_('reading cvs log cache %s\n') % cachefile)

            oldlog = pickle.load(file(cachefile))

            ui.note(_('cache has %d log entries\n') % len(oldlog))

        except Exception, e:

            ui.note(_('error reading cache: %r\n') % e)

        if oldlog:

            date = oldlog[-1].date    # last commit date as a (time,tz) tuple

            date = util.datestr(date, '%Y/%m/%d %H:%M:%S %1%2')

    # build the CVS commandline

    cmd = ['cvs', '-q']

    if root:

        cmd.append('-d%s' % root)

        p = util.normpath(getrepopath(root))

        if not p.endswith('/'):

            p += '/'

        prefix = p + util.normpath(prefix)

    cmd.append(['log', 'rlog'][rlog])

    if date:

        # no space between option and date string

        cmd.append('-d>%s' % date)

    cmd.append(directory)

    # state machine begins here

    tags = {}     # dictionary of revisions on current file with their tags

    branchmap = {} # mapping between branch names and revision numbers

    state = 0

    store = False # set when a new record can be appended

    cmd = [util.shellquote(arg) for arg in cmd]

    ui.note(_("running %s\n") % (' '.join(cmd)))

    ui.debug(_("prefix=%r directory=%r root=%r\n") % (prefix, directory, root))

    pfp = util.popen(' '.join(cmd))

    peek = pfp.readline()

    while True:

        line = peek

        if line == '':

            break

        peek = pfp.readline()

        if line.endswith('\n'):

            line = line[:-1]

        #ui.debug('state=%d line=%r\n' % (state, line))

        if state == 0:

            # initial state, consume input until we see 'RCS file'

            match = re_00.match(line)

            if match:

                rcs = match.group(1)

                tags = {}

                if rlog:

                    filename = util.normpath(rcs[:-2])

                    if filename.startswith(prefix):

                        filename = filename[len(prefix):]

                    if filename.startswith('/'):

                        filename = filename[1:]

                    if filename.startswith('Attic/'):

                        filename = filename[6:]

                    else:

                        filename = filename.replace('/Attic/', '/')

                    state = 2

                    continue

                state = 1

                continue

            match = re_01.match(line)

            if match:

                raise Exception(match.group(1))

            match = re_02.match(line)

            if match:

                raise Exception(match.group(2))

            if re_03.match(line):

                raise Exception(line)

        elif state == 1:

            # expect 'Working file' (only when using log instead of rlog)

            match = re_10.match(line)

            assert match, _('RCS file must be followed by working file')

            filename = util.normpath(match.group(1))

            state = 2

        elif state == 2:

            # expect 'symbolic names'

            if re_20.match(line):

                branchmap = {}

                state = 3

        elif state == 3:

            # read the symbolic names and store as tags

            match = re_30.match(line)

            if match:

                rev = [int(x) for x in match.group(2).split('.')]

                # Convert magic branch number to an odd-numbered one

                revn = len(rev)

                if revn > 3 and (revn % 2) == 0 and rev[-2] == 0:

                    rev = rev[:-2] + rev[-1:]

                rev = tuple(rev)

                if rev not in tags:

                    tags[rev] = []

                tags[rev].append(match.group(1))

                branchmap[match.group(1)] = match.group(2)

            elif re_31.match(line):

                state = 5

            elif re_32.match(line):

                state = 0

        elif state == 4:

            # expecting '------' separator before first revision

            if re_31.match(line):

                state = 5

            else:

                assert not re_32.match(line), _('must have at least '

                                                'some revisions')

        elif state == 5:

            # expecting revision number and possibly (ignored) lock indication

            # we create the logentry here from values stored in states 0 to 4,

            # as this state is re-entered for subsequent revisions of a file.

            match = re_50.match(line)

            assert match, _('expected revision number')

            e = logentry(rcs=scache(rcs), file=scache(filename),

                    revision=tuple([int(x) for x in match.group(1).split('.')]),

                    branches=[], parent=None,

                    synthetic=False)

            state = 6

        elif state == 6:

            # expecting date, author, state, lines changed

            match = re_60.match(line)

            assert match, _('revision must be followed by date line')

            d = match.group(1)

            if d[2] == '/':

                # Y2K

                d = '19' + d

            if len(d.split()) != 3:

                # cvs log dates always in GMT

                d = d + ' UTC'

            e.date = util.parsedate(d, ['%y/%m/%d %H:%M:%S',

                                        '%Y/%m/%d %H:%M:%S',

                                        '%Y-%m-%d %H:%M:%S'])

            e.author = scache(match.group(2))

            e.dead = match.group(3).lower() == 'dead'

            if match.group(5):

                if match.group(6):

                    e.lines = (int(match.group(5)), int(match.group(6)))

                else:

                    e.lines = (int(match.group(5)), 0)

            elif match.group(6):

                e.lines = (0, int(match.group(6)))

            else:

                e.lines = None

            if match.group(7): # cvsnt mergepoint

                myrev = match.group(8).split('.')

                if len(myrev) == 2: # head

                    e.mergepoint = 'HEAD'

                else:

                    myrev = '.'.join(myrev[:-2] + ['0', myrev[-2]])

                    branches = [b for b in branchmap if branchmap[b] == myrev]

                    assert len(branches) == 1, 'unknown branch: %s' % e.mergepoint

                    e.mergepoint = branches[0]

            else:

                e.mergepoint = None

            e.comment = []

            state = 7

        elif state == 7:

            # read the revision numbers of branches that start at this revision

            # or store the commit log message otherwise

            m = re_70.match(line)

            if m:

                e.branches = [tuple([int(y) for y in x.strip().split('.')])

                                for x in m.group(1).split(';')]

                state = 8

            elif re_31.match(line) and re_50.match(peek):

                state = 5

                store = True

            elif re_32.match(line):

                state = 0

                store = True

            else:

                e.comment.append(line)

        elif state == 8:

            # store commit log message

            if re_31.match(line):

                state = 5

                store = True

            elif re_32.match(line):

                state = 0

                store = True

            else:

                e.comment.append(line)

        # When a file is added on a branch B1, CVS creates a synthetic

        # dead trunk revision 1.1 so that the branch has a root.

        # Likewise, if you merge such a file to a later branch B2 (one

        # that already existed when the file was added on B1), CVS

        # creates a synthetic dead revision 1.1.x.1 on B2.  Don't drop

        # these revisions now, but mark them synthetic so

        # createchangeset() can take care of them.

        if (store and

              e.dead and

              e.revision[-1] == 1 and      # 1.1 or 1.1.x.1

              len(e.comment) == 1 and

              file_added_re.match(e.comment[0])):

            ui.debug(_('found synthetic revision in %s: %r\n')

                     % (e.rcs, e.comment[0]))