# queue.py - patch queues for mercurial

#

# Copyright 2005 Chris Mason <mason@suse.com>

#

# This software may be used and distributed according to the terms

# of the GNU General Public License, incorporated herein by reference.

'''patch management and development

This extension lets you work with a stack of patches in a Mercurial

repository.  It manages two stacks of patches - all known patches, and

applied patches (subset of known patches).

Known patches are represented as patch files in the .hg/patches

directory.  Applied patches are both patch files and changesets.

Common tasks (use "hg help command" for more details):

prepare repository to work with patches   qinit

create new patch                          qnew

import existing patch                     qimport

print patch series                        qseries

print applied patches                     qapplied

print name of top applied patch           qtop

add known patch to applied stack          qpush

remove patch from applied stack           qpop

refresh contents of top applied patch     qrefresh

'''

from mercurial.demandload import *

demandload(globals(), "os sys re struct traceback errno bz2")

from mercurial.i18n import gettext as _

from mercurial import ui, hg, revlog, commands, util

versionstr = "0.45"

commands.norepo += " qclone qversion"

class StatusEntry:

    def __init__(self, rev, name=None):

        if not name:

            self.rev, self.name = rev.split(':')

        else:

            self.rev, self.name = rev, name

    def __str__(self):

        return self.rev + ':' + self.name

