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

import cStringIO, email.Parser, os, errno, re

import tempfile, zlib

from i18n import _

from node import hex, nullid, short

import base85, mdiff, scmutil, util, diffhelpers, copies, encoding

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

class PatchError(Exception):

    pass

# public functions

def split(stream):

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

    def isheader(line, inheader):

        if inheader and line[0] in (' ', '\t'):

            # continuation

            return True

        if line[0] in (' ', '-', '+'):

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

            return False

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

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

    def chunk(lines):

        return cStringIO.StringIO(''.join(lines))

    def hgsplit(stream, cur):

        inheader = True

        for line in stream:

            if not line.strip():

                inheader = False

            if not inheader and line.startswith('# 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('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 = cStringIO.StringIO()

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

            g.flatten(m)

            fp.seek(0)

            return fp

        for line in stream:

            cur.append(line)

        c = chunk(cur)

        m = email.Parser.Parser().parse(c)

        if not m.is_multipart():

            yield msgfp(m)

        else:

            ok_types = ('text/plain', 'text/x-diff', '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

    inheader = False

    cur = []

    mimeheaders = ['content-type']

    if not hasattr(stream, 'next'):

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

        stream = fiter(stream)

    for line in stream:

        cur.append(line)

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

            return hgsplit(stream, cur)

        elif line.startswith('From '):

            return mboxsplit(stream, cur)

        elif isheader(line, inheader):

            inheader = True

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

                # let email parser handle this

                return mimesplit(stream, cur)

        elif line.startswith('--- ') 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)

def extract(ui, fileobj):

    '''extract patch from data read from fileobj.

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

    return tuple (filename, message, user, date, branch, node, p1, p2).

    Any item in the returned tuple can be None. If filename is None,

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

    # attempt to detect the start of a patch

    # (this heuristic is borrowed from quilt)

    diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'

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

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

                        r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)

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

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

    try:

        msg = email.Parser.Parser().parse(fileobj)

        subject = msg['Subject']

        user = msg['From']

        if not subject and not user:

            # Not an email, restore parsed headers if any

            subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'

        gitsendmail = 'git-send-email' in msg.get('X-Mailer', '')

        # should try to parse msg['Date']

        date = None

        nodeid = None

        branch = None

        parents = []

        if subject:

            if subject.startswith('[PATCH'):

                pend = subject.find(']')

                if pend >= 0:

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

            subject = subject.replace('\n\t', ' ')

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

        if user:

            ui.debug('From: %s\n' % user)

        diffs_seen = 0

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

        message = ''

        for part in msg.walk():

            content_type = part.get_content_type()

            ui.debug('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('found patch at byte %d\n' % m.start(0))

                diffs_seen += 1

                cfp = cStringIO.StringIO()

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

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

                        ui.debug('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('# User '):

                            user = line[7:]

                            ui.debug('From: %s\n' % user)

                        elif line.startswith("# Date "):

                            date = line[7:]

                        elif line.startswith("# Branch "):

                            branch = line[9:]

                        elif line.startswith("# Node ID "):

                            nodeid = line[10:]

                        elif line.startswith("# Parent "):

                            parents.append(line[10:])

                        elif not line.startswith("# "):

                            hgpatchheader = False

                    elif line == '---' and gitsendmail:

                        ignoretext = True

                    if not hgpatchheader and not ignoretext:

                        cfp.write(line)

                        cfp.write('\n')

                message = cfp.getvalue()

                if tmpfp:

                    tmpfp.write(payload)

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

                        tmpfp.write('\n')

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

                message += '\n' + payload

    except:

        tmpfp.close()

        os.unlink(tmpname)

        raise

    if subject and not message.startswith(subject):

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

    tmpfp.close()

    if not diffs_seen:

        os.unlink(tmpname)

        return None, message, user, date, branch, None, None, None

    p1 = parents and parents.pop(0) or None

    p2 = parents and parents.pop(0) or None

    return tmpname, message, user, date, branch, nodeid, p1, p2

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 = 'MODIFY'

        self.binary = False

    def setmode(self, mode):

        islink = mode & 020000

        isexec = mode & 0100

        self.mode = (islink, isexec)

    def __repr__(self):

        return "<patchmeta %s %r>" % (self.op, self.path)

def readgitpatch(lr):

    """extract git-style metadata about patches from <patchname>"""

    # Filter patch for git information

    gp = None

    gitpatches = []

    for line in lr:

        line = line.rstrip(' \r\n')

        if line.startswith('diff --git'):

            m = gitre.match(line)

            if m:

                if gp:

                    gitpatches.append(gp)

                dst = m.group(2)

                gp = patchmeta(dst)

        elif gp:

            if line.startswith('--- '):

                gitpatches.append(gp)

                gp = None

                continue

            if line.startswith('rename from '):

                gp.op = 'RENAME'

                gp.oldpath = line[12:]

            elif line.startswith('rename to '):

                gp.path = line[10:]

            elif line.startswith('copy from '):

                gp.op = 'COPY'

                gp.oldpath = line[10:]

            elif line.startswith('copy to '):

                gp.path = line[8:]

            elif line.startswith('deleted file'):

                gp.op = 'DELETE'

            elif line.startswith('new file mode '):

                gp.op = 'ADD'

                gp.setmode(int(line[-6:], 8))

            elif line.startswith('new mode '):

                gp.setmode(int(line[-6:], 8))

            elif line.startswith('GIT binary patch'):

                gp.binary = True

    if gp:

        gitpatches.append(gp)

    return gitpatches

class linereader(object):

    # simple class to allow pushing lines back into the input stream

    def __init__(self, fp):

        self.fp = fp

        self.buf = []

    def push(self, line):

        if line is not None:

            self.buf.append(line)

    def readline(self):

        if self.buf:

            l = self.buf[0]

            del self.buf[0]

            return l

        return self.fp.readline()

    def __iter__(self):

        while 1:

            l = self.readline()

            if not l:

                break

            yield l

class abstractbackend(object):

    def __init__(self, ui):

        self.ui = ui

    def getfile(self, fname):

        """Return target file data and flags as a (data, (islink,

        isexec)) tuple.

        """

        raise NotImplementedError

    def setfile(self, fname, data, mode):

        """Write data to target file fname and set its mode. mode is a

        (islink, isexec) tuple. If data is None, the file content should

        be left unchanged.

        """

        raise NotImplementedError

    def unlink(self, fname):

        """Unlink target file."""

        raise NotImplementedError

    def writerej(self, fname, failed, total, lines):

        """Write rejected lines for fname. total is the number of hunks

        which failed to apply and total the total number of hunks for this

        files.

        """

        pass

    def copy(self, src, dst):

        """Copy src file into dst file. Create intermediate directories if

        necessary. Files are specified relatively to the patching base

        directory.

        """

        raise NotImplementedError

    def exists(self, fname):

        raise NotImplementedError

class fsbackend(abstractbackend):

    def __init__(self, ui, basedir):

        super(fsbackend, self).__init__(ui)

        self.opener = scmutil.opener(basedir)

    def _join(self, f):

        return os.path.join(self.opener.base, f)

    def getfile(self, fname):

        path = self._join(fname)

        if os.path.islink(path):

            return (os.readlink(path), (True, False))

        isexec, islink = False, False

        try:

            isexec = os.lstat(path).st_mode & 0100 != 0

            islink = os.path.islink(path)

        except OSError, e:

            if e.errno != errno.ENOENT:

                raise

        return (self.opener.read(fname), (islink, isexec))

    def setfile(self, fname, data, mode):

        islink, isexec = mode

        if data is None:

            util.setflags(self._join(fname), islink, isexec)

            return

        if islink:

            self.opener.symlink(data, fname)

        else:

            self.opener.write(fname, data)

            if isexec:

                util.setflags(self._join(fname), False, True)

    def unlink(self, fname):

        try:

            util.unlinkpath(self._join(fname))

        except OSError, inst:

            if inst.errno != errno.ENOENT:

                raise

    def writerej(self, fname, failed, total, lines):

        fname = fname + ".rej"

        self.ui.warn(

            _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %

            (failed, total, fname))

        fp = self.opener(fname, 'w')

        fp.writelines(lines)

        fp.close()

    def copy(self, src, dst):

        basedir = self.opener.base

        abssrc, absdst = [scmutil.canonpath(basedir, basedir, x)

                          for x in [src, dst]]

        if os.path.lexists(absdst):

            raise util.Abort(_("cannot create %s: destination already exists")

                             % dst)

        dstdir = os.path.dirname(absdst)

        if dstdir and not os.path.isdir(dstdir):

            try:

                os.makedirs(dstdir)

            except IOError:

                raise util.Abort(

                    _("cannot create %s: unable to create destination directory")

                    % dst)

        util.copyfile(abssrc, absdst)

    def exists(self, fname):

        return os.path.lexists(self._join(fname))

class workingbackend(fsbackend):

    def __init__(self, ui, repo, similarity):

        super(workingbackend, self).__init__(ui, repo.root)

        self.repo = repo

        self.similarity = similarity

        self.removed = set()

        self.changed = set()

        self.copied = []

    def setfile(self, fname, data, mode):

        super(workingbackend, self).setfile(fname, data, mode)

        self.changed.add(fname)

    def unlink(self, fname):

        super(workingbackend, self).unlink(fname)

        self.removed.add(fname)

        self.changed.add(fname)

    def copy(self, src, dst):

        super(workingbackend, self).copy(src, dst)

        self.copied.append((src, dst))

        self.changed.add(dst)

    def close(self):

        wctx = self.repo[None]

        addremoved = set(self.changed)

        for src, dst in self.copied: