# obsutil.py - utility functions for obsolescence

#

# Copyright 2017 Boris Feld <boris.feld@octobus.net>

#

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

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

from __future__ import absolute_import

import re

from .i18n import _

from . import (

    diffutil,

    encoding,

    node as nodemod,

    phases,

    pycompat,

    util,

)

from .utils import dateutil

### obsolescence marker flag

## bumpedfix flag

#

# When a changeset A' succeed to a changeset A which became public, we call A'

# "bumped" because it's a successors of a public changesets

#

# o    A' (bumped)

# |`:

# | o  A

# |/

# o    Z

#

# The way to solve this situation is to create a new changeset Ad as children

# of A. This changeset have the same content than A'. So the diff from A to A'

# is the same than the diff from A to Ad. Ad is marked as a successors of A'

#

# o   Ad

# |`:

# | x A'

# |'|

# o | A

# |/

# o Z

#

# But by transitivity Ad is also a successors of A. To avoid having Ad marked

# as bumped too, we add the `bumpedfix` flag to the marker. <A', (Ad,)>.

# This flag mean that the successors express the changes between the public and

# bumped version and fix the situation, breaking the transitivity of

# "bumped" here.

bumpedfix = 1

usingsha256 = 2

class marker(object):

    """Wrap obsolete marker raw data"""

    def __init__(self, repo, data):

        # the repo argument will be used to create changectx in later version

        self._repo = repo

        self._data = data

        self._decodedmeta = None

    def __hash__(self):

        return hash(self._data)

    def __eq__(self, other):

        if type(other) != type(self):

            return False

        return self._data == other._data

    def prednode(self):

        """Predecessor changeset node identifier"""

        return self._data[0]

    def succnodes(self):

        """List of successor changesets node identifiers"""

        return self._data[1]

    def parentnodes(self):

        """Parents of the predecessors (None if not recorded)"""

        return self._data[5]

    def metadata(self):

        """Decoded metadata dictionary"""

        return dict(self._data[3])

    def date(self):

        """Creation date as (unixtime, offset)"""

        return self._data[4]

    def flags(self):

        """The flags field of the marker"""

        return self._data[2]

def getmarkers(repo, nodes=None, exclusive=False):

    """returns markers known in a repository

    If <nodes> is specified, only markers "relevant" to those nodes are are

    returned"""

    if nodes is None:

        rawmarkers = repo.obsstore

    elif exclusive:

        rawmarkers = exclusivemarkers(repo, nodes)

    else:

        rawmarkers = repo.obsstore.relevantmarkers(nodes)

    for markerdata in rawmarkers:

        yield marker(repo, markerdata)

def closestpredecessors(repo, nodeid):

    """yield the list of next predecessors pointing on visible changectx nodes

    This function respect the repoview filtering, filtered revision will be

    considered missing.

    """

    precursors = repo.obsstore.predecessors

    stack = [nodeid]

    seen = set(stack)

    while stack:

        current = stack.pop()

        currentpreccs = precursors.get(current, ())

        for prec in currentpreccs:

            precnodeid = prec[0]

            # Basic cycle protection

            if precnodeid in seen:

                continue

            seen.add(precnodeid)

            if precnodeid in repo:

                yield precnodeid

            else:

                stack.append(precnodeid)

def allpredecessors(obsstore, nodes, ignoreflags=0):

    """Yield node for every precursors of <nodes>.

    Some precursors may be unknown locally.

    This is a linear yield unsuited to detecting folded changesets. It includes

    initial nodes too."""

    remaining = set(nodes)

    seen = set(remaining)

    prec = obsstore.predecessors.get

    while remaining:

        current = remaining.pop()

        yield current

        for mark in prec(current, ()):

            # ignore marker flagged with specified flag

            if mark[2] & ignoreflags:

                continue

            suc = mark[0]

            if suc not in seen:

                seen.add(suc)

                remaining.add(suc)

