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

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