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

import itertools

import os

from mercurial.i18n import _

from mercurial.node import (

    hex,

    short,

)

from mercurial import (

    bundle2,

    cmdutil,

    commands,

    discovery,

    encoding,

    error,

    exchange,

    extensions,

    hg,

    narrowspec,

    pathutil,

    pycompat,

    registrar,

    repair,

    repoview,

    requirements,

    sparse,

    util,

    wireprototypes,

)

from mercurial.utils import (

    urlutil,

)

table = {}

command = registrar.command(table)

def setup():

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

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

    entry[1].append(

        (b'', b'narrow', None, _(b"create a narrow clone of select files"))

    )

    entry[1].append(

        (

            b'',

            b'depth',

            b'',

            _(b"limit the history fetched by distance from heads"),

        )

    )

    entry[1].append((b'', b'narrowspec', b'', _(b"read narrowspecs from file")))

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

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

        entry[1].append(

            (b'', b'include', [], _(b"specifically fetch this file/directory"))

        )

        entry[1].append(

            (

                b'',

                b'exclude',

                [],

                _(b"do not fetch this file/directory, even if included"),

            )

        )

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

    entry[1].append(

        (

            b'',

            b'depth',

            b'',

            _(b"limit the history fetched by distance from heads"),

        )

    )

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

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

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

    wrappedextraprepare = util.nullcontextmanager()

    narrowspecfile = opts['narrowspec']

    if narrowspecfile:

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

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

        try:

            fdata = util.readfile(filepath)

        except IOError as inst:

            raise error.Abort(

                _(b"cannot read narrowspecs from '%s': %s")

                % (filepath, encoding.strtolocal(inst.strerror))

            )

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

        if profiles:

            raise error.ConfigError(

                _(

                    b"cannot specify other files using '%include' in"

                    b" narrowspec"

                )

            )

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

                # TODO: fix exchange._pullbundle2extraprepare()

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

        wrappedextraprepare = extensions.wrappedfunction(

            exchange, '_pullbundle2extraprepare', pullbundle2extraprepare_widen

        )

    with wrappedextraprepare:

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

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

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

    wrappedextraprepare = util.nullcontextmanager()

    if requirements.NARROW_REQUIREMENT in repo.requirements:

        def pullbundle2extraprepare_widen(orig, pullop, kwargs):

            orig(pullop, kwargs)

            if opts.get('depth'):

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

        wrappedextraprepare = extensions.wrappedfunction(

            exchange, '_pullbundle2extraprepare', pullbundle2extraprepare_widen

        )

    with wrappedextraprepare:

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

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

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

    if requirements.NARROW_REQUIREMENT in repo.requirements:

        repo_includes, repo_excludes = repo.narrowpats

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

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

        includes, excludes, unused_invalid = narrowspec.restrictpatterns(

            includes, excludes, repo_includes, repo_excludes

        )

        if includes:

            opts['include'] = includes

        if excludes:

            opts['exclude'] = excludes

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

def pullbundle2extraprepare(orig, pullop, kwargs):

    repo = pullop.repo

    if requirements.NARROW_REQUIREMENT not in repo.requirements:

        return orig(pullop, kwargs)

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

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

    orig(pullop, kwargs)

    kwargs[b'narrow'] = True

    include, exclude = repo.narrowpats

    kwargs[b'oldincludepats'] = include

    kwargs[b'oldexcludepats'] = exclude

    if include:

        kwargs[b'includepats'] = include

    if exclude:

        kwargs[b'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():

        kwargs[b'known'] = [

            hex(ctx.node())

            for ctx in repo.set(b'::%ln', pullop.common)

            if ctx.node() != repo.nullid

        ]

        if not kwargs[b'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[b'known']

extensions.wrapfunction(

    exchange, '_pullbundle2extraprepare', pullbundle2extraprepare

)

def _narrow(

    ui,

    repo,

    remote,

    commoninc,

    oldincludes,

    oldexcludes,

    newincludes,

    newexcludes,

    force,

    backup,

):

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

    outgoing = discovery.findcommonoutgoing(unfi, remote, commoninc=commoninc)

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

    progress = ui.makeprogress(

        topic=_(b'changesets'),

        unit=_(b'changesets'),

        total=len(outgoing.missing) + len(outgoing.excluded),

    )

    localnodes = []

    with progress:

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

            progress.increment()

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

                localnodes.append(n)

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

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

    visibletostrip = list(

        repo.changelog.node(r) for r in (revstostrip - hiddenrevs)

    )

    if visibletostrip:

        ui.status(

            _(

                b'The following changeset(s) or their ancestors have '

                b'local changes not on the remote:\n'

            )

        )

        maxnodes = 10

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

            for n in visibletostrip:

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

        else:

            for n in visibletostrip[:maxnodes]:

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

            ui.status(

                _(b'...and %d more, use --verbose to list all\n')

                % (len(visibletostrip) - maxnodes)

            )

        if not force:

            raise error.StateError(

                _(b'local changes found'),

                hint=_(b'use --force-delete-local-changes to ignore'),

            )

    with ui.uninterruptible():

        if revstostrip:

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

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

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

                urev = max(

                    repo.revs(

                        b'(::%n) - %ln + null',

                        repo[b'.'].node(),

                        visibletostrip,

                    )

                )

                hg.clean(repo, urev)

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

            if backup:

                ui.status(_(b'moving unwanted changesets to backup\n'))

            else:

                ui.status(_(b'deleting unwanted changesets\n'))

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

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

        todelete = []

        for entry in repo.store.data_entries():

            if not entry.is_revlog:

                continue

            if entry.is_filelog:

                if not newmatch(entry.target_id):

                    for file_ in entry.files():

                        todelete.append(file_.unencoded_path)

            elif entry.is_manifestlog:

                dir = entry.target_id[:-1]

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

                include = True

                for d in dirs:

                    visit = newmatch.visitdir(d)

                    if not visit:

                        include = False

                        break

                    if visit == b'all':

                        break

                if not include:

                    for file_ in entry.files():

                        todelete.append(file_.unencoded_path)

        repo.destroying()

        with repo.transaction(b'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(_(b'deleting %s\n') % f)

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

                repo.store.markremoved(f)

            ui.status(_(b'deleting unwanted files from working copy\n'))

            with repo.dirstate.changing_parents(repo):

                narrowspec.updateworkingcopy(repo, assumeclean=True)

                narrowspec.copytoworkingcopy(repo)

        repo.destroyed()

def _widen(

    ui,

    repo,

    remote,

    commoninc,

    oldincludes,

    oldexcludes,

    newincludes,

    newexcludes,

):

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

    ellipsesremote = any(

        cap in remotecap for cap in wireprototypes.SUPPORTED_ELLIPSESCAP

    )

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

    # ellipses capabilities

    isoldellipses = (

        ellipsesremote

        and wireprototypes.ELLIPSESCAP1 in remotecap

        and wireprototypes.ELLIPSESCAP not in remotecap

    )

    def pullbundle2extraprepare_widen(orig, pullop, kwargs):

        orig(pullop, kwargs)

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

        kwargs[b'includepats'] = newincludes

        kwargs[b'excludepats'] = newexcludes

    wrappedextraprepare = extensions.wrappedfunction(

        exchange, '_pullbundle2extraprepare', pullbundle2extraprepare_widen

    )

    # 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 = {(b'devel', b'all-warnings'): False}