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

regexbytesescapemap = {i: (b'\\' + i) 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, indent=0, level=0):

    """Pretty print an object."""

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

def pprintgen(o, bprefix=False, indent=0, level=0):

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

    ``bprefix`` is a flag influencing whether bytestrings are preferred with

    a ``b''`` prefix.

    ``indent`` controls whether collections and nested data structures

    span multiple lines via the indentation amount in spaces. By default,

    no newlines are emitted.

    ``level`` specifies the initial indent level. Used if ``indent > 0``.

    """

    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):

        if not o:

            yield '[]'

            return

        yield '['

        if indent:

            level += 1

            yield '\n'

            yield ' ' * (level * indent)

        for i, a in enumerate(o):

            for chunk in pprintgen(a, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            if i + 1 < len(o):

                if indent:

                    yield ',\n'

                    yield ' ' * (level * indent)

                else:

                    yield ', '

        if indent:

            level -= 1

            yield '\n'

            yield ' ' * (level * indent)

        yield ']'

    elif isinstance(o, dict):

        if not o:

            yield '{}'

            return

        yield '{'

        if indent:

            level += 1

            yield '\n'

            yield ' ' * (level * indent)

        for i, (k, v) in enumerate(sorted(o.items())):

            for chunk in pprintgen(k, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            yield ': '

            for chunk in pprintgen(v, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            if i + 1 < len(o):

                if indent:

                    yield ',\n'

                    yield ' ' * (level * indent)

                else:

                    yield ', '

        if indent:

            level -= 1

            yield '\n'

            yield ' ' * (level * indent)

        yield '}'

    elif isinstance(o, set):

        if not o:

            yield 'set([])'

            return

        yield 'set(['

        if indent:

            level += 1

            yield '\n'

            yield ' ' * (level * indent)

        for i, k in enumerate(sorted(o)):

            for chunk in pprintgen(k, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            if i + 1 < len(o):

                if indent:

                    yield ',\n'

                    yield ' ' * (level * indent)

                else:

                    yield ', '

        if indent:

            level -= 1

            yield '\n'

            yield ' ' * (level * indent)

        yield '])'

    elif isinstance(o, tuple):

        if not o:

            yield '()'

            return

        yield '('

        if indent:

            level += 1

            yield '\n'

            yield ' ' * (level * indent)

        for i, a in enumerate(o):

            for chunk in pprintgen(a, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            if i + 1 < len(o):

                if indent:

                    yield ',\n'

                    yield ' ' * (level * indent)

                else:

                    yield ', '

        if indent:

            level -= 1

            yield '\n'

            yield ' ' * (level * indent)

        yield ')'

    elif isinstance(o, types.GeneratorType):

        # Special case of empty generator.

        try:

            nextitem = next(o)

        except StopIteration:

            yield 'gen[]'

            return

        yield 'gen['

        if indent:

            level += 1

            yield '\n'

            yield ' ' * (level * indent)

        last = False

        while not last:

            current = nextitem

            try:

                nextitem = next(o)

            except StopIteration:

                last = True

            for chunk in pprintgen(current, bprefix=bprefix, indent=indent,

                                   level=level):

                yield chunk

            if not last:

                if indent:

                    yield ',\n'

                    yield ' ' * (level * indent)

                else:

                    yield ', '

        if indent:

            level -= 1

            yield '\n'

            yield ' ' * (level * indent)

        yield ']'

    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