# 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 functools

import os

import re

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial import (

    encoding,

    error,

    hook,

    pycompat,

    util,

)

from mercurial.utils import (

    dateutil,

    procutil,

    stringutil,

)

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(b'/foo/bar')

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

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

    '/foo/bar'

    >>> getrepopath(b'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(b':')

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

    start = 0

    if atposition != -1:

        start = atposition

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

    return repopath

def createlog(ui, directory=None, root=b"", 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(_(b'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(b'RCS file: (.+)$')

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

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

    re_03 = re.compile(

        b"(Cannot access.+CVSROOT)|(can't create temporary directory.+)$"

    )

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

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

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

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

    re_32 = re.compile(

        b'======================================='

        b'======================================$'

    )

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

    re_60 = re.compile(

        br'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);'

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

        br'(\s+commitid:\s+([^;]+);)?'

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

    )

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

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

    prefix = b''  # 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:

            with open(os.path.join(b'CVS', b'Repository'), b'rb') as f:

                prefix = f.read().strip()

            directory = prefix

            if prefix == b".":

                prefix = b""

        except IOError:

            raise logerror(_(b'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(b'CVS', b'Root'), b'rb').read().strip()

        except IOError:

            pass

    if not root:

        root = encoding.environ.get(b'CVSROOT', b'')

    # read log cache if one exists

    oldlog = []

    date = None

    if cache:

        cachedir = os.path.expanduser(b'~/.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(b":") + [directory, b"cache"]

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

        cachefile = os.path.join(

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

        )

    if cache == b'update':

        try:

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

            oldlog = pickle.load(open(cachefile, b'rb'))

            for e in oldlog:

                if not (

                    util.safehasattr(e, b'branchpoints')

                    and util.safehasattr(e, b'commitid')

                    and util.safehasattr(e, b'mergepoint')

                ):

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

                    oldlog = []

                    break

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

        except Exception as e:

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

        if oldlog:

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

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

    # build the CVS commandline

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

    if root:

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

        p = util.normpath(getrepopath(root))

        if not p.endswith(b'/'):

            p += b'/'

        if prefix:

            # looks like normpath replaces "" by "."

            prefix = p + util.normpath(prefix)

        else:

            prefix = p

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

    if date:

        # no space between option and date string

        cmd.append(b'-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 = [procutil.shellquote(arg) for arg in cmd]

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

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

    pfp = procutil.popen(b' '.join(cmd), b'rb')

    peek = util.fromnativeeol(pfp.readline())

    while True:

        line = peek

        if line == b'':

            break

        peek = util.fromnativeeol(pfp.readline())

        if line.endswith(b'\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(b'/'):

                        filename = filename[1:]

                    if filename.startswith(b'Attic/'):

                        filename = filename[6:]

                    else:

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

                    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, _(b'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(b'.')]

                # 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), _(

                    b'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, _(b'expected revision number')

            e = logentry(

                rcs=scache(rcs),

                file=scache(filename),

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

                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, _(b'revision must be followed by date line')

            d = match.group(1)

            if d[2] == b'/':

                # Y2K

                d = b'19' + d

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

                # cvs log dates always in GMT

                d = d + b' UTC'

            e.date = dateutil.parsedate(

                d,

                [

                    b'%y/%m/%d %H:%M:%S',

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

                    b'%Y-%m-%d %H:%M:%S',

                ],

            )

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

            e.dead = match.group(3).lower() == b'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