# patch.py - patch file parsing routines

#

# Copyright 2006 Brendan Cully <brendan@kublai.com>

# Copyright 2007 Chris Mason <chris.mason@oracle.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, print_function

import collections

import contextlib

import copy

import errno

import os

import re

import shutil

import zlib

from .i18n import _

from .node import (

    hex,

    short,

)

from .pycompat import open

from . import (

    copies,

    diffhelper,

    diffutil,

    encoding,

    error,

    mail,

    mdiff,

    pathutil,

    pycompat,

    scmutil,

    similar,

    util,

    vfs as vfsmod,

)

from .utils import (

    dateutil,

    hashutil,

    procutil,

    stringutil,

)

stringio = util.stringio

gitre = re.compile(br'diff --git a/(.*) b/(.*)')

tabsplitter = re.compile(br'(\t+|[^\t]+)')

wordsplitter = re.compile(

    br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])'

)

PatchError = error.PatchError

# public functions

def split(stream):

    '''return an iterator of individual patches from a stream'''

    def isheader(line, inheader):

        if inheader and line.startswith((b' ', b'\t')):

            # continuation

            return True

        if line.startswith((b' ', b'-', b'+')):

            # diff line - don't check for header pattern in there

            return False

        l = line.split(b': ', 1)

        return len(l) == 2 and b' ' not in l[0]

    def chunk(lines):

        return stringio(b''.join(lines))

    def hgsplit(stream, cur):

        inheader = True

        for line in stream:

            if not line.strip():

                inheader = False

            if not inheader and line.startswith(b'# HG changeset patch'):

                yield chunk(cur)

                cur = []

                inheader = True

            cur.append(line)

        if cur:

            yield chunk(cur)

    def mboxsplit(stream, cur):

        for line in stream:

            if line.startswith(b'From '):

                for c in split(chunk(cur[1:])):

                    yield c

                cur = []

            cur.append(line)

        if cur:

            for c in split(chunk(cur[1:])):

                yield c

    def mimesplit(stream, cur):

        def msgfp(m):

            fp = stringio()

            g = mail.Generator(fp, mangle_from_=False)

            g.flatten(m)

            fp.seek(0)

            return fp

        for line in stream:

            cur.append(line)

        c = chunk(cur)

        m = mail.parse(c)

        if not m.is_multipart():

            yield msgfp(m)

        else:

            ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch')

            for part in m.walk():

                ct = part.get_content_type()

                if ct not in ok_types:

                    continue

                yield msgfp(part)

    def headersplit(stream, cur):

        inheader = False

        for line in stream:

            if not inheader and isheader(line, inheader):

                yield chunk(cur)

                cur = []

                inheader = True

            if inheader and not isheader(line, inheader):

                inheader = False

            cur.append(line)

        if cur:

            yield chunk(cur)

    def remainder(cur):

        yield chunk(cur)

    class fiter(object):

        def __init__(self, fp):

            self.fp = fp

        def __iter__(self):

            return self

        def next(self):

            l = self.fp.readline()

            if not l:

                raise StopIteration

            return l

        __next__ = next

    inheader = False

    cur = []

    mimeheaders = [b'content-type']

    if not util.safehasattr(stream, b'next'):

        # http responses, for example, have readline but not next

        stream = fiter(stream)

    for line in stream:

        cur.append(line)

        if line.startswith(b'# HG changeset patch'):

            return hgsplit(stream, cur)

        elif line.startswith(b'From '):

            return mboxsplit(stream, cur)

        elif isheader(line, inheader):

            inheader = True

            if line.split(b':', 1)[0].lower() in mimeheaders:

                # let email parser handle this

                return mimesplit(stream, cur)

        elif line.startswith(b'--- ') and inheader:

            # No evil headers seen by diff start, split by hand

            return headersplit(stream, cur)

        # Not enough info, keep reading

    # if we are here, we have a very plain patch

    return remainder(cur)

## Some facility for extensible patch parsing:

# list of pairs ("header to match", "data key")

patchheadermap = [

    (b'Date', b'date'),

    (b'Branch', b'branch'),

    (b'Node ID', b'nodeid'),

]

@contextlib.contextmanager

def extract(ui, fileobj):

    """extract patch from data read from fileobj.

    patch can be a normal patch or contained in an email message.

    return a dictionary. Standard keys are:

      - filename,

      - message,

      - user,

      - date,

      - branch,

      - node,

      - p1,

      - p2.

    Any item can be missing from the dictionary. If filename is missing,

    fileobj did not contain a patch. Caller must unlink filename when done."""

    fd, tmpname = pycompat.mkstemp(prefix=b'hg-patch-')

    tmpfp = os.fdopen(fd, 'wb')

    try:

        yield _extract(ui, fileobj, tmpname, tmpfp)

    finally:

        tmpfp.close()

        os.unlink(tmpname)

