# stringutil.py - utility for generic string formatting, parsing, etc.

#

#  Copyright 2005 K. Thananchayan <thananck@yahoo.com>

#  Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#  Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

#

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

import codecs

import re as remod

import textwrap

import types

from ..i18n import _

from ..thirdparty import attr

from .. import (

    encoding,

    error,

    pycompat,

)

# regex special chars pulled from https://bugs.python.org/issue29995

# which was part of Python 3.7.

_respecial = pycompat.bytestr(b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f')

_regexescapemap = {ord(i): (b'\\' + i).decode('latin1') for i in _respecial}

def reescape(pat):

    """Drop-in replacement for re.escape."""

    # NOTE: it is intentional that this works on unicodes and not

    # bytes, as it's only possible to do the escaping with

    # unicode.translate, not bytes.translate. Sigh.

    wantuni = True

    if isinstance(pat, bytes):

        wantuni = False

        pat = pat.decode('latin1')

    pat = pat.translate(_regexescapemap)

    if wantuni:

        return pat

    return pat.encode('latin1')

def pprint(o, bprefix=False):

    """Pretty print an object."""

    return b''.join(pprintgen(o, bprefix=bprefix))

def pprintgen(o, bprefix=False):

    """Pretty print an object to a generator of atoms."""

    if isinstance(o, bytes):

        if bprefix:

            yield "b'%s'" % escapestr(o)

        else:

            yield "'%s'" % escapestr(o)

    elif isinstance(o, bytearray):

        # codecs.escape_encode() can't handle bytearray, so escapestr fails

        # without coercion.

        yield "bytearray['%s']" % escapestr(bytes(o))

    elif isinstance(o, list):

    elif isinstance(o, dict):

    elif isinstance(o, set):

    elif isinstance(o, tuple):

    elif isinstance(o, types.GeneratorType):

    else:

        yield pycompat.byterepr(o)

def prettyrepr(o):

    """Pretty print a representation of a possibly-nested object"""

    lines = []

    rs = pycompat.byterepr(o)

    p0 = p1 = 0

    while p0 < len(rs):

        # '... field=<type ... field=<type ...'

        #      ~~~~~~~~~~~~~~~~

        #      p0    p1        q0    q1

        q0 = -1

        q1 = rs.find('<', p1 + 1)

        if q1 < 0:

            q1 = len(rs)

        elif q1 > p1 + 1 and rs.startswith('=', q1 - 1):

            # backtrack for ' field=<'

            q0 = rs.rfind(' ', p1 + 1, q1 - 1)

        if q0 < 0:

            q0 = q1

        else:

            q0 += 1  # skip ' '

        l = rs.count('<', 0, p0) - rs.count('>', 0, p0)

        assert l >= 0

        lines.append((l, rs[p0:q0].rstrip()))

        p0, p1 = q0, q1

    return '\n'.join('  ' * l + s for l, s in lines)

def buildrepr(r):

    """Format an optional printable representation from unexpanded bits

    ========  =================================

    type(r)   example

    ========  =================================

    tuple     ('<not %r>', other)

    bytes     '<branch closed>'

    callable  lambda: '<branch %r>' % sorted(b)

    object    other

    ========  =================================

    """

    if r is None:

        return ''

    elif isinstance(r, tuple):

        return r[0] % pycompat.rapply(pycompat.maybebytestr, r[1:])

    elif isinstance(r, bytes):

        return r

    elif callable(r):

        return r()

    else:

        return pprint(r)

def binary(s):

    """return true if a string is binary data"""

    return bool(s and '\0' in s)

def stringmatcher(pattern, casesensitive=True):

    """

    accepts a string, possibly starting with 're:' or 'literal:' prefix.

    returns the matcher name, pattern, and matcher function.

    missing or unknown prefixes are treated as literal matches.

    helper for tests:

    >>> def test(pattern, *tests):

    ...     kind, pattern, matcher = stringmatcher(pattern)

    ...     return (kind, pattern, [bool(matcher(t)) for t in tests])

    >>> def itest(pattern, *tests):

    ...     kind, pattern, matcher = stringmatcher(pattern, casesensitive=False)

    ...     return (kind, pattern, [bool(matcher(t)) for t in tests])

    exact matching (no prefix):

    >>> test(b'abcdefg', b'abc', b'def', b'abcdefg')

    ('literal', 'abcdefg', [False, False, True])

    regex matching ('re:' prefix)

    >>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')

    ('re', 'a.+b', [False, False, True])

    force exact matches ('literal:' prefix)

    >>> test(b'literal:re:foobar', b'foobar', b're:foobar')

    ('literal', 're:foobar', [False, True])

    unknown prefixes are ignored and treated as literals

    >>> test(b'foo:bar', b'foo', b'bar', b'foo:bar')

    ('literal', 'foo:bar', [False, False, True])

    case insensitive regex matches

    >>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')

    ('re', 'A.+b', [False, False, True])

    case insensitive literal matches

    >>> itest(b'ABCDEFG', b'abc', b'def', b'abcdefg')

    ('literal', 'ABCDEFG', [False, False, True])

    """

    if pattern.startswith('re:'):

        pattern = pattern[3:]

        try:

            flags = 0

            if not casesensitive:

                flags = remod.I

            regex = remod.compile(pattern, flags)

        except remod.error as e:

            raise error.ParseError(_('invalid regular expression: %s')

                                   % e)

        return 're', pattern, regex.search

    elif pattern.startswith('literal:'):

        pattern = pattern[8:]

    match = pattern.__eq__

    if not casesensitive:

        ipat = encoding.lower(pattern)

        match = lambda s: ipat == encoding.lower(s)

    return 'literal', pattern, match

def shortuser(user):

    """Return a short representation of a user name or email address."""

    f = user.find('@')

    if f >= 0:

        user = user[:f]

    f = user.find('<')

    if f >= 0:

        user = user[f + 1:]

    f = user.find(' ')

    if f >= 0:

        user = user[:f]

    f = user.find('.')

    if f >= 0:

        user = user[:f]

    return user

def emailuser(user):

    """Return the user portion of an email address."""

    f = user.find('@')

    if f >= 0:

        user = user[:f]

    f = user.find('<')

    if f >= 0:

        user = user[f + 1:]

    return user

def email(author):

    '''get email of author.'''

    r = author.find('>')

    if r == -1:

        r = None

    return author[author.find('<') + 1:r]

def person(author):

    """Returns the name before an email address,

    interpreting it as per RFC 5322

    >>> person(b'foo@bar')

    'foo'

    >>> person(b'Foo Bar <foo@bar>')

    'Foo Bar'

    >>> person(b'"Foo Bar" <foo@bar>')

    'Foo Bar'

    >>> person(b'"Foo \"buz\" Bar" <foo@bar>')

    'Foo "buz" Bar'

    >>> # The following are invalid, but do exist in real-life

    ...

    >>> person(b'Foo "buz" Bar <foo@bar>')

    'Foo "buz" Bar'

    >>> person(b'"Foo Bar <foo@bar>')

    'Foo Bar'

    """

    if '@' not in author:

        return author

    f = author.find('<')

    if f != -1:

        return author[:f].strip(' "').replace('\\"', '"')

    f = author.find('@')

    return author[:f].replace('.', ' ')

@attr.s(hash=True)

class mailmapping(object):

    '''Represents a username/email key or value in

    a mailmap file'''

    email = attr.ib()

    name = attr.ib(default=None)

def _ismailmaplineinvalid(names, emails):

    '''Returns True if the parsed names and emails

    in a mailmap entry are invalid.

    >>> # No names or emails fails

    >>> names, emails = [], []

    >>> _ismailmaplineinvalid(names, emails)

    True

    >>> # Only one email fails

    >>> emails = [b'email@email.com']

    >>> _ismailmaplineinvalid(names, emails)

    True

    >>> # One email and one name passes

    >>> names = [b'Test Name']

    >>> _ismailmaplineinvalid(names, emails)

    False

    >>> # No names but two emails passes

    >>> names = []

    >>> emails = [b'proper@email.com', b'commit@email.com']

    >>> _ismailmaplineinvalid(names, emails)

    False

    '''

    return not emails or not names and len(emails) < 2

def parsemailmap(mailmapcontent):

    """Parses data in the .mailmap format

    >>> mmdata = b"\\n".join([

    ... b'# Comment',

    ... b'Name <commit1@email.xx>',

    ... b'<name@email.xx> <commit2@email.xx>',

    ... b'Name <proper@email.xx> <commit3@email.xx>',

    ... b'Name <proper@email.xx> Commit <commit4@email.xx>',

    ... ])

    >>> mm = parsemailmap(mmdata)

    >>> for key in sorted(mm.keys()):

    ...     print(key)

    mailmapping(email='commit1@email.xx', name=None)

    mailmapping(email='commit2@email.xx', name=None)

    mailmapping(email='commit3@email.xx', name=None)

    mailmapping(email='commit4@email.xx', name='Commit')

    >>> for val in sorted(mm.values()):

    ...     print(val)

    mailmapping(email='commit1@email.xx', name='Name')

    mailmapping(email='name@email.xx', name=None)

    mailmapping(email='proper@email.xx', name='Name')

    mailmapping(email='proper@email.xx', name='Name')

    """

    mailmap = {}

    if mailmapcontent is None:

        return mailmap

    for line in mailmapcontent.splitlines():

        # Don't bother checking the line if it is a comment or

        # is an improperly formed author field

        if line.lstrip().startswith('#'):

            continue

        # names, emails hold the parsed emails and names for each line

        # name_builder holds the words in a persons name

        names, emails = [], []

        namebuilder = []

        for element in line.split():

            if element.startswith('#'):

                # If we reach a comment in the mailmap file, move on

                break

            elif element.startswith('<') and element.endswith('>'):

                # We have found an email.

                # Parse it, and finalize any names from earlier

                emails.append(element[1:-1])  # Slice off the "<>"

                if namebuilder:

                    names.append(' '.join(namebuilder))

                    namebuilder = []

                # Break if we have found a second email, any other

                # data does not fit the spec for .mailmap

                if len(emails) > 1:

                    break

            else:

                # We have found another word in the committers name

                namebuilder.append(element)

        # Check to see if we have parsed the line into a valid form

        # We require at least one email, and either at least one

        # name or a second email

        if _ismailmaplineinvalid(names, emails):

            continue

        mailmapkey = mailmapping(

            email=emails[-1],

            name=names[-1] if len(names) == 2 else None,

        )

        mailmap[mailmapkey] = mailmapping(

            email=emails[0],

            name=names[0] if names else None,

        )

    return mailmap

def mapname(mailmap, author):

    """Returns the author field according to the mailmap cache, or

    the original author field.

    >>> mmdata = b"\\n".join([

    ...     b'# Comment',

    ...     b'Name <commit1@email.xx>',

    ...     b'<name@email.xx> <commit2@email.xx>',

    ...     b'Name <proper@email.xx> <commit3@email.xx>',

    ...     b'Name <proper@email.xx> Commit <commit4@email.xx>',

    ... ])

    >>> m = parsemailmap(mmdata)

    >>> mapname(m, b'Commit <commit1@email.xx>')

    'Name <commit1@email.xx>'

    >>> mapname(m, b'Name <commit2@email.xx>')

    'Name <name@email.xx>'

    >>> mapname(m, b'Commit <commit3@email.xx>')

    'Name <proper@email.xx>'

    >>> mapname(m, b'Commit <commit4@email.xx>')

    'Name <proper@email.xx>'

    >>> mapname(m, b'Unknown Name <unknown@email.com>')

    'Unknown Name <unknown@email.com>'

    """

    # If the author field coming in isn't in the correct format,

    # or the mailmap is empty just return the original author field

    if not isauthorwellformed(author) or not mailmap:

        return author

    # Turn the user name into a mailmapping

    commit = mailmapping(name=person(author), email=email(author))

    try:

        # Try and use both the commit email and name as the key

        proper = mailmap[commit]

    except KeyError:

        # If the lookup fails, use just the email as the key instead

        # We call this commit2 as not to erase original commit fields

        commit2 = mailmapping(email=commit.email)

        proper = mailmap.get(commit2, mailmapping(None, None))

    # Return the author field with proper values filled in

    return '%s <%s>' % (

        proper.name if proper.name else commit.name,

        proper.email if proper.email else commit.email,

    )