# 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, incorporated herein by reference.

from i18n import _

from node import *

import base85, cmdutil, mdiff, util, context, revlog, diffhelpers

import cStringIO, email.Parser, os, popen2, re, sha

import sys, tempfile, zlib

class PatchError(Exception):

    pass

class NoHunks(PatchError):

    pass

# helper functions

def copyfile(src, dst, basedir=None):

    if not basedir:

        basedir = os.getcwd()

    abssrc, absdst = [os.path.join(basedir, n) for n in (src, dst)]

    if os.path.exists(absdst):

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

                         dst)

    targetdir = os.path.dirname(absdst)

    if not os.path.isdir(targetdir):

        os.makedirs(targetdir)

    util.copyfile(abssrc, absdst)

# public functions

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, 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: |' +

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

                        '(---|\*\*\*)[ \t])', re.MULTILINE)

    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']

        # 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

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

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

                        hgpatch = True

                        # drop earlier commit message content

                        cfp.seek(0)

                        cfp.truncate()

                        subject = None

                    elif hgpatch:

                        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 line == '---' and 'git-send-email' in msg['X-Mailer']:

                        ignoretext = True

                    if not line.startswith('# ') 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

GP_PATCH  = 1 << 0  # we have to run patch

GP_FILTER = 1 << 1  # there's some copy/rename operation

GP_BINARY = 1 << 2  # there's a binary patch

def readgitpatch(fp, firstline=None):

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

    class gitpatch:

        "op is one of ADD, DELETE, RENAME, MODIFY or COPY"

        def __init__(self, path):

            self.path = path

            self.oldpath = None

            self.mode = None

            self.op = 'MODIFY'

            self.lineno = 0

            self.binary = False

    def reader(fp, firstline):

        if firstline is not None:

            yield firstline

        for line in fp:

            yield line

    # Filter patch for git information

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

    gp = None

    gitpatches = []

    # Can have a git patch with only metadata, causing patch to complain

    dopatch = 0

    lineno = 0

    for line in reader(fp, firstline):

        lineno += 1

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

            m = gitre.match(line)

            if m:

                if gp:

                    gitpatches.append(gp)

                src, dst = m.group(1, 2)

                gp = gitpatch(dst)

                gp.lineno = lineno

        elif gp:

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

                if gp.op in ('COPY', 'RENAME'):

                    dopatch |= GP_FILTER

                gitpatches.append(gp)

                gp = None

                dopatch |= GP_PATCH

                continue

            if line.startswith('rename from '):

                gp.op = 'RENAME'

                gp.oldpath = line[12:].rstrip()

            elif line.startswith('rename to '):

                gp.path = line[10:].rstrip()

            elif line.startswith('copy from '):

                gp.op = 'COPY'

                gp.oldpath = line[10:].rstrip()

            elif line.startswith('copy to '):

                gp.path = line[8:].rstrip()

            elif line.startswith('deleted file'):

                gp.op = 'DELETE'

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

                gp.op = 'ADD'

                gp.mode = int(line.rstrip()[-6:], 8)

            elif line.startswith('new mode '):

                gp.mode = int(line.rstrip()[-6:], 8)

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

                dopatch |= GP_BINARY

                gp.binary = True

    if gp:

        gitpatches.append(gp)

    if not gitpatches:

        dopatch = GP_PATCH

    return (dopatch, gitpatches)

def patch(patchname, ui, strip=1, cwd=None, files={}):

    """apply <patchname> to the working directory.

    returns whether patch was applied with fuzz factor."""

    patcher = ui.config('ui', 'patch')

    args = []

    try:

        if patcher:

            return externalpatch(patcher, args, patchname, ui, strip, cwd,

                                 files)

        else:

            try:

                return internalpatch(patchname, ui, strip, cwd, files)

            except NoHunks:

                patcher = util.find_exe('gpatch') or util.find_exe('patch')

                ui.debug('no valid hunks found; trying with %r instead\n' %

                         patcher)

                if util.needbinarypatch():

                    args.append('--binary')

                return externalpatch(patcher, args, patchname, ui, strip, cwd,

                                     files)

    except PatchError, err:

        s = str(err)

        if s:

            raise util.Abort(s)

        else:

            raise util.Abort(_('patch failed to apply'))

def externalpatch(patcher, args, patchname, ui, strip, cwd, files):

    """use <patcher> to apply <patchname> to the working directory.

    returns whether patch was applied with fuzz factor."""

    fuzz = False

    if cwd:

        args.append('-d %s' % util.shellquote(cwd))

    fp = os.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,

                                       util.shellquote(patchname)))

    for line in fp:

        line = line.rstrip()

        ui.note(line + '\n')

        if line.startswith('patching file '):

            pf = util.parse_patch_output(line)

            printed_file = False

            files.setdefault(pf, (None, None))

        elif line.find('with fuzz') >= 0:

            fuzz = True

            if not printed_file:

                ui.warn(pf + '\n')

                printed_file = True

            ui.warn(line + '\n')

        elif line.find('saving rejects to file') >= 0:

            ui.warn(line + '\n')

        elif line.find('FAILED') >= 0:

            if not printed_file:

                ui.warn(pf + '\n')

                printed_file = True

            ui.warn(line + '\n')

    code = fp.close()

    if code:

        raise PatchError(_("patch command failed: %s") %

                         util.explain_exit(code)[0])

    return fuzz

