# 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 or any later version.

from __future__ import absolute_import

import os

import re

from mercurial.i18n import _

from mercurial import (

    encoding,

    hook,

    pycompat,

    util,

)

pickle = util.pickle

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

        .commitid  - CVS commitid or None

        .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) or None

        .branchpoints - the branches that start at the current entry or empty

    '''

    def __init__(self, **entries):

        self.synthetic = False

        self.__dict__.update(entries)

    def __repr__(self):

        items = ("%s=%r"%(k, self.__dict__[k]) for k in sorted(self.__dict__))

        return "%s(%s)"%(type(self).__name__, ", ".join(items))

class logerror(Exception):

    pass

def getrepopath(cvspath):

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

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

    '/foo/bar'

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

    '/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')

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

    >>> getrepopath('user@server/path/to/repository')

    '/path/to/repository'

    """

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

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

    #

    # CVSpath is splitted into parts and then position of the first occurrence

    # of the '/' char after the '@' is located. The solution is the rest of the

    # string after that '/' sign including it

    parts = cvspath.split(':')

    atposition = parts[-1].find('@')

    start = 0

    if atposition != -1:

        start = atposition

    repopath = parts[-1][parts[-1].find('/', start):]

    return repopath

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'(\s+commitid:\s+([^;]+);)?'

                       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 = open(os.path.join('CVS','Repository')).read().strip()

            directory = prefix

            if prefix == ".":

                prefix = ""

        except IOError:

            raise logerror(_('not a CVS sandbox'))

        if prefix and not prefix.endswith(pycompat.ossep):

            prefix += pycompat.ossep

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

        try:

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

        except IOError:

            pass

    if not root:

        root = encoding.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

        # alphanumeric characters, 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(open(cachefile))

            for e in oldlog:

                if not (util.safehasattr(e, 'branchpoints') and

                        util.safehasattr(e, 'commitid') and

                        util.safehasattr(e, 'mergepoint')):

                    ui.status(_('ignoring old cache\n'))

                    oldlog = []

                    break

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

        except Exception as 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 += '/'

        if prefix:

            # looks like normpath replaces "" by "."

            prefix = p + util.normpath(prefix)

        else:

            prefix = p

    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

    rcsmap = {}

    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 logerror(match.group(1))

            match = re_02.match(line)

            if match:

                raise logerror(match.group(2))

            if re_03.match(line):

                raise logerror(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,

                         commitid=None,

                         mergepoint=None,

                         branchpoints=set())

            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): # cvs 1.12 commitid

                e.commitid = match.group(8)

            if match.group(9): # cvsnt mergepoint

                myrev = match.group(10).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]

            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: