# absorb.py

#

# Copyright 2016 Facebook, Inc.

#

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

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

"""apply working directory changes to changesets (EXPERIMENTAL)

The absorb extension provides a command to use annotate information to

amend modified chunks into the corresponding non-public changesets.

::

    [absorb]

    # only check 50 recent non-public changesets at most

    max-stack-size = 50

    # whether to add noise to new commits to avoid obsolescence cycle

    add-noise = 1

    # make `amend --correlated` a shortcut to the main command

    amend-flag = correlated

    [color]

    absorb.node = blue bold

    absorb.path = bold

"""

# TODO:

#  * Rename config items to [commands] namespace

#  * Converge getdraftstack() with other code in core

#  * move many attributes on fixupstate to be private

from __future__ import absolute_import

import collections

from mercurial.i18n import _

from mercurial import (

    cmdutil,

    commands,

    context,

    crecord,

    error,

    linelog,

    mdiff,

    node,

    obsolete,

    patch,

    phases,

    pycompat,

    registrar,

    repair,

    scmutil,

    util,

)

from mercurial.utils import (

    stringutil,

)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = 'ships-with-hg-core'

cmdtable = {}

command = registrar.command(cmdtable)

configtable = {}

configitem = registrar.configitem(configtable)

configitem('absorb', 'add-noise', default=True)

configitem('absorb', 'amend-flag', default=None)

configitem('absorb', 'max-stack-size', default=50)

colortable = {

    'absorb.node': 'blue bold',

    'absorb.path': 'bold',

}

defaultdict = collections.defaultdict

class nullui(object):

    """blank ui object doing nothing"""

    debugflag = False

    verbose = False

    quiet = True

    def __getitem__(name):

        def nullfunc(*args, **kwds):

            return

        return nullfunc

class emptyfilecontext(object):

    """minimal filecontext representing an empty file"""

    def data(self):

        return ''

    def node(self):

        return node.nullid

def uniq(lst):

    """list -> list. remove duplicated items without changing the order"""

    seen = set()

    result = []

    for x in lst:

        if x not in seen:

            seen.add(x)

            result.append(x)

    return result

def getdraftstack(headctx, limit=None):

    """(ctx, int?) -> [ctx]. get a linear stack of non-public changesets.

    changesets are sorted in topo order, oldest first.

    return at most limit items, if limit is a positive number.

    merges are considered as non-draft as well. i.e. every commit

    returned has and only has 1 parent.

    """

    ctx = headctx

    result = []

    while ctx.phase() != phases.public:

        if limit and len(result) >= limit:

            break

        parents = ctx.parents()

        if len(parents) != 1:

            break

        result.append(ctx)

        ctx = parents[0]

    result.reverse()

    return result

def getfilestack(stack, path, seenfctxs=None):

    """([ctx], str, set) -> [fctx], {ctx: fctx}

    stack is a list of contexts, from old to new. usually they are what

    "getdraftstack" returns.

    follows renames, but not copies.

    seenfctxs is a set of filecontexts that will be considered "immutable".

    they are usually what this function returned in earlier calls, useful

    to avoid issues that a file was "moved" to multiple places and was then

    modified differently, like: "a" was copied to "b", "a" was also copied to

    "c" and then "a" was deleted, then both "b" and "c" were "moved" from "a"

    and we enforce only one of them to be able to affect "a"'s content.

    return an empty list and an empty dict, if the specified path does not

    exist in stack[-1] (the top of the stack).

    otherwise, return a list of de-duplicated filecontexts, and the map to

    convert ctx in the stack to fctx, for possible mutable fctxs. the first item

    of the list would be outside the stack and should be considered immutable.

    the remaining items are within the stack.

    for example, given the following changelog and corresponding filelog

    revisions:

      changelog: 3----4----5----6----7

      filelog:   x    0----1----1----2 (x: no such file yet)

    - if stack = [5, 6, 7], returns ([0, 1, 2], {5: 1, 6: 1, 7: 2})

    - if stack = [3, 4, 5], returns ([e, 0, 1], {4: 0, 5: 1}), where "e" is a

      dummy empty filecontext.

    - if stack = [2], returns ([], {})

    - if stack = [7], returns ([1, 2], {7: 2})

    - if stack = [6, 7], returns ([1, 2], {6: 1, 7: 2}), although {6: 1} can be

      removed, since 1 is immutable.

    """

    if seenfctxs is None:

        seenfctxs = set()

    assert stack

    if path not in stack[-1]:

        return [], {}

    fctxs = []

    fctxmap = {}

    pctx = stack[0].p1() # the public (immutable) ctx we stop at

    for ctx in reversed(stack):

        if path not in ctx: # the file is added in the next commit

            pctx = ctx

            break

        fctx = ctx[path]

        fctxs.append(fctx)

        if fctx in seenfctxs: # treat fctx as the immutable one

            pctx = None # do not add another immutable fctx

            break

        fctxmap[ctx] = fctx # only for mutable fctxs

        renamed = fctx.renamed()

        if renamed:

            path = renamed[0] # follow rename

            if path in ctx: # but do not follow copy

                pctx = ctx.p1()

                break

    if pctx is not None: # need an extra immutable fctx

        if path in pctx:

            fctxs.append(pctx[path])

        else:

            fctxs.append(emptyfilecontext())

    fctxs.reverse()

    # note: we rely on a property of hg: filerev is not reused for linear

    # history. i.e. it's impossible to have:

    #   changelog:  4----5----6 (linear, no merges)

    #   filelog:    1----2----1

    #                         ^ reuse filerev (impossible)

    # because parents are part of the hash. if that's not true, we need to

    # remove uniq and find a different way to identify fctxs.

    return uniq(fctxs), fctxmap