def _extract(ui, fileobj, tmpname, tmpfp):

    # attempt to detect the start of a patch

    # (this heuristic is borrowed from quilt)

    diffre = re.compile(

        br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'

        br'retrieving revision [0-9]+(\.[0-9]+)*$|'

        br'---[ \t].*?^\+\+\+[ \t]|'

        br'\*\*\*[ \t].*?^---[ \t])',

        re.MULTILINE | re.DOTALL,

    )

    data = {}

    msg = mail.parse(fileobj)

    subject = msg['Subject'] and mail.headdecode(msg['Subject'])

    data[b'user'] = msg['From'] and mail.headdecode(msg['From'])

    if not subject and not data[b'user']:

        # Not an email, restore parsed headers if any

        subject = (

            b'\n'.join(

                b': '.join(map(encoding.strtolocal, h)) for h in msg.items()

            )

            + b'\n'

        )

    # should try to parse msg['Date']

    parents = []

    nodeid = msg['X-Mercurial-Node']

    if nodeid:

        data[b'nodeid'] = nodeid = mail.headdecode(nodeid)

        ui.debug(b'Node ID: %s\n' % nodeid)

    if subject:

        if subject.startswith(b'[PATCH'):

            pend = subject.find(b']')

            if pend >= 0:

                subject = subject[pend + 1 :].lstrip()

        subject = re.sub(br'\n[ \t]+', b' ', subject)

        ui.debug(b'Subject: %s\n' % subject)

    if data[b'user']:

        ui.debug(b'From: %s\n' % data[b'user'])

    diffs_seen = 0

    ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch')

    message = b''

    for part in msg.walk():

        content_type = pycompat.bytestr(part.get_content_type())

        ui.debug(b'Content-Type: %s\n' % content_type)

        if content_type not in ok_types:

            continue

        payload = part.get_payload(decode=True)

        m = diffre.search(payload)

        if m:

            hgpatch = False

            hgpatchheader = False

            ignoretext = False

            ui.debug(b'found patch at byte %d\n' % m.start(0))

            diffs_seen += 1

            cfp = stringio()

            for line in payload[: m.start(0)].splitlines():

                if line.startswith(b'# HG changeset patch') and not hgpatch:

                    ui.debug(b'patch generated by hg export\n')

                    hgpatch = True

                    hgpatchheader = True

                    # drop earlier commit message content

                    cfp.seek(0)

                    cfp.truncate()

                    subject = None

                elif hgpatchheader:

                    if line.startswith(b'# User '):

                        data[b'user'] = line[7:]

                        ui.debug(b'From: %s\n' % data[b'user'])

                    elif line.startswith(b"# Parent "):

                        parents.append(line[9:].lstrip())

                    elif line.startswith(b"# "):

                        for header, key in patchheadermap:

                            prefix = b'# %s ' % header

                            if line.startswith(prefix):

                                data[key] = line[len(prefix) :]

                                ui.debug(b'%s: %s\n' % (header, data[key]))

                    else:

                        hgpatchheader = False

                elif line == b'---':

                    ignoretext = True

                if not hgpatchheader and not ignoretext:

                    cfp.write(line)

                    cfp.write(b'\n')

            message = cfp.getvalue()

            if tmpfp:

                tmpfp.write(payload)

                if not payload.endswith(b'\n'):

                    tmpfp.write(b'\n')

        elif not diffs_seen and message and content_type == b'text/plain':

            message += b'\n' + payload

    if subject and not message.startswith(subject):

        message = b'%s\n%s' % (subject, message)

    data[b'message'] = message

    tmpfp.close()

    if parents:

        data[b'p1'] = parents.pop(0)

        if parents:

            data[b'p2'] = parents.pop(0)

    if diffs_seen:

        data[b'filename'] = tmpname

    return data

class patchmeta(object):

    """Patched file metadata

    'op' is the performed operation within ADD, DELETE, RENAME, MODIFY

    or COPY.  'path' is patched file path. 'oldpath' is set to the

    origin file when 'op' is either COPY or RENAME, None otherwise. If

    file mode is changed, 'mode' is a tuple (islink, isexec) where

    'islink' is True if the file is a symlink and 'isexec' is True if

    the file is executable. Otherwise, 'mode' is None.

    """

    def __init__(self, path):

        self.path = path

        self.oldpath = None

        self.mode = None

        self.op = b'MODIFY'

        self.binary = False

    def setmode(self, mode):

        islink = mode & 0o20000

        isexec = mode & 0o100

        self.mode = (islink, isexec)

    def copy(self):

        other = patchmeta(self.path)

        other.oldpath = self.oldpath

        other.mode = self.mode

        other.op = self.op

        other.binary = self.binary

        return other

    def _ispatchinga(self, afile):

        if afile == b'/dev/null':

            return self.op == b'ADD'

        return afile == b'a/' + (self.oldpath or self.path)

    def _ispatchingb(self, bfile):

        if bfile == b'/dev/null':

            return self.op == b'DELETE'

        return bfile == b'b/' + self.path