# mq.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 version 2 or any later version.

'''manage a stack of patches

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

  create new patch                          qnew

  import existing patch                     qimport

  print patch series                        qseries

  print applied patches                     qapplied

  add known patch to applied stack          qpush

  remove patch from applied stack           qpop

  refresh contents of top applied patch     qrefresh

By default, mq will automatically use git patches when required to

avoid losing file mode changes, copy records, binary files or empty

files creations or deletions. This behaviour can be configured with::

  [mq]

  git = auto/keep/yes/no

If set to 'keep', mq will obey the [diff] section configuration while

preserving existing git patches upon qrefresh. If set to 'yes' or

'no', mq will override the [diff] section and always generate git or

regular patches, possibly losing data in the second case.

You will by default be managing a patch queue named "patches". You can

create other, independent patch queues with the :hg:`qqueue` command.

'''

from mercurial.i18n import _

from mercurial.node import bin, hex, short, nullid, nullrev

from mercurial.lock import release

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

from mercurial import repair, extensions, url, error

import os, sys, re, errno, shutil

commands.norepo += " qclone"

# 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(object):

    def __init__(self, node, name):

        self.node, self.name = node, name

    def __repr__(self):

        return hex(self.node) + ':' + self.name

class patchheader(object):

    def __init__(self, pf, plainmode=False):

        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:

                if not lines[-1].strip():

                    del lines[-1]

                else:

                    break

        message = []

        comments = []

        user = None

        date = None

        parent = None

        format = None

        subject = None

        diffstart = 0

        for line in file(pf):

            line = line.rstrip()

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

                or (diffstart and line.startswith('+++ '))):

                diffstart = 2

                break

            diffstart = 0 # reset

            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 line.startswith("# Parent "):

                    parent = line[9:]

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

                    message.append(line)

                    format = None

            elif line == '# HG changeset patch':

                message = []

                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 != "tagdone" and (line.startswith("Date: ") or

                                           line.startswith("date: "))):

                date = 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)

        self.message = message

        self.comments = comments

        self.user = user

        self.date = date

        self.parent = parent

        self.haspatch = diffstart > 1

        self.plainmode = plainmode

    def setuser(self, user):

        if not self.updateheader(['From: ', '# User '], user):

            try:

                patchheaderat = self.comments.index('# HG changeset patch')

                self.comments.insert(patchheaderat + 1, '# User ' + user)

            except ValueError:

                if self.plainmode or self._hasheader(['Date: ']):

                    self.comments = ['From: ' + user] + self.comments

                else:

                    tmp = ['# HG changeset patch', '# User ' + user, '']

                    self.comments = tmp + self.comments

        self.user = user

    def setdate(self, date):

        if not self.updateheader(['Date: ', '# Date '], date):

            try:

                patchheaderat = self.comments.index('# HG changeset patch')

                self.comments.insert(patchheaderat + 1, '# Date ' + date)

            except ValueError:

                if self.plainmode or self._hasheader(['From: ']):

                    self.comments = ['Date: ' + date] + self.comments

                else:

                    tmp = ['# HG changeset patch', '# Date ' + date, '']

                    self.comments = tmp + self.comments

        self.date = date

    def setparent(self, parent):

        if not self.updateheader(['# Parent '], parent):

            try:

                patchheaderat = self.comments.index('# HG changeset patch')

                self.comments.insert(patchheaderat + 1, '# Parent ' + parent)

            except ValueError:

                pass

        self.parent = parent

    def setmessage(self, message):

        if self.comments:

            self._delmsg()

        self.message = [message]

        self.comments += self.message

    def updateheader(self, prefixes, new):

        '''Update all references to a field in the patch header.

        Return whether the field is present.'''

        res = False

        for prefix in prefixes:

            for i in xrange(len(self.comments)):

                if self.comments[i].startswith(prefix):

                    self.comments[i] = prefix + new

                    res = True

                    break

        return res

    def _hasheader(self, prefixes):

        '''Check if a header starts with any of the given prefixes.'''

        for prefix in prefixes:

            for comment in self.comments:

                if comment.startswith(prefix):

                    return True

        return False

    def __str__(self):

        if not self.comments:

            return ''

        return '\n'.join(self.comments) + '\n\n'

    def _delmsg(self):

        '''Remove existing message, keeping the rest of the comments fields.

        If comments contains 'subject: ', message will prepend

        the field and a blank line.'''

        if self.message:

            subj = 'subject: ' + self.message[0].lower()

            for i in xrange(len(self.comments)):

                if subj == self.comments[i].lower():

                    del self.comments[i]

                    self.message = self.message[2:]

                    break

        ci = 0

        for mi in self.message:

            while mi != self.comments[ci]:

                ci += 1

            del self.comments[ci]

