# Copyright (C) 2015 - Mike Edgar <adgar@google.com>

#

# This extension enables removal of file content at a given revision,

# rewriting the data/metadata of successive revisions to preserve revision log

# integrity.

"""erase file content at a given revision

The censor command instructs Mercurial to erase all content of a file at a given

revision *without updating the changeset hash.* This allows existing history to

remain valid while preventing future clones/pulls from receiving the erased

data.

Typical uses for censor are due to security or legal requirements, including::

 * Passwords, private keys, cryptographic material

 * Licensed data/code/libraries for which the license has expired

 * Personally Identifiable Information or other private data

Censored nodes can interrupt mercurial's typical operation whenever the excised

data needs to be materialized. Some commands, like ``hg cat``/``hg revert``,

simply fail when asked to produce censored data. Others, like ``hg verify`` and

``hg update``, must be capable of tolerating censored data to continue to

function in a meaningful way. Such commands only tolerate censored file

revisions if they are allowed by the "censor.policy=ignore" config option.

"""

from __future__ import absolute_import

from mercurial.i18n import _

from mercurial.node import short

from mercurial import (

    error,

    registrar,

    scmutil,

)

cmdtable = {}

command = registrar.command(cmdtable)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

@command(

    [

    ],

    helpcategory=command.CATEGORY_MAINTENANCE,

)

    with repo.wlock(), repo.lock():

        return _docensor(ui, repo, path, rev, tombstone, **opts)

    if not path:

    if not rev:

    wctx = repo[None]

    m = scmutil.match(wctx, (path,))

    if m.anypats() or len(m.files()) != 1:

    path = m.files()[0]

    flog = repo.file(path)

    if not len(flog):

    rev = scmutil.revsingle(repo, rev, rev).rev()

    try:

        ctx = repo[rev]

    except KeyError:

    try:

        fctx = ctx.filectx(path)

    except error.LookupError:

    fnode = fctx.filenode()

    heads = []

    for headnode in repo.heads():

        hc = repo[headnode]

        if path in hc and hc.filenode(path) == fnode:

            heads.append(hc)

    if heads:

        raise error.Abort(

        )

    wp = wctx.parents()

    if ctx.node() in [p.node() for p in wp]:

        raise error.Abort(

        )

    with repo.transaction(b'censor') as tr:

        flog.censorrevision(tr, fnode, tombstone=tombstone)