def internalpatch(patchobj, ui, strip, cwd, files={}):

    """use builtin patch to apply <patchobj> to the working directory.

    returns whether patch was applied with fuzz factor."""

    try:

        fp = file(patchobj, 'rb')

    except TypeError:

        fp = patchobj

    if cwd:

        curdir = os.getcwd()

        os.chdir(cwd)

    try:

        ret = applydiff(ui, fp, files, strip=strip)

    finally:

        if cwd:

            os.chdir(curdir)

    if ret < 0:

        raise PatchError

    return ret > 0

# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1

unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')

contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')

class patchfile:

    def __init__(self, ui, fname):

        self.fname = fname

        self.ui = ui

        try:

            fp = file(fname, 'rb')

            self.lines = fp.readlines()

            self.exists = True

        except IOError:

            dirname = os.path.dirname(fname)

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

                dirs = dirname.split(os.path.sep)

                d = ""

                for x in dirs:

                    d = os.path.join(d, x)

                    if not os.path.isdir(d):

                        os.mkdir(d)

            self.lines = []

            self.exists = False

        self.hash = {}

        self.dirty = 0

        self.offset = 0

        self.rej = []

        self.fileprinted = False

        self.printfile(False)

        self.hunks = 0

    def printfile(self, warn):

        if self.fileprinted:

            return

        if warn or self.ui.verbose:

            self.fileprinted = True

        s = _("patching file %s\n") % self.fname

        if warn:

            self.ui.warn(s)

        else:

            self.ui.note(s)

    def findlines(self, l, linenum):

        # looks through the hash and finds candidate lines.  The

        # result is a list of line numbers sorted based on distance

        # from linenum

        def sorter(a, b):

            vala = abs(a - linenum)

            valb = abs(b - linenum)

            return cmp(vala, valb)

        try:

            cand = self.hash[l]

        except:

            return []

        if len(cand) > 1:

            # resort our list of potentials forward then back.

            cand.sort(cmp=sorter)

        return cand

    def hashlines(self):

        self.hash = {}

        for x in xrange(len(self.lines)):

            s = self.lines[x]

            self.hash.setdefault(s, []).append(x)

    def write_rej(self):

        # our rejects are a little different from patch(1).  This always

        # creates rejects in the same form as the original patch.  A file

        # header is inserted so that you can run the reject through patch again

        # without having to type the filename.

        if not self.rej:

            return

        if self.hunks != 1:

            hunkstr = "s"

        else:

            hunkstr = ""

        fname = self.fname + ".rej"

        self.ui.warn(

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

            (len(self.rej), self.hunks, hunkstr, fname))

        try: os.unlink(fname)

        except:

            pass

        fp = file(fname, 'wb')

        base = os.path.basename(self.fname)

        fp.write("--- %s\n+++ %s\n" % (base, base))

        for x in self.rej:

            for l in x.hunk:

                fp.write(l)

                if l[-1] != '\n':

                    fp.write("\n\ No newline at end of file\n")

    def write(self, dest=None):

        if self.dirty:

            if not dest:

                dest = self.fname

            st = None

            try:

                st = os.lstat(dest)

                if st.st_nlink > 1:

                    os.unlink(dest)

            except: pass

            fp = file(dest, 'wb')

            if st:

                os.chmod(dest, st.st_mode)

            fp.writelines(self.lines)

            fp.close()

    def close(self):

        self.write()

        self.write_rej()

    def apply(self, h, reverse):

        if not h.complete():

            raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %

                            (h.number, h.desc, len(h.a), h.lena, len(h.b),

                            h.lenb))

        self.hunks += 1

        if reverse:

            h.reverse()

        if self.exists and h.createfile():

            self.ui.warn(_("file %s already exists\n") % self.fname)

            self.rej.append(h)

            return -1

        if isinstance(h, binhunk):

            if h.rmfile():

                os.unlink(self.fname)

            else:

                self.lines[:] = h.new()

                self.offset += len(h.new())

                self.dirty = 1

            return 0

        # fast case first, no offsets, no fuzz

        old = h.old()

        # patch starts counting at 1 unless we are adding the file

        if h.starta == 0:

            start = 0

        else:

            start = h.starta + self.offset - 1

        orig_start = start

        if diffhelpers.testhunk(old, self.lines, start) == 0:

            if h.rmfile():

                os.unlink(self.fname)

            else:

                self.lines[start : start + h.lena] = h.new()

                self.offset += h.lenb - h.lena

                self.dirty = 1

            return 0

        # ok, we couldn't match the hunk.  Lets look for offsets and fuzz it

        self.hashlines()

        if h.hunk[-1][0] != ' ':

            # if the hunk tried to put something at the bottom of the file

            # override the start line and use eof here

            search_start = len(self.lines)

        else:

            search_start = orig_start

        for fuzzlen in xrange(3):

            for toponly in [ True, False ]:

                old = h.old(fuzzlen, toponly)

                cand = self.findlines(old[0][1:], search_start)

                for l in cand:

                    if diffhelpers.testhunk(old, self.lines, l) == 0:

                        newlines = h.new(fuzzlen, toponly)

                        self.lines[l : l + len(old)] = newlines

                        self.offset += len(newlines) - len(old)

                        self.dirty = 1

                        if fuzzlen:

                            fuzzstr = "with fuzz %d " % fuzzlen

                            f = self.ui.warn

                            self.printfile(True)

                        else:

                            fuzzstr = ""

                            f = self.ui.note

                        offset = l - orig_start - fuzzlen

                        if offset == 1:

                            linestr = "line"

                        else:

                            linestr = "lines"

                        f(_("Hunk #%d succeeded at %d %s(offset %d %s).\n") %

                          (h.number, l+1, fuzzstr, offset, linestr))

                        return fuzzlen