class overlaystore(patch.filestore):

    """read-only, hybrid store based on a dict and ctx.

    memworkingcopy: {path: content}, overrides file contents.

    """

    def __init__(self, basectx, memworkingcopy):

        self.basectx = basectx

        self.memworkingcopy = memworkingcopy

    def getfile(self, path):

        """comply with mercurial.patch.filestore.getfile"""

        if path not in self.basectx:

            return None, None, None

        fctx = self.basectx[path]

        if path in self.memworkingcopy:

            content = self.memworkingcopy[path]

        else:

            content = fctx.data()

        mode = (fctx.islink(), fctx.isexec())

        renamed = fctx.renamed() # False or (path, node)

        return content, mode, (renamed and renamed[0])

def overlaycontext(memworkingcopy, ctx, parents=None, extra=None):

    """({path: content}, ctx, (p1node, p2node)?, {}?) -> memctx

    memworkingcopy overrides file contents.

    """

    # parents must contain 2 items: (node1, node2)

    if parents is None:

        parents = ctx.repo().changelog.parents(ctx.node())

    if extra is None:

        extra = ctx.extra()

    date = ctx.date()

    desc = ctx.description()

    user = ctx.user()

    files = set(ctx.files()).union(memworkingcopy)

    store = overlaystore(ctx, memworkingcopy)

    return context.memctx(

        repo=ctx.repo(), parents=parents, text=desc,

        files=files, filectxfn=store, user=user, date=date,

        branch=None, extra=extra)

