# 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 os

from .i18n import _

from .node import (

    hex,

    nullid,

)

from . import (

    error,

    match as matchmod,

    merge as mergemod,

    mergestate as mergestatemod,

    pathutil,

    pycompat,

    scmutil,

    util,

)

from .utils import hashutil

# 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

    for line in raw.split(b'\n'):

        line = line.strip()

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

            # empty or comment line, skip

            continue

        elif line.startswith(b'%include '):

            line = line[9:].strip()

            if line:

                profiles.add(line)

        elif line == b'[include]':

            if havesection and current != includes:

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

                raise error.Abort(

                    _(

                        b'%(action)s config cannot have includes '

                        b'after excludes'

                    )

                    % {b'action': action}

                )

            havesection = True

            current = includes

            continue

        elif line == b'[exclude]':

            havesection = True

            current = excludes

        elif line:

            if current is None:

                raise error.Abort(

                    _(

                        b'%(action)s config entry outside of '

                        b'section: %(line)s'

                    )

                    % {b'action': action, b'line': line},

                    hint=_(

                        b'add an [include] or [exclude] line '

                        b'to declare the entry type'

                    ),

                )

            if line.strip().startswith(b'/'):

                ui.warn(

                    _(

                        b'warning: %(action)s profile cannot use'

                        b' paths starting with /, ignoring %(line)s\n'

                    )

                    % {b'action': action, b'line': line}

                )

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

    raw = repo.vfs.tryread(b'sparse')

    if not raw:

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

    if rev is None:

        raise error.Abort(

            _(b'cannot parse sparse patterns from working directory')

        )

    includes, excludes, profiles = parseconfig(repo.ui, raw, b'sparse')

    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 = (

                    b"warning: sparse profile '%s' not found "

                    b"in rev %s - ignoring it\n" % (profile, ctx)

                )

                # experimental config: sparse.missingwarning

                if repo.ui.configbool(b'sparse', b'missingwarning'):

                    repo.ui.warn(msg)

                else:

                    repo.ui.debug(msg)

                continue

            pincludes, pexcludes, subprofs = parseconfig(

                repo.ui, raw, b'sparse'

            )

            includes.update(pincludes)

            excludes.update(pexcludes)

            profiles.update(subprofs)

        profiles = visited

    if includes:

        includes.add(b'.hg*')

    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

    signature = cache.get(b'signature')

    if includetemp:

        tempsignature = cache.get(b'tempsignature')

    else:

        tempsignature = b'0'

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

        signature = hex(hashutil.sha1(repo.vfs.tryread(b'sparse')).digest())

        cache[b'signature'] = signature

        if includetemp:

            raw = repo.vfs.tryread(b'tempsparse')

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

            cache[b'tempsignature'] = tempsignature

    return b'%s %s' % (signature, tempsignature)

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

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

    with repo.vfs(b'sparse', b'wb') as fh:

        for p in sorted(profiles):

            fh.write(b'%%include %s\n' % p)

        if includes:

            fh.write(b'[include]\n')

            for i in sorted(includes):

                fh.write(i)

                fh.write(b'\n')

        if excludes:

            fh.write(b'[exclude]\n')

            for e in sorted(excludes):

                fh.write(e)

                fh.write(b'\n')

    repo._sparsesignaturecache.clear()

def readtemporaryincludes(repo):

    raw = repo.vfs.tryread(b'tempsparse')

    if not raw:

        return set()

    return set(raw.split(b'\n'))

def writetemporaryincludes(repo, includes):

    repo.vfs.write(b'tempsparse', b'\n'.join(sorted(includes)))

    repo._sparsesignaturecache.clear()

def addtemporaryincludes(repo, additional):

    includes = readtemporaryincludes(repo)

    for i in additional:

        includes.add(i)

    writetemporaryincludes(repo, includes)

def prunetemporaryincludes(repo):

    if not enabled or not repo.vfs.exists(b'tempsparse'):

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

            message = _(b'dropping temporarily included sparse files')

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

            dropped.append(file)

    typeactions = mergemod.emptyactions()

    typeactions[b'r'] = actions

    mergemod.applyupdates(

        repo, typeactions, repo[None], repo[b'.'], False, wantfiledata=False

    )

    # Fix dirstate

    for file in dropped:

        dirstate.drop(file)

    repo.vfs.unlink(b'tempsparse')

    repo._sparsesignaturecache.clear()

    msg = _(

        b'cleaned up %d temporarily added file(s) from the '

        b'sparse checkout\n'

    )

    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."""

    kindpats = [(b'path', include, b'') for include in includes]

    includematcher = matchmod.includematcher(b'', kindpats)

    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)

    key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs)))

    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,

                    b'',

                    [],

                    include=includes,

                    exclude=excludes,

                    default=b'relpath',

                )

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

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

    if not enabled:

        return

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

    oldsparsematch = matcher(repo, oldrevs)

    if oldsparsematch.always():

        return

    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