# queue.py - patch queues for mercurial

#

# Copyright 2005, 2006 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.i18n import _

from mercurial import commands, cmdutil, hg, patch, revlog, util, changegroup

import os, sys, re, errno

commands.norepo += " qclone qversion"

# Patch names looks like unix-file names.

# They must be joinable with queue directory and result in the patch path.

normname = util.normpath

class statusentry:

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

        if not name:

            fields = rev.split(':', 1)

            if len(fields) == 2:

                self.rev, self.name = fields

            else:

                self.rev, self.name = None, None

        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

        self.path = patchdir or 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"

        self.guards_path = "guards"

        self.active_guards = None

        self.guards_dirty = False

        self._diffopts = None

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

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

        self.parse_series()

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

            lines = self.opener(self.status_path).read().splitlines()

            self.applied = [statusentry(l) for l in lines]

    def diffopts(self):

        if self._diffopts is None:

            self._diffopts = patch.diffopts(self.ui)

        return self._diffopts

    def join(self, *p):

        return os.path.join(self.path, *p)

    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

    guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')

    def parse_series(self):

        self.series = []

        self.series_guards = []

        for l in self.full_series:

            h = l.find('#')

            if h == -1:

                patch = l

                comment = ''

            elif h == 0:

                continue

            else:

                patch = l[:h]

                comment = l[h:]

            patch = patch.strip()

            if patch:

                if patch in self.series:

                    raise util.Abort(_('%s appears more than once in %s') %

                                     (patch, self.join(self.series_path)))

                self.series.append(patch)

                self.series_guards.append(self.guard_re.findall(comment))

    def check_guard(self, guard):

        bad_chars = '# \t\r\n\f'

        first = guard[0]

        for c in '-+':

            if first == c:

                return (_('guard %r starts with invalid character: %r') %

                        (guard, c))

        for c in bad_chars:

            if c in guard:

                return _('invalid character in guard %r: %r') % (guard, c)

    def set_active(self, guards):

        for guard in guards:

            bad = self.check_guard(guard)

            if bad:

                raise util.Abort(bad)

        guards = dict.fromkeys(guards).keys()

        guards.sort()

        self.ui.debug('active guards: %s\n' % ' '.join(guards))

        self.active_guards = guards

        self.guards_dirty = True

    def active(self):

        if self.active_guards is None:

            self.active_guards = []

            try:

                guards = self.opener(self.guards_path).read().split()

            except IOError, err:

                if err.errno != errno.ENOENT: raise

                guards = []

            for i, guard in enumerate(guards):

                bad = self.check_guard(guard)

                if bad:

                    self.ui.warn('%s:%d: %s\n' %

                                 (self.join(self.guards_path), i + 1, bad))

                else:

                    self.active_guards.append(guard)

        return self.active_guards

    def set_guards(self, idx, guards):

        for g in guards:

            if len(g) < 2:

                raise util.Abort(_('guard %r too short') % g)

            if g[0] not in '-+':

                raise util.Abort(_('guard %r starts with invalid char') % g)

            bad = self.check_guard(g[1:])

            if bad:

                raise util.Abort(bad)

        drop = self.guard_re.sub('', self.full_series[idx])

        self.full_series[idx] = drop + ''.join([' #' + g for g in guards])

        self.parse_series()

        self.series_dirty = True

    def pushable(self, idx):

        if isinstance(idx, str):

            idx = self.series.index(idx)

        patchguards = self.series_guards[idx]

        if not patchguards:

            return True, None

        default = False

        guards = self.active()

        exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]

        if exactneg:

            return False, exactneg[0]

        pos = [g for g in patchguards if g[0] == '+']

        exactpos = [g for g in pos if g[1:] in guards]

        if pos:

            if exactpos:

                return True, exactpos[0]

            return False, pos

        return True, ''

    def explain_pushable(self, idx, all_patches=False):

        write = all_patches and self.ui.write or self.ui.warn

        if all_patches or self.ui.verbose:

            if isinstance(idx, str):

                idx = self.series.index(idx)

            pushable, why = self.pushable(idx)

            if all_patches and pushable:

                if why is None:

                    write(_('allowing %s - no guards in effect\n') %

                          self.series[idx])

                else:

                    if not why:

                        write(_('allowing %s - no matching negative guards\n') %

                              self.series[idx])

                    else:

                        write(_('allowing %s - guarded by %r\n') %

                              (self.series[idx], why))

            if not pushable:

                if why:

                    write(_('skipping %s - guarded by %r\n') %

                          (self.series[idx], why))

                else:

                    write(_('skipping %s - no matching guards\n') %

                          self.series[idx])

    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)

        if self.guards_dirty: write_list(self.active_guards, self.guards_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 = self.join(patch)

        message = []

        comments = []

        user = None

        date = None

        format = None

        subject = None

        diffstart = 0

        for line in file(pf):

            line = line.rstrip()

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

                diffstart = 2

                break

            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 removeundo(self, repo):

        undo = repo.sjoin('undo')

        if not os.path.exists(undo):

            return

        try:

            os.unlink(undo)

        except OSError, inst:

            self.ui.warn('error removing undo: %s\n' % str(inst))

    def printdiff(self, repo, node1, node2=None, files=None,

                  fp=None, changes=None, opts={}):

        fns, matchfn, anypats = cmdutil.matchpats(repo, files, opts)

        patch.diff(repo, node1, node2, fns, match=matchfn,

                   fp=fp, changes=changes, opts=self.diffopts())

    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.clean(repo, head, wlock=wlock)

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

        ctx = repo.changectx(rev)

        ret = hg.merge(repo, rev, wlock=wlock)

        if ret:

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

        n = repo.commit(None, ctx.description(), ctx.user(),

                        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)

        self.printdiff(repo, head, n, fp=patchf)

        patchf.close()

        self.removeundo(repo)

        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.removeundo(repo)

            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)

            pushable, reason = self.pushable(patch)

            if not pushable:

                self.explain_pushable(patch, all_patches=True)

                continue

            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)

        self.save_dirty()

        return (0, head)

    def patch(self, repo, patchfile):

        '''Apply patchfile  to the working directory.

        patchfile: file name of patch'''

        files = {}

        try:

            fuzz = patch.patch(patchfile, self.ui, strip=1, cwd=repo.root,

                               files=files)

        except Exception, inst:

            self.ui.note(str(inst) + '\n')

            if not self.ui.verbose:

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

            return (False, files, False)

        return (True, files, fuzz)

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

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

              all_files={}):

        tr = repo.transaction()

        try:

            ret = self._apply(tr, repo, series, list, update_status,

                              strict, patchdir, merge, wlock,

                              all_files=all_files)

            tr.close()

            self.save_dirty()

            return ret

        except:

            try:

                tr.abort()

            finally:

                repo.reload()

                repo.wreload()

            raise

    def _apply(self, tr, repo, series, list=False, update_status=True,

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

               all_files={}):

        # TODO unify with commands.py

        if not patchdir:

            patchdir = self.path

        err = 0

        if not wlock:

            wlock = repo.wlock()

        lock = repo.lock()

        n = None

        for patchname in series:

            pushable, reason = self.pushable(patchname)

            if not pushable:

                self.explain_pushable(patchname, all_patches=True)

                continue

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

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

            try:

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

            except:

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

                err = 1

                break

            if not message:

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

            else:

                if list:

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

                message = '\n'.join(message)

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

            all_files.update(files)

            patcherr = not patcherr

            if merge and files:

                # Mark as removed/merged and update dirstate parent info

                removed = []

                merged = []