class queue:

    def __init__(self, ui, path, patchdir=None):

        self.basepath = path

        if patchdir:

            self.path = patchdir

        else:

            self.path = os.path.join(path, "patches")

        self.opener = util.opener(self.path)

        self.ui = ui

        self.applied = []

        self.full_series = []

        self.applied_dirty = 0

        self.series_dirty = 0

        self.series_path = "series"

        self.status_path = "status"

        if os.path.exists(os.path.join(self.path, self.series_path)):

            self.full_series = self.opener(self.series_path).read().splitlines()

        self.parse_series()

        if os.path.exists(os.path.join(self.path, self.status_path)):

            self.applied = [StatusEntry(l)

                            for l in self.opener(self.status_path).read().splitlines()]

    def find_series(self, patch):

        pre = re.compile("(\s*)([^#]+)")

        index = 0

        for l in self.full_series:

            m = pre.match(l)

            if m:

                s = m.group(2)

                s = s.rstrip()

                if s == patch:

                    return index

            index += 1

        return None

    def parse_series(self):

        self.series = []

        for l in self.full_series:

            s = l.split('#', 1)[0].strip()

            if s:

                self.series.append(s)

    def save_dirty(self):

        def write_list(items, path):

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

            for i in items:

                print >> fp, i

            fp.close()

        if self.applied_dirty: write_list(map(str, self.applied), self.status_path)

        if self.series_dirty: write_list(self.full_series, self.series_path)

    def readheaders(self, patch):

        def eatdiff(lines):

            while lines:

                l = lines[-1]

                if (l.startswith("diff -") or

                    l.startswith("Index:") or

                    l.startswith("===========")):

                    del lines[-1]

                else:

                    break

        def eatempty(lines):

            while lines:

                l = lines[-1]

                if re.match('\s*$', l):

                    del lines[-1]

                else:

                    break

        pf = os.path.join(self.path, patch)

        message = []

        comments = []

        user = None

        date = None

        format = None

        subject = None

        diffstart = 0

        for line in file(pf):

            line = line.rstrip()

            if diffstart:

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

                    diffstart = 2

                break

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

                diffstart = 1

                continue

            elif format == "hgpatch":

                # parse values when importing the result of an hg export

                if line.startswith("# User "):

                    user = line[7:]

                elif line.startswith("# Date "):

                    date = line[7:]

                elif not line.startswith("# ") and line:

                    message.append(line)

                    format = None

            elif line == '# HG changeset patch':

                format = "hgpatch"

            elif (format != "tagdone" and (line.startswith("Subject: ") or

                                           line.startswith("subject: "))):

                subject = line[9:]

                format = "tag"

            elif (format != "tagdone" and (line.startswith("From: ") or

                                           line.startswith("from: "))):

                user = line[6:]

                format = "tag"

            elif format == "tag" and line == "":

                # when looking for tags (subject: from: etc) they

                # end once you find a blank line in the source

                format = "tagdone"

            elif message or line:

                message.append(line)

            comments.append(line)

        eatdiff(message)

        eatdiff(comments)

        eatempty(message)

        eatempty(comments)

        # make sure message isn't empty

        if format and format.startswith("tag") and subject:

            message.insert(0, "")

            message.insert(0, subject)

        return (message, comments, user, date, diffstart > 1)

    def mergeone(self, repo, mergeq, head, patch, rev, wlock):

        # first try just applying the patch

        (err, n) = self.apply(repo, [ patch ], update_status=False,

                              strict=True, merge=rev, wlock=wlock)

        if err == 0:

            return (err, n)

        if n is None:

            raise util.Abort(_("apply failed for patch %s") % patch)

        self.ui.warn("patch didn't work out, merging %s\n" % patch)

        # apply failed, strip away that rev and merge.

        hg.update(repo, head, allow=False, force=True, wlock=wlock)

        self.strip(repo, n, update=False, backup='strip', wlock=wlock)

        c = repo.changelog.read(rev)

        ret = hg.update(repo, rev, allow=True, wlock=wlock)

        if ret:

            raise util.Abort(_("update returned %d") % ret)

        n = repo.commit(None, c[4], c[1], force=1, wlock=wlock)

        if n == None:

            raise util.Abort(_("repo commit failed"))

        try:

            message, comments, user, date, patchfound = mergeq.readheaders(patch)

        except:

            raise util.Abort(_("unable to read %s") % patch)

        patchf = self.opener(patch, "w")

        if comments:

            comments = "\n".join(comments) + '\n\n'

            patchf.write(comments)

        commands.dodiff(patchf, self.ui, repo, head, n)

        patchf.close()

        return (0, n)

    def qparents(self, repo, rev=None):

        if rev is None:

            (p1, p2) = repo.dirstate.parents()

            if p2 == revlog.nullid:

                return p1

            if len(self.applied) == 0:

                return None

            return revlog.bin(self.applied[-1].rev)

        pp = repo.changelog.parents(rev)

        if pp[1] != revlog.nullid:

            arevs = [ x.rev for x in self.applied ]

            p0 = revlog.hex(pp[0])

            p1 = revlog.hex(pp[1])

            if p0 in arevs:

                return pp[0]

            if p1 in arevs:

                return pp[1]

        return pp[0]

    def mergepatch(self, repo, mergeq, series, wlock):

        if len(self.applied) == 0:

            # each of the patches merged in will have two parents.  This

            # can confuse the qrefresh, qdiff, and strip code because it

            # needs to know which parent is actually in the patch queue.

            # so, we insert a merge marker with only one parent.  This way

            # the first patch in the queue is never a merge patch

            #

            pname = ".hg.patches.merge.marker"

            n = repo.commit(None, '[mq]: merge marker', user=None, force=1,

                            wlock=wlock)

            self.applied.append(StatusEntry(revlog.hex(n), pname))

            self.applied_dirty = 1

        head = self.qparents(repo)

        for patch in series:

            patch = mergeq.lookup(patch, strict=True)

            if not patch:

                self.ui.warn("patch %s does not exist\n" % patch)

                return (1, None)

            info = mergeq.isapplied(patch)

            if not info:

                self.ui.warn("patch %s is not applied\n" % patch)

                return (1, None)

            rev = revlog.bin(info[1])

            (err, head) = self.mergeone(repo, mergeq, head, patch, rev, wlock)

            if head:

                self.applied.append(StatusEntry(revlog.hex(head), patch))

                self.applied_dirty = 1

            if err:

                return (err, head)

        return (0, head)

    def patch(self, repo, patchfile):

        '''Apply patchfile  to the working directory.

        patchfile: file name of patch'''

        try:

            pp = util.find_in_path('gpatch', os.environ.get('PATH', ''), 'patch')

            f = os.popen("%s -d %s -p1 --no-backup-if-mismatch < %s" %

                         (pp, util.shellquote(repo.root), util.shellquote(patchfile)))

        except:

            self.ui.warn("patch failed, unable to continue (try -v)\n")

            return (None, [], False)

        files = []

        fuzz = False

        for l in f:

            l = l.rstrip('\r\n');

            if self.ui.verbose:

                self.ui.warn(l + "\n")

            if l[:14] == 'patching file ':

                pf = os.path.normpath(util.parse_patch_output(l))

                if pf not in files:

                    files.append(pf)

                printed_file = False

                file_str = l

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

                if not printed_file:

                    self.ui.warn(file_str + '\n')

                    printed_file = True

                self.ui.warn(l + '\n')

                fuzz = True

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

                self.ui.warn(l + '\n')

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

                if not printed_file:

                    self.ui.warn(file_str + '\n')

                    printed_file = True

                self.ui.warn(l + '\n')

        return (not f.close(), files, fuzz)

    def apply(self, repo, series, list=False, update_status=True,

              strict=False, patchdir=None, merge=None, wlock=None):

        # TODO unify with commands.py

        if not patchdir:

            patchdir = self.path

        err = 0

        if not wlock:

            wlock = repo.wlock()

        lock = repo.lock()

        tr = repo.transaction()

        n = None

        for patch in series:

            self.ui.warn("applying %s\n" % patch)

            pf = os.path.join(patchdir, patch)

            try:

                message, comments, user, date, patchfound = self.readheaders(patch)

            except:

                self.ui.warn("Unable to read %s\n" % pf)

                err = 1

                break

            if not message:

                message = "imported patch %s\n" % patch

            else:

                if list:

                    message.append("\nimported patch %s" % patch)

                message = '\n'.join(message)

            (patcherr, files, fuzz) = self.patch(repo, pf)

            patcherr = not patcherr

            if merge and len(files) > 0:

                # Mark as merged and update dirstate parent info

                repo.dirstate.update(repo.dirstate.filterfiles(files), 'm')

                p1, p2 = repo.dirstate.parents()

                repo.dirstate.setparents(p1, merge)

            if len(files) > 0:

                cwd = repo.getcwd()

                cfiles = files

                if cwd:

                    cfiles = [util.pathto(cwd, f) for f in files]

                commands.addremove_lock(self.ui, repo, cfiles,

                                        opts={}, wlock=wlock)

            n = repo.commit(files, message, user, date, force=1, lock=lock,

                            wlock=wlock)

            if n == None:

                raise util.Abort(_("repo commit failed"))

            if update_status:

                self.applied.append(StatusEntry(revlog.hex(n), patch))

            if patcherr:

                if not patchfound:

                    self.ui.warn("patch %s is empty\n" % patch)

                    err = 0

                else:

                    self.ui.warn("patch failed, rejects left in working dir\n")