# narrowcommands.py - command modifications for narrowhg extension

#

# Copyright 2017 Google, 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 itertools

import os

from mercurial.i18n import _

from mercurial import (

    bundle2,

    cmdutil,

    commands,

    discovery,

    encoding,

    error,

    exchange,

    extensions,

    hg,

    narrowspec,

    node,

    pycompat,

    registrar,

    repair,

    repoview,

    sparse,

    util,

    wireprototypes,

)

table = {}

command = registrar.command(table)

def setup():

    """Wraps user-facing mercurial commands with narrow-aware versions."""

    entry = extensions.wrapcommand(commands.table, 'clone', clonenarrowcmd)

    # TODO(durin42): unify sparse/narrow --include/--exclude logic a bit

    if 'sparse' not in extensions.enabled():

        entry[1].append(

    entry = extensions.wrapcommand(commands.table, 'pull', pullnarrowcmd)

    extensions.wrapcommand(commands.table, 'archive', archivenarrowcmd)

def clonenarrowcmd(orig, ui, repo, *args, **opts):

    """Wraps clone command, so 'hg clone' first wraps localrepo.clone()."""

    opts = pycompat.byteskwargs(opts)

    wrappedextraprepare = util.nullcontextmanager()

    narrowspecfile = opts['narrowspec']

    if narrowspecfile:

        filepath = os.path.join(encoding.getcwd(), narrowspecfile)

        ui.status(_("reading narrowspec from '%s'\n") % filepath)

        try:

            fdata = util.readfile(filepath)

        except IOError as inst:

        includes, excludes, profiles = sparse.parseconfig(ui, fdata, 'narrow')

        if profiles:

        narrowspec.validatepatterns(includes)

        narrowspec.validatepatterns(excludes)

        # narrowspec is passed so we should assume that user wants narrow clone

        opts['narrow'] = True

        opts['include'].extend(includes)

        opts['exclude'].extend(excludes)

    if opts['narrow']:

        def pullbundle2extraprepare_widen(orig, pullop, kwargs):

            orig(pullop, kwargs)

            if opts.get('depth'):

                kwargs['depth'] = opts['depth']

    with wrappedextraprepare:

        return orig(ui, repo, *args, **pycompat.strkwargs(opts))

def pullnarrowcmd(orig, ui, repo, *args, **opts):

    """Wraps pull command to allow modifying narrow spec."""

    wrappedextraprepare = util.nullcontextmanager()

    if repository.NARROW_REQUIREMENT in repo.requirements:

        def pullbundle2extraprepare_widen(orig, pullop, kwargs):

            orig(pullop, kwargs)

            if opts.get(r'depth'):

                kwargs['depth'] = opts[r'depth']

    with wrappedextraprepare:

        return orig(ui, repo, *args, **opts)

def archivenarrowcmd(orig, ui, repo, *args, **opts):

    """Wraps archive command to narrow the default includes."""

    if repository.NARROW_REQUIREMENT in repo.requirements:

        repo_includes, repo_excludes = repo.narrowpats

        includes = set(opts.get(r'include', []))

        excludes = set(opts.get(r'exclude', []))

        includes, excludes, unused_invalid = narrowspec.restrictpatterns(

        if includes:

            opts[r'include'] = includes

        if excludes:

            opts[r'exclude'] = excludes

    return orig(ui, repo, *args, **opts)

def pullbundle2extraprepare(orig, pullop, kwargs):

    repo = pullop.repo

    if repository.NARROW_REQUIREMENT not in repo.requirements:

        return orig(pullop, kwargs)

    if wireprototypes.NARROWCAP not in pullop.remote.capabilities():

        raise error.Abort(_("server does not support narrow clones"))

    orig(pullop, kwargs)

    kwargs['narrow'] = True

    include, exclude = repo.narrowpats

    kwargs['oldincludepats'] = include

    kwargs['oldexcludepats'] = exclude

    if include:

        kwargs['includepats'] = include

    if exclude:

        kwargs['excludepats'] = exclude

    # calculate known nodes only in ellipses cases because in non-ellipses cases

    # we have all the nodes

    if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():

        if not kwargs['known']:

            # Mercurial serializes an empty list as '' and deserializes it as

            # [''], so delete it instead to avoid handling the empty string on

            # the server.

            del kwargs['known']

    oldmatch = narrowspec.match(repo.root, oldincludes, oldexcludes)

    newmatch = narrowspec.match(repo.root, newincludes, newexcludes)

    # This is essentially doing "hg outgoing" to find all local-only

    # commits. We will then check that the local-only commits don't

    # have any changes to files that will be untracked.

    unfi = repo.unfiltered()

    ui.status(_('looking for local changes to affected paths\n'))

    localnodes = []

    for n in itertools.chain(outgoing.missing, outgoing.excluded):

        if any(oldmatch(f) and not newmatch(f) for f in unfi[n].files()):

            localnodes.append(n)

    revstostrip = unfi.revs('descendants(%ln)', localnodes)

    hiddenrevs = repoview.filterrevs(repo, 'visible')

    if visibletostrip:

        maxnodes = 10

        if ui.verbose or len(visibletostrip) <= maxnodes:

            for n in visibletostrip:

                ui.status('%s\n' % node.short(n))

        else:

            for n in visibletostrip[:maxnodes]:

                ui.status('%s\n' % node.short(n))

        if not force:

    with ui.uninterruptible():

        if revstostrip:

            tostrip = [unfi.changelog.node(r) for r in revstostrip]

            if repo['.'].node() in tostrip:

                # stripping working copy, so move to a different commit first

                hg.clean(repo, urev)

            overrides = {('devel', 'strip-obsmarkers'): False}

            with ui.configoverride(overrides, 'narrow'):

                repair.strip(ui, unfi, tostrip, topic='narrow')

        todelete = []

        for f, f2, size in repo.store.datafiles():

            if f.startswith('data/'):

                file = f[5:-2]

                if not newmatch(file):

                    todelete.append(f)

            elif f.startswith('meta/'):

                dir = f[5:-13]

                dirs = sorted(util.dirs({dir})) + [dir]

                include = True

                for d in dirs:

                    visit = newmatch.visitdir(d)

                    if not visit:

                        include = False

                        break

                    if visit == 'all':

                        break

                if not include:

                    todelete.append(f)

        repo.destroying()

        with repo.transaction('narrowing'):

            # Update narrowspec before removing revlogs, so repo won't be

            # corrupt in case of crash

            repo.setnarrowpats(newincludes, newexcludes)

            for f in todelete:

                ui.status(_('deleting %s\n') % f)

                util.unlinkpath(repo.svfs.join(f))

                repo.store.markremoved(f)

            narrowspec.updateworkingcopy(repo, assumeclean=True)

            narrowspec.copytoworkingcopy(repo)

        repo.destroyed()

    # for now we assume that if a server has ellipses enabled, we will be

    # exchanging ellipses nodes. In future we should add ellipses as a client

    # side requirement (maybe) to distinguish a client is shallow or not and

    # then send that information to server whether we want ellipses or not.

    # Theoretically a non-ellipses repo should be able to use narrow

    # functionality from an ellipses enabled server

    remotecap = remote.capabilities()

    # check whether we are talking to a server which supports old version of

    # ellipses capabilities

    def pullbundle2extraprepare_widen(orig, pullop, kwargs):

        orig(pullop, kwargs)

        # The old{in,ex}cludepats have already been set by orig()

        kwargs['includepats'] = newincludes

        kwargs['excludepats'] = newexcludes

    # define a function that narrowbundle2 can call after creating the

    # backup bundle, but before applying the bundle from the server

    def setnewnarrowpats():

        repo.setnarrowpats(newincludes, newexcludes)

    repo.setnewnarrowpats = setnewnarrowpats

    # silence the devel-warning of applying an empty changegroup

    overrides = {('devel', 'all-warnings'): False}

    common = commoninc[0]

    with ui.uninterruptible():

        if ellipsesremote:

            ds = repo.dirstate

            p1, p2 = ds.p1(), ds.p2()

            with ds.parentchange():

                ds.setparents(node.nullid, node.nullid)

        if isoldellipses:

            with wrappedextraprepare:

                exchange.pull(repo, remote, heads=common)

        else:

            known = []

            if ellipsesremote:

            with remote.commandexecutor() as e:

            trmanager = exchange.transactionmanager(repo, 'widen', remote.url())

            with trmanager, repo.ui.configoverride(overrides, 'widen'):