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

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"

repomap = {}

commands.norepo += " 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)):

            self.applied = 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 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")

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

        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

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

            else:

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

            self.ui.warn("apply failed for patch %s\n" % patch)

            sys.exit(1)

        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:

            self.ui.warn("update returned %d\n" % ret)

            sys.exit(1)

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

        if n == None:

            self.ui.warn("repo commit failed\n")

            sys.exit(1)

        try:

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

        except:

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

            sys.exit(1)

        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

            (top, patch) = self.applied[-1].split(':')

            top = revlog.bin(top)

            return top

        pp = repo.changelog.parents(rev)

        if pp[1] != revlog.nullid:

            arevs = [ x.split(':')[0] 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 None

        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(revlog.hex(n) + ":" + pname)

            self.applied_dirty = 1

        head = self.qparents(repo)

        for patch in series:

            patch = mergeq.lookup(patch)

            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(revlog.hex(head) + ":" + patch)

                self.applied_dirty = 1

            if err:

                return (err, head)

        return (0, head)

    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

        pwd = os.getcwd()

        os.chdir(repo.root)

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

            try:

                f = os.popen("patch -p1 --no-backup-if-mismatch < '%s'" % (pf))

            except:

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

                err = 1

                break

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

            patcherr = f.close()

            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:

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

                                        opts={}, wlock=wlock)

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

                            wlock=wlock)

            if n == None:

                self.ui.warn("repo commit failed\n")

                sys.exit(1)

            if update_status:

                self.applied.append(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")

                    err = 1

                break

            if fuzz and strict:

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

                err = 1

                break

        tr.close()

        os.chdir(pwd)

        return (err, n)

    def delete(self, repo, patch):

        patch = self.lookup(patch)

        info = self.isapplied(patch)

        if info:

            self.ui.warn("cannot delete applied patch %s\n" % patch)

            sys.exit(1)

        if patch not in self.series:

            self.ui.warn("patch %s not in series file\n" % patch)

            sys.exit(1)

        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:

            (top, patch) = self.applied[-1].split(':')

            top = revlog.bin(top)

            pp = repo.dirstate.parents()

            if top not in pp:

                self.ui.warn("queue top not at dirstate parents. top %s dirstate %s %s\n" %( revlog.short(top), revlog.short(pp[0]), revlog.short(pp[1])))

                sys.exit(1)

            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:

            self.ui.write("Local changes found, refresh first\n")

            sys.exit(1)

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

        if not force:

            self.check_localchanges(repo)

        self.check_toppatch(repo)

        wlock = repo.wlock()

        insert = self.series_end()

        if msg:

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

        else:

            n = repo.commit([],

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

        if n == None:

            self.ui.warn("repo commit failed\n")

            sys.exit(1)

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

        self.applied.append(revlog.hex(n) + ":" + 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])

    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 = {}

            for x in xrange(revnum, cl.count()):

                c = cl.read(cl.node(x))

                for f in c[3]:

                    if f in seen:

                        continue

                    seen[f] = 1

                    if f in mm:

                        filerev = mm[f]

                    else:

                        filerev = 0

                    seen[f] = filerev

            # we go in two steps here so the strip loop happens in a

            # sensible order.  When stripping many files, this helps keep

            # our disk access patterns under control.

            list = seen.keys()

            list.sort()

            for f in list:

                ff = repo.file(f)

                filerev = seen[f]

                if filerev != 0:

                    if filerev in ff.nodemap:

                        filerev = ff.rev(filerev)

                    else:

                        filerev = 0

                ff.strip(filerev, revnum)

        if not wlock:

            wlock = repo.wlock()

        lock = repo.lock()

        chlog = repo.changelog

        # TODO delete the undo files, and handle undo of merge sets

        pp = chlog.parents(rev)

        revnum = chlog.rev(rev)

        if update:

            urev = self.qparents(repo, rev)

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

            repo.dirstate.write()

        # save is a list of all the branches we are truncating away

        # that we actually want to keep.  changegroup will be used

        # to preserve them and add them back after the truncate

        saveheads = []

        savebases = {}

        tip = chlog.tip()

        heads = limitheads(chlog, rev)

        seen = {}

        # search through all the heads, finding those where the revision

        # we want to strip away is an ancestor.  Also look for merges

        # that might be turned into new heads by the strip.

        while heads:

            h = heads.pop()

            n = h

            while True:

                seen[n] = 1

                pp = chlog.parents(n)

                if pp[1] != revlog.nullid and chlog.rev(pp[1]) > revnum:

                    if pp[1] not in seen:

                        heads.append(pp[1])