# sparse.py - functionality for sparse checkouts

#

# Copyright 2014 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.

from __future__ import absolute_import

import hashlib

import os

from .i18n import _

from .node import (

    hex,

    nullid,

)

from . import (

    error,

    match as matchmod,

    merge as mergemod,

    pathutil,

    pycompat,

    scmutil,

    util,

)

# Whether sparse features are enabled. This variable is intended to be

# temporary to facilitate porting sparse to core. It should eventually be

# a per-repo option, possibly a repo requirement.

enabled = False

def parseconfig(ui, raw, action):

    """Parse sparse config file content.

    action is the command which is trigerring this read, can be narrow, sparse

    Returns a tuple of includes, excludes, and profiles.

    """

    includes = set()

    excludes = set()

    profiles = set()

    current = None

    havesection = False

        line = line.strip()

            # empty or comment line, skip

            continue

            line = line[9:].strip()

            if line:

                profiles.add(line)

            if havesection and current != includes:

                # TODO pass filename into this API so we can report it.

                raise error.Abort(

                    _(

                    )

                )

            havesection = True

            current = includes

            continue

            havesection = True

            current = excludes

        elif line:

            if current is None:

                raise error.Abort(

                    hint=_(

                    ),

                )

                ui.warn(

                    _(

                    )

                )

                continue

            current.add(line)

    return includes, excludes, profiles

# Exists as separate function to facilitate monkeypatching.

def readprofile(repo, profile, changeid):

    """Resolve the raw content of a sparse profile file."""

    # TODO add some kind of cache here because this incurs a manifest

    # resolve and can be slow.

    return repo.filectx(profile, changeid=changeid).data()

def patternsforrev(repo, rev):

    """Obtain sparse checkout patterns for the given rev.

    Returns a tuple of iterables representing includes, excludes, and

    patterns.

    """

    # Feature isn't enabled. No-op.

    if not enabled:

        return set(), set(), set()

    if not raw:

        return set(), set(), set()

    if rev is None:

        raise error.Abort(

        )

    ctx = repo[rev]

    if profiles:

        visited = set()

        while profiles:

            profile = profiles.pop()

            if profile in visited:

                continue

            visited.add(profile)

            try:

                raw = readprofile(repo, profile, rev)

            except error.ManifestLookupError:

                msg = (

                )

                # experimental config: sparse.missingwarning

                    repo.ui.warn(msg)

                else:

                    repo.ui.debug(msg)

                continue

            includes.update(pincludes)

            excludes.update(pexcludes)

            profiles.update(subprofs)

        profiles = visited

    if includes:

    return includes, excludes, profiles

def activeconfig(repo):

    """Determine the active sparse config rules.

    Rules are constructed by reading the current sparse config and bringing in

    referenced profiles from parents of the working directory.

    """

    revs = [

        repo.changelog.rev(node)

        for node in repo.dirstate.parents()

        if node != nullid

    ]

    allincludes = set()

    allexcludes = set()

    allprofiles = set()

    for rev in revs:

        includes, excludes, profiles = patternsforrev(repo, rev)

        allincludes |= includes

        allexcludes |= excludes

        allprofiles |= profiles

    return allincludes, allexcludes, allprofiles

def configsignature(repo, includetemp=True):

    """Obtain the signature string for the current sparse configuration.

    This is used to construct a cache key for matchers.

    """

    cache = repo._sparsesignaturecache

    if includetemp:

    else:

    if signature is None or (includetemp and tempsignature is None):

        if includetemp:

            tempsignature = hex(hashlib.sha1(raw).digest())

def writeconfig(repo, includes, excludes, profiles):

    """Write the sparse config file given a sparse configuration."""

        for p in sorted(profiles):

        if includes:

            for i in sorted(includes):

                fh.write(i)

        if excludes:

            for e in sorted(excludes):

                fh.write(e)

    repo._sparsesignaturecache.clear()

def readtemporaryincludes(repo):

    if not raw:

        return set()

def writetemporaryincludes(repo, includes):

    repo._sparsesignaturecache.clear()

def addtemporaryincludes(repo, additional):

    includes = readtemporaryincludes(repo)

    for i in additional:

        includes.add(i)

    writetemporaryincludes(repo, includes)

def prunetemporaryincludes(repo):

        return

    s = repo.status()

    if s.modified or s.added or s.removed or s.deleted:

        # Still have pending changes. Don't bother trying to prune.

        return

    sparsematch = matcher(repo, includetemp=False)

    dirstate = repo.dirstate

    actions = []

    dropped = []

    tempincludes = readtemporaryincludes(repo)

    for file in tempincludes:

        if file in dirstate and not sparsematch(file):

            actions.append((file, None, message))

            dropped.append(file)

    typeactions = mergemod.emptyactions()

    mergemod.applyupdates(

    )

    # Fix dirstate

    for file in dropped:

        dirstate.drop(file)

    repo._sparsesignaturecache.clear()

    msg = _(

    )

    repo.ui.status(msg % len(tempincludes))

def forceincludematcher(matcher, includes):

    """Returns a matcher that returns true for any of the forced includes

    before testing against the actual matcher."""

    return matchmod.unionmatcher([includematcher, matcher])

def matcher(repo, revs=None, includetemp=True):

    """Obtain a matcher for sparse working directories for the given revs.

    If multiple revisions are specified, the matcher is the union of all

    revs.

    ``includetemp`` indicates whether to use the temporary sparse profile.

    """

    # If sparse isn't enabled, sparse matcher matches everything.

    if not enabled:

        return matchmod.always()

    if not revs or revs == [None]:

        revs = [

            repo.changelog.rev(node)

            for node in repo.dirstate.parents()

            if node != nullid

        ]

    signature = configsignature(repo, includetemp=includetemp)

    result = repo._sparsematchercache.get(key)

    if result:

        return result

    matchers = []

    for rev in revs:

        try:

            includes, excludes, profiles = patternsforrev(repo, rev)

            if includes or excludes:

                matcher = matchmod.match(

                    repo.root,

                    [],

                    include=includes,

                    exclude=excludes,

                )

                matchers.append(matcher)

        except IOError:

            pass

    if not matchers:

        result = matchmod.always()

    elif len(matchers) == 1:

        result = matchers[0]

    else:

        result = matchmod.unionmatcher(matchers)

    if includetemp:

        tempincludes = readtemporaryincludes(repo)

        result = forceincludematcher(result, tempincludes)

    repo._sparsematchercache[key] = result

    return result

def filterupdatesactions(repo, wctx, mctx, branchmerge, actions):

    """Filter updates to only lay out files that match the sparse rules."""

    if not enabled:

        return actions

    oldrevs = [pctx.rev() for pctx in wctx.parents()]

    oldsparsematch = matcher(repo, oldrevs)

    if oldsparsematch.always():

        return actions

    files = set()

    prunedactions = {}

    if branchmerge:

        # If we're merging, use the wctx filter, since we're merging into

        # the wctx.

        sparsematch = matcher(repo, [wctx.p1().rev()])

    else:

        # If we're updating, use the target context's filter, since we're

        # moving to the target context.