# record.py

#

# Copyright 2007 Bryan O'Sullivan <bos@serpentine.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''commands to interactively select changes for commit/qrefresh'''

from mercurial.i18n import _

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

from mercurial import util

import copy, cStringIO, errno, os, re, shutil, tempfile

cmdtable = {}

command = cmdutil.command(cmdtable)

testedwith = 'internal'

lines_re = re.compile(r'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')

def scanpatch(fp):

    """like patch.iterhunks, but yield different events

    - ('file',    [header_lines + fromfile + tofile])

    - ('context', [context_lines])

    - ('hunk',    [hunk_lines])

    - ('range',   (-start,len, +start,len, proc))

    """

    lr = patch.linereader(fp)

    def scanwhile(first, p):

        """scan lr while predicate holds"""

        lines = [first]

        while True:

            line = lr.readline()

            if not line:

                break

            if p(line):

                lines.append(line)

            else:

                lr.push(line)

                break

        return lines

    while True:

        line = lr.readline()

        if not line:

            break

        if line.startswith('diff --git a/') or line.startswith('diff -r '):

            def notheader(line):

                s = line.split(None, 1)

                return not s or s[0] not in ('---', 'diff')

            header = scanwhile(line, notheader)

            fromfile = lr.readline()

            if fromfile.startswith('---'):

                tofile = lr.readline()

                header += [fromfile, tofile]

            else:

                lr.push(fromfile)

            yield 'file', header

        elif line[0] == ' ':

            yield 'context', scanwhile(line, lambda l: l[0] in ' \\')

        elif line[0] in '-+':

            yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')

        else:

            m = lines_re.match(line)

            if m:

                yield 'range', m.groups()

            else:

                yield 'other', line

def countchanges(hunk):

    """hunk -> (n+,n-)"""

    add = len([h for h in hunk if h[0] == '+'])

    rem = len([h for h in hunk if h[0] == '-'])

    return add, rem

class hunk(object):

    """patch hunk

    XXX shouldn't we merge this with patch.hunk ?

    """

    maxcontext = 3

    def __init__(self, header, fromline, toline, proc, before, hunk, after):

        def trimcontext(number, lines):

            delta = len(lines) - self.maxcontext

            if False and delta > 0:

                return number + delta, lines[:self.maxcontext]

            return number, lines

        self.header = header

        self.fromline, self.before = trimcontext(fromline, before)

        self.toline, self.after = trimcontext(toline, after)

        self.proc = proc

        self.hunk = hunk

        self.added, self.removed = countchanges(self.hunk)

    def write(self, fp):

        delta = len(self.before) + len(self.after)

        if self.after and self.after[-1] == '\\ No newline at end of file\n':

            delta -= 1

        fromlen = delta + self.removed

        tolen = delta + self.added

        fp.write('@@ -%d,%d +%d,%d @@%s\n' %

                 (self.fromline, fromlen, self.toline, tolen,

                  self.proc and (' ' + self.proc)))

        fp.write(''.join(self.before + self.hunk + self.after))

    pretty = write

    def filename(self):

        return self.header.filename()

    def __repr__(self):

        return '<hunk %r@%d>' % (self.filename(), self.fromline)

def parsepatch(fp):

    """patch -> [] of headers -> [] of hunks """

    class parser(object):

        """patch parsing state machine"""

        def __init__(self):

            self.fromline = 0

            self.toline = 0

            self.proc = ''

            self.header = None

            self.context = []

            self.before = []

            self.hunk = []

            self.headers = []

        def addrange(self, limits):

            fromstart, fromend, tostart, toend, proc = limits

            self.fromline = int(fromstart)

            self.toline = int(tostart)

            self.proc = proc

        def addcontext(self, context):

            if self.hunk:

                h = hunk(self.header, self.fromline, self.toline, self.proc,

                         self.before, self.hunk, context)

                self.header.hunks.append(h)

                self.fromline += len(self.before) + h.removed

                self.toline += len(self.before) + h.added

                self.before = []

                self.hunk = []

                self.proc = ''

            self.context = context

        def addhunk(self, hunk):

            if self.context:

                self.before = self.context

                self.context = []

            self.hunk = hunk

        def newfile(self, hdr):

            self.addcontext([])

            self.headers.append(h)

            self.header = h

        def addother(self, line):

            pass # 'other' lines are ignored

        def finished(self):

            self.addcontext([])

            return self.headers

        transitions = {

            'file': {'context': addcontext,

                     'file': newfile,

                     'hunk': addhunk,

                     'range': addrange},

            'context': {'file': newfile,

                        'hunk': addhunk,

                        'range': addrange,

                        'other': addother},

            'hunk': {'context': addcontext,

                     'file': newfile,

                     'range': addrange},

            'range': {'context': addcontext,

                      'hunk': addhunk},

            'other': {'other': addother},

            }

    p = parser()

    state = 'context'

    for newstate, data in scanpatch(fp):

        try:

            p.transitions[state][newstate](p, data)

        except KeyError:

            raise patch.PatchError('unhandled transition: %s -> %s' %

                                   (state, newstate))

        state = newstate

    return p.finished()