def allsuccessors(obsstore, nodes, ignoreflags=0):

    """Yield node for every successor of <nodes>.

    Some successors may be unknown locally.

    This is a linear yield unsuited to detecting split changesets. It includes

    initial nodes too."""

    remaining = set(nodes)

    seen = set(remaining)

    while remaining:

        current = remaining.pop()

        yield current

        for mark in obsstore.successors.get(current, ()):

            # ignore marker flagged with specified flag

            if mark[2] & ignoreflags:

                continue

            for suc in mark[1]:

                if suc not in seen:

                    seen.add(suc)

                    remaining.add(suc)

def _filterprunes(markers):

    """return a set with no prune markers"""

    return set(m for m in markers if m[1])

def exclusivemarkers(repo, nodes):

    """set of markers relevant to "nodes" but no other locally-known nodes

    This function compute the set of markers "exclusive" to a locally-known

    node. This means we walk the markers starting from <nodes> until we reach a

    locally-known precursors outside of <nodes>. Element of <nodes> with

    locally-known successors outside of <nodes> are ignored (since their

    precursors markers are also relevant to these successors).

    For example:

        # (A0 rewritten as A1)

        #

        # A0 <-1- A1 # Marker "1" is exclusive to A1

        or

        # (A0 rewritten as AX; AX rewritten as A1; AX is unkown locally)

        #

        # <-1- A0 <-2- AX <-3- A1 # Marker "2,3" are exclusive to A1

        or

        # (A0 has unknown precursors, A0 rewritten as A1 and A2 (divergence))

        #

        #          <-2- A1 # Marker "2" is exclusive to A0,A1

        #        /

        # <-1- A0

        #        \

        #         <-3- A2 # Marker "3" is exclusive to A0,A2

        #

        # in addition:

        #

        #  Markers "2,3" are exclusive to A1,A2

        #  Markers "1,2,3" are exclusive to A0,A1,A2

        See test/test-obsolete-bundle-strip.t for more examples.

    An example usage is strip. When stripping a changeset, we also want to

    strip the markers exclusive to this changeset. Otherwise we would have

    "dangling"" obsolescence markers from its precursors: Obsolescence markers

    marking a node as obsolete without any successors available locally.

    As for relevant markers, the prune markers for children will be followed.

    Of course, they will only be followed if the pruned children is

    locally-known. Since the prune markers are relevant to the pruned node.

    However, while prune markers are considered relevant to the parent of the

    pruned changesets, prune markers for locally-known changeset (with no

    successors) are considered exclusive to the pruned nodes. This allows

    to strip the prune markers (with the rest of the exclusive chain) alongside

    the pruned changesets.

    """

    # running on a filtered repository would be dangerous as markers could be

    # reported as exclusive when they are relevant for other filtered nodes.

    unfi = repo.unfiltered()

    # shortcut to various useful item

    has_node = unfi.changelog.index.has_node

    precursorsmarkers = unfi.obsstore.predecessors

    successormarkers = unfi.obsstore.successors

    childrenmarkers = unfi.obsstore.children

    # exclusive markers (return of the function)

    exclmarkers = set()

    # we need fast membership testing

    nodes = set(nodes)

    # looking for head in the obshistory

    #

    # XXX we are ignoring all issues in regard with cycle for now.

    stack = [n for n in nodes if not _filterprunes(successormarkers.get(n, ()))]

    stack.sort()

    # nodes already stacked

    seennodes = set(stack)

    while stack:

        current = stack.pop()

        # fetch precursors markers

        markers = list(precursorsmarkers.get(current, ()))

        # extend the list with prune markers

        for mark in successormarkers.get(current, ()):

            if not mark[1]:

                markers.append(mark)

        # and markers from children (looking for prune)

        for mark in childrenmarkers.get(current, ()):

            if not mark[1]:

                markers.append(mark)

        # traverse the markers

        for mark in markers:

            if mark in exclmarkers:

                # markers already selected

                continue

            # If the markers is about the current node, select it

            #

            # (this delay the addition of markers from children)

            if mark[1] or mark[0] == current:

                exclmarkers.add(mark)

            # should we keep traversing through the precursors?

            prec = mark[0]

            # nodes in the stack or already processed

            if prec in seennodes:

                continue

            # is this a locally known node ?

            known = has_node(prec)

            # if locally-known and not in the <nodes> set the traversal

            # stop here.

            if known and prec not in nodes:

                continue

            # do not keep going if there are unselected markers pointing to this

            # nodes. If we end up traversing these unselected markers later the

            # node will be taken care of at that point.

            precmarkers = _filterprunes(successormarkers.get(prec))

            if precmarkers.issubset(exclmarkers):

                seennodes.add(prec)

                stack.append(prec)

    return exclmarkers