class queue(object):

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

        self.basepath = path

        try:

            fh = open(os.path.join(path, 'patches.queue'))

            cur = fh.read().rstrip()

            if not cur:

                curpath = os.path.join(path, 'patches')

            else:

                curpath = os.path.join(path, 'patches-' + cur)

        except IOError:

            curpath = os.path.join(path, 'patches')

        self.path = patchdir or curpath

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

        self.ui = ui

        self.applied_dirty = 0

        self.series_dirty = 0

        self.added = []

        self.series_path = "series"

        self.status_path = "status"

        self.guards_path = "guards"

        self.active_guards = None

        self.guards_dirty = False

        # Handle mq.git as a bool with extended values

        try:

            gitmode = ui.configbool('mq', 'git', None)

            if gitmode is None:

                raise error.ConfigError()

            self.gitmode = gitmode and 'yes' or 'no'

        except error.ConfigError:

            self.gitmode = ui.config('mq', 'git', 'auto').lower()

        self.plainmode = ui.configbool('mq', 'plain', False)

    @util.propertycache

    def applied(self):

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

            def parse(l):

                n, name = l.split(':', 1)

                return statusentry(bin(n), name)

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

            return [parse(l) for l in lines]

        return []

    @util.propertycache

    def full_series(self):

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

            return self.opener(self.series_path).read().splitlines()

        return []

    @util.propertycache

    def series(self):

        self.parse_series()

        return self.series

    @util.propertycache

    def series_guards(self):

        self.parse_series()

        return self.series_guards

    def invalidate(self):

        for a in 'applied full_series series series_guards'.split():

            if a in self.__dict__:

                delattr(self, a)

        self.applied_dirty = 0

        self.series_dirty = 0

        self.guards_dirty = False

        self.active_guards = None

    def diffopts(self, opts={}, patchfn=None):

        diffopts = patch.diffopts(self.ui, opts)

        if self.gitmode == 'auto':

            diffopts.upgrade = True

        elif self.gitmode == 'keep':

            pass

        elif self.gitmode in ('yes', 'no'):

            diffopts.git = self.gitmode == 'yes'

        else:

            raise util.Abort(_('mq.git option can be auto/keep/yes/no'

                               ' got %s') % self.gitmode)

        if patchfn:

            diffopts = self.patchopts(diffopts, patchfn)

        return diffopts

    def patchopts(self, diffopts, *patches):

        """Return a copy of input diff options with git set to true if

        referenced patch is a git patch and should be preserved as such.

        """

        diffopts = diffopts.copy()

        if not diffopts.git and self.gitmode == 'keep':

            for patchfn in patches:

                patchf = self.opener(patchfn, 'r')

                # if the patch was a git patch, refresh it as a git patch

                for line in patchf:

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

                        diffopts.git = True

                        break

                patchf.close()

        return diffopts

    def join(self, *p):

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

    def find_series(self, patch):

        def matchpatch(l):

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

            return l.strip() == patch

        for index, l in enumerate(self.full_series):

            if matchpatch(l):

                return index

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

        if not guard:

            return _('guard cannot be an empty string')

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

        first = guard[0]

        if first in '-+':

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

                      (guard, first))

        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 = sorted(set(guards))

        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

        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:

                fp.write("%s\n" % 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)

        if self.added:

            qrepo = self.qrepo()

            if qrepo:

                qrepo[None].add(f for f in self.added if f not in qrepo[None])

            self.added = []

    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, diffopts, node1, node2=None, files=None,

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

        stat = opts.get('stat')

        m = cmdutil.match(repo, files, opts)

        cmdutil.diffordiffstat(self.ui, repo, diffopts, node1, node2,  m,

                               changes, stat, fp)

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

        # first try just applying the patch

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

                              strict=True, merge=rev)

        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)

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

        ctx = repo[rev]

        ret = hg.merge(repo, rev)

        if ret:

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

        n = repo.commit(ctx.description(), ctx.user(), force=True)

        if n is None:

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

        try:

            ph = patchheader(mergeq.join(patch), self.plainmode)

        except:

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