class filefixupstate(object):

    """state needed to apply fixups to a single file

    internally, it keeps file contents of several revisions and a linelog.

    the linelog uses odd revision numbers for original contents (fctxs passed

    to __init__), and even revision numbers for fixups, like:

        linelog rev 1: self.fctxs[0] (from an immutable "public" changeset)

        linelog rev 2: fixups made to self.fctxs[0]

        linelog rev 3: self.fctxs[1] (a child of fctxs[0])

        linelog rev 4: fixups made to self.fctxs[1]

        ...

    a typical use is like:

        1. call diffwith, to calculate self.fixups

        2. (optionally), present self.fixups to the user, or change it

        3. call apply, to apply changes

        4. read results from "finalcontents", or call getfinalcontent

    """

        """([fctx], ui or None) -> None

        fctxs should be linear, and sorted by topo order - oldest first.

        fctxs[0] will be considered as "immutable" and will not be changed.

        """

        self.fctxs = fctxs

        self.ui = ui or nullui()

        self.opts = opts or {}

        # following fields are built from fctxs. they exist for perf reason

        self.contents = [f.data() for f in fctxs]

        self.contentlines = pycompat.maplist(mdiff.splitnewlines, self.contents)

        self.linelog = self._buildlinelog()

        if self.ui.debugflag:

            assert self._checkoutlinelog() == self.contents

        # following fields will be filled later

        self.chunkstats = [0, 0] # [adopted, total : int]

        self.targetlines = [] # [str]

        self.fixups = [] # [(linelog rev, a1, a2, b1, b2)]

        self.finalcontents = [] # [str]

        """calculate fixups needed by examining the differences between

        self.fctxs[-1] and targetfctx, chunk by chunk.

        targetfctx is the target state we move towards. we may or may not be

        able to get there because not all modified chunks can be amended into

        a non-public fctx unambiguously.

        call this only once, before apply().

        update self.fixups, self.chunkstats, and self.targetlines.

        """

        a = self.contents[-1]

        alines = self.contentlines[-1]

        b = targetfctx.data()

        blines = mdiff.splitnewlines(b)

        self.targetlines = blines

        self.linelog.annotate(self.linelog.maxrev)

        annotated = self.linelog.annotateresult # [(linelog rev, linenum)]

        assert len(annotated) == len(alines)

        # add a dummy end line to make insertion at the end easier

        if annotated:

            dummyendline = (annotated[-1][0], annotated[-1][1] + 1)

            annotated.append(dummyendline)

        # analyse diff blocks

        for chunk in self._alldiffchunks(a, b, alines, blines):

            newfixups = self._analysediffchunk(chunk, annotated)

            self.chunkstats[0] += bool(newfixups) # 1 or 0

            self.chunkstats[1] += 1

            self.fixups += newfixups

    def apply(self):

        """apply self.fixups. update self.linelog, self.finalcontents.

        call this only once, before getfinalcontent(), after diffwith().

        """

        # the following is unnecessary, as it's done by "diffwith":

        #   self.linelog.annotate(self.linelog.maxrev)

        for rev, a1, a2, b1, b2 in reversed(self.fixups):

            blines = self.targetlines[b1:b2]

            if self.ui.debugflag:

                idx = (max(rev - 1, 0)) // 2

                self.ui.write(_('%s: chunk %d:%d -> %d lines\n')

                              % (node.short(self.fctxs[idx].node()),

                                 a1, a2, len(blines)))

            self.linelog.replacelines(rev, a1, a2, b1, b2)

        if self.opts.get('edit_lines', False):

            self.finalcontents = self._checkoutlinelogwithedits()

        else:

            self.finalcontents = self._checkoutlinelog()

    def getfinalcontent(self, fctx):

        """(fctx) -> str. get modified file content for a given filecontext"""

        idx = self.fctxs.index(fctx)

        return self.finalcontents[idx]

    def _analysediffchunk(self, chunk, annotated):

        """analyse a different chunk and return new fixups found

        return [] if no lines from the chunk can be safely applied.

        the chunk (or lines) cannot be safely applied, if, for example:

          - the modified (deleted) lines belong to a public changeset

            (self.fctxs[0])

          - the chunk is a pure insertion and the adjacent lines (at most 2

            lines) belong to different non-public changesets, or do not belong

            to any non-public changesets.

          - the chunk is modifying lines from different changesets.

            in this case, if the number of lines deleted equals to the number

            of lines added, assume it's a simple 1:1 map (could be wrong).

            otherwise, give up.

          - the chunk is modifying lines from a single non-public changeset,

            but other revisions touch the area as well. i.e. the lines are

            not continuous as seen from the linelog.

        """

        a1, a2, b1, b2 = chunk

        # find involved indexes from annotate result

        involved = annotated[a1:a2]

        if not involved and annotated: # a1 == a2 and a is not empty

            # pure insertion, check nearby lines. ignore lines belong

            # to the public (first) changeset (i.e. annotated[i][0] == 1)

            nearbylinenums = {a2, max(0, a1 - 1)}

            involved = [annotated[i]

                        for i in nearbylinenums if annotated[i][0] != 1]

        involvedrevs = list(set(r for r, l in involved))

        newfixups = []

        if len(involvedrevs) == 1 and self._iscontinuous(a1, a2 - 1, True):

            # chunk belongs to a single revision

            rev = involvedrevs[0]

            if rev > 1:

                fixuprev = rev + 1

                newfixups.append((fixuprev, a1, a2, b1, b2))

        elif a2 - a1 == b2 - b1 or b1 == b2:

            # 1:1 line mapping, or chunk was deleted

            for i in pycompat.xrange(a1, a2):

                rev, linenum = annotated[i]

                if rev > 1:

                    if b1 == b2: # deletion, simply remove that single line

                        nb1 = nb2 = 0

                    else: # 1:1 line mapping, change the corresponding rev

                        nb1 = b1 + i - a1

                        nb2 = nb1 + 1

                    fixuprev = rev + 1

                    newfixups.append((fixuprev, i, i + 1, nb1, nb2))

        return self._optimizefixups(newfixups)

    @staticmethod

    def _alldiffchunks(a, b, alines, blines):

        """like mdiff.allblocks, but only care about differences"""

        blocks = mdiff.allblocks(a, b, lines1=alines, lines2=blines)

        for chunk, btype in blocks:

            if btype != '!':

                continue

            yield chunk

    def _buildlinelog(self):