def foreground(repo, nodes):

    """return all nodes in the "foreground" of other node

    The foreground of a revision is anything reachable using parent -> children

    or precursor -> successor relation. It is very similar to "descendant" but

    augmented with obsolescence information.

    Beware that possible obsolescence cycle may result if complex situation.

    """

    repo = repo.unfiltered()

    foreground = set(repo.set(b'%ln::', nodes))

    if repo.obsstore:

        # We only need this complicated logic if there is obsolescence

        # XXX will probably deserve an optimised revset.

        has_node = repo.changelog.index.has_node

        plen = -1

        # compute the whole set of successors or descendants

        while len(foreground) != plen:

            plen = len(foreground)

            succs = set(c.node() for c in foreground)

            mutable = [c.node() for c in foreground if c.mutable()]

            succs.update(allsuccessors(repo.obsstore, mutable))

            known = (n for n in succs if has_node(n))

            foreground = set(repo.set(b'%ln::', known))

    return set(c.node() for c in foreground)

# effectflag field

#

# Effect-flag is a 1-byte bit field used to store what changed between a

# changeset and its successor(s).

#

# The effect flag is stored in obs-markers metadata while we iterate on the

# information design. That's why we have the EFFECTFLAGFIELD. If we come up

# with an incompatible design for effect flag, we can store a new design under

# another field name so we don't break readers. We plan to extend the existing

# obsmarkers bit-field when the effect flag design will be stabilized.

#

# The effect-flag is placed behind an experimental flag

# `effect-flags` set to off by default.

#

EFFECTFLAGFIELD = b"ef1"

DESCCHANGED = 1 << 0  # action changed the description

METACHANGED = 1 << 1  # action change the meta

DIFFCHANGED = 1 << 3  # action change diff introduced by the changeset

PARENTCHANGED = 1 << 2  # action change the parent

USERCHANGED = 1 << 4  # the user changed

DATECHANGED = 1 << 5  # the date changed

BRANCHCHANGED = 1 << 6  # the branch changed

METABLACKLIST = [

    re.compile(b'^branch$'),

    re.compile(b'^.*-source$'),

    re.compile(b'^.*_source$'),

    re.compile(b'^source$'),

]

def metanotblacklisted(metaitem):

    """ Check that the key of a meta item (extrakey, extravalue) does not

    match at least one of the blacklist pattern

    """

    metakey = metaitem[0]

    return not any(pattern.match(metakey) for pattern in METABLACKLIST)

def _prepare_hunk(hunk):

    """Drop all information but the username and patch"""

    cleanhunk = []

    for line in hunk.splitlines():

        if line.startswith(b'# User') or not line.startswith(b'#'):

            if line.startswith(b'@@'):

                line = b'@@\n'

            cleanhunk.append(line)

    return cleanhunk

def _getdifflines(iterdiff):

    """return a cleaned up lines"""

    lines = next(iterdiff, None)

    if lines is None:

        return lines

    return _prepare_hunk(lines)

def _cmpdiff(leftctx, rightctx):

    """return True if both ctx introduce the "same diff"

    This is a first and basic implementation, with many shortcoming.

    """

    diffopts = diffutil.diffallopts(leftctx.repo().ui, {b'git': True})

    # Leftctx or right ctx might be filtered, so we need to use the contexts

    # with an unfiltered repository to safely compute the diff