# 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 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.read_series(self.full_series)

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

    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 read_series(self, list):

        def matcher(list):

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

            for l in list:

                m = pre.match(l)

                if m:

                    s = m.group(2)

                    s = s.rstrip()

                    if len(s) > 0:

                        yield s

        self.series = []

        self.series = [ x for x in matcher(list) ]

    def save_dirty(self):

        if self.applied_dirty:

            if len(self.applied) > 0:

                nl = "\n"

            else:

                nl = ""

            f = self.opener(self.status_path, "w")

        if self.series_dirty:

            if len(self.full_series) > 0:

                nl = "\n"

            else:

                nl = ""

            f = self.opener(self.series_path, "w")

            f.write("\n".join(self.full_series) + nl)

    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.

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

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

        c = repo.changelog.read(rev)

        ret = repo.update(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

        pp = repo.changelog.parents(rev)

        if pp[1] != revlog.nullid:

            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_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_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, repo.root, 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(l[14:])

                # when patch finds a space in the file name, it puts

                # single quotes around the filename.  strip them off

                if pf[0] == "'" and pf[-1] == "'":

                    pf = pf[1:-1]

                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:

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

                    err = 1

                break

            if fuzz and strict:

                self.ui.warn("fuzz found when applying patch, stopping\n")

                err = 1

                break

        tr.close()

        return (err, n)

    def delete(self, repo, patch, force=False):

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

        info = self.isapplied(patch)

        if info:

            raise util.Abort(_("cannot delete applied patch %s") % patch)

        if patch not in self.series:

            raise util.Abort(_("patch %s not in series file") % patch)

        if force:

            r = self.qrepo()

            if r:

                r.remove([patch], True)

            else:

                os.unlink(os.path.join(self.path, patch))

        i = self.find_series(patch)

        del self.full_series[i]

        self.read_series(self.full_series)

        self.series_dirty = 1

    def check_toppatch(self, repo):

        if len(self.applied) > 0:

            pp = repo.dirstate.parents()

            if top not in pp:

                raise util.Abort(_("queue top not at same revision as working directory"))

            return top

        return None

    def check_localchanges(self, repo):

        (c, a, r, d, u) = repo.changes(None, None)

        if c or a or d or r:

            raise util.Abort(_("local changes found, refresh first"))

    def new(self, repo, patch, msg=None, force=None):

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

            raise util.Abort(_('patch "%s" already exists') % patch)

        commitfiles = []

        (c, a, r, d, u) = repo.changes(None, None)

        if c or a or d or r:

            if not force:

                raise util.Abort(_("local changes found, refresh first"))

            commitfiles = c + a + r

        self.check_toppatch(repo)

        wlock = repo.wlock()

        insert = self.full_series_end()

        if msg:

            n = repo.commit(commitfiles, "[mq]: %s" % msg, force=True,

                            wlock=wlock)

        else:

            n = repo.commit(commitfiles,

                            "New patch: %s" % patch, force=True, wlock=wlock)

        if n == None:

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

        self.full_series[insert:insert] = [patch]

        self.read_series(self.full_series)

        self.series_dirty = 1

        self.applied_dirty = 1

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

        if msg:

            msg = msg + "\n"

            p.write(msg)

        p.close()

        wlock = None

        r = self.qrepo()

        if r: r.add([patch])

        if commitfiles:

            self.refresh(repo, msg=None, short=True)

    def strip(self, repo, rev, update=True, backup="all", wlock=None):

        def limitheads(chlog, stop):

            """return the list of all nodes that have no children"""

            p = {}

            h = []

            stoprev = 0

            if stop in chlog.nodemap:

                stoprev = chlog.rev(stop)

            for r in range(chlog.count() - 1, -1, -1):

                n = chlog.node(r)

                if n not in p:

                    h.append(n)

                if n == stop:

                    break

                if r < stoprev:

                    break

                for pn in chlog.parents(n):

                    p[pn] = 1

            return h

        def bundle(cg):

            backupdir = repo.join("strip-backup")

            if not os.path.isdir(backupdir):

                os.mkdir(backupdir)

            name = os.path.join(backupdir, "%s" % revlog.short(rev))

            name = savename(name)

            self.ui.warn("saving bundle to %s\n" % name)

            # TODO, exclusive open

            f = open(name, "wb")

            try:

                f.write("HG10")

                z = bz2.BZ2Compressor(9)

                while 1:

                    chunk = cg.read(4096)

                    if not chunk:

                        break

                    f.write(z.compress(chunk))

                f.write(z.flush())

            except:

                os.unlink(name)

                raise

            f.close()

            return name

        def stripall(rev, revnum):

            cl = repo.changelog

            c = cl.read(rev)

            mm = repo.manifest.read(c[0])

            seen = {}