def filterpatch(ui, headers):

    """Interactively filter patch chunks into applied-only chunks"""

    def prompt(skipfile, skipall, query, chunk):

        """prompt query, and process base inputs

        - y/n for the rest of file

        - y/n for the rest

        - ? (help)

        - q (quit)

        Return True/False and possibly updated skipfile and skipall.

        """

        newpatches = None

        if skipall is not None:

            return skipall, skipfile, skipall, newpatches

        if skipfile is not None:

            return skipfile, skipfile, skipall, newpatches

        while True:

            resps = _('[Ynesfdaq?]'

                      '$$ &Yes, record this change'

                      '$$ &No, skip this change'

                      '$$ &Edit this change manually'

                      '$$ &Skip remaining changes to this file'

                      '$$ Record remaining changes to this &file'

                      '$$ &Done, skip remaining changes and files'

                      '$$ Record &all changes to all remaining files'

                      '$$ &Quit, recording no changes'

                      '$$ &? (display help)')

            r = ui.promptchoice("%s %s" % (query, resps))

            ui.write("\n")

            if r == 8: # ?

                for c, t in ui.extractchoices(resps)[1]:

                    ui.write('%s - %s\n' % (c, t.lower()))

                continue

            elif r == 0: # yes

                ret = True

            elif r == 1: # no

                ret = False

            elif r == 2: # Edit patch

                if chunk is None:

                    ui.write(_('cannot edit patch for whole file'))

                    ui.write("\n")

                    continue

                if chunk.header.binary():

                    ui.write(_('cannot edit patch for binary file'))

                    ui.write("\n")

                    continue

                # Patch comment based on the Git one (based on comment at end of

                # http://mercurial.selenic.com/wiki/RecordExtension)

                phelp = '---' + _("""

To remove '-' lines, make them ' ' lines (context).

To remove '+' lines, delete them.

Lines starting with # will be removed from the patch.

If the patch applies cleanly, the edited hunk will immediately be

added to the record list. If it does not apply cleanly, a rejects

file will be generated: you can use that when you try again. If

all lines of the hunk are removed, then the edit is aborted and

the hunk is left unchanged.

""")

                (patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",

                        suffix=".diff", text=True)

                ncpatchfp = None

                try:

                    # Write the initial patch

                    f = os.fdopen(patchfd, "w")

                    chunk.header.write(f)

                    chunk.write(f)

                    f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))

                    f.close()

                    # Start the editor and wait for it to complete

                    editor = ui.geteditor()

                    ui.system("%s \"%s\"" % (editor, patchfn),

                              environ={'HGUSER': ui.username()},

                              onerr=util.Abort, errprefix=_("edit failed"))

                    # Remove comment lines

                    patchfp = open(patchfn)

                    ncpatchfp = cStringIO.StringIO()

                    for line in patchfp:

                        if not line.startswith('#'):

                            ncpatchfp.write(line)

                    patchfp.close()

                    ncpatchfp.seek(0)

                    newpatches = parsepatch(ncpatchfp)

                finally:

                    os.unlink(patchfn)

                    del ncpatchfp

                # Signal that the chunk shouldn't be applied as-is, but

                # provide the new patch to be used instead.

                ret = False

            elif r == 3: # Skip

                ret = skipfile = False

            elif r == 4: # file (Record remaining)

                ret = skipfile = True

            elif r == 5: # done, skip remaining

                ret = skipall = False

            elif r == 6: # all

                ret = skipall = True

            elif r == 7: # quit

                raise util.Abort(_('user quit'))

            return ret, skipfile, skipall, newpatches

    seen = set()

    applied = {}        # 'filename' -> [] of chunks

    skipfile, skipall = None, None

    pos, total = 1, sum(len(h.hunks) for h in headers)

    for h in headers:

        pos += len(h.hunks)

        skipfile = None

        fixoffset = 0

        hdr = ''.join(h.header)

        if hdr in seen:

            continue

        seen.add(hdr)

        if skipall is None:

            h.pretty(ui)

        msg = (_('examine changes to %s?') %

               _(' and ').join("'%s'" % f for f in h.files()))

        r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)

        if not r:

            continue

        applied[h.filename()] = [h]

        if h.allhunks():

            applied[h.filename()] += h.hunks

            continue

        for i, chunk in enumerate(h.hunks):

            if skipfile is None and skipall is None:

                chunk.pretty(ui)

            if total == 1:

                msg = _("record this change to '%s'?") % chunk.filename()

            else:

                idx = pos - len(h.hunks) + i

                msg = _("record change %d/%d to '%s'?") % (idx, total,

                                                           chunk.filename())

            r, skipfile, skipall, newpatches = prompt(skipfile,

                    skipall, msg, chunk)

            if r:

                if fixoffset:

                    chunk = copy.copy(chunk)

                    chunk.toline += fixoffset

                applied[chunk.filename()].append(chunk)

            elif newpatches is not None:

                for newpatch in newpatches:

                    for newhunk in newpatch.hunks:

                        if fixoffset:

                            newhunk.toline += fixoffset

                        applied[newhunk.filename()].append(newhunk)

            else:

                fixoffset += chunk.removed - chunk.added

    return sum([h for h in applied.itervalues()

               if h[0].special() or len(h) > 1], [])

@command("record",

         # same options as commit + white space diff options

         commands.table['^commit|ci'][1][:] + commands.diffwsopts,

          _('hg record [OPTION]... [FILE]...'))

def record(ui, repo, *pats, **opts):

    '''interactively select changes to commit

    If a list of files is omitted, all changes reported by :hg:`status`

    will be candidates for recording.

    See :hg:`help dates` for a list of formats valid for -d/--date.

    You will be prompted for whether to record changes to each

    modified file, and for files with multiple changes, for each

    change to use. For each query, the following responses are

    possible::

      y - record this change

      n - skip this change

      e - edit this change manually

      s - skip remaining changes to this file

      f - record remaining changes to this file

      d - done, skip remaining changes and files