doc/runrst

registrar: replace "cmdtype" with an intent-based mechanism (API)

Commands perform varied actions and repositories vary in their
capabilities.

Historically, the .hg/requires file has been used to lock out clients
lacking a requirement. But this is a very heavy-handed approach and
is typically reserved for cases where the on-disk storage format
changes and we want to prevent incompatible clients from operating on
a repo.

Outside of the .hg/requires file, we tend to deal with things like
optional, extension-provided features via checking at call sites.
We'll either have checks in core or extensions will monkeypatch
functions in core disabling incompatible features, enabling new
features, etc.

Things are somewhat tolerable today. But once we introduce alternate
storage backends with varying support for repository features and
vastly different modes of behavior, the current model will quickly
grow unwieldy. For example, the implementation of the "simple store"
required a lot of hacks to deal with stripping and verify because
various parts of core assume things are implemented a certain way.
Partial clone will require new ways of modeling file data retrieval,
because we can no longer assume that all file data is already local.
In this new world, some commands might not make any sense for certain
types of repositories.

What we need is a mechanism to affect the construction of repository
(and eventually peer) instances so the requirements/capabilities
needed for the current operation can be taken into account. "Current
operation" can almost certainly be defined by a command. So it makes
sense for commands to declare their intended actions.

This commit introduces the "intents" concept on the command registrar.
"intents" captures a set of strings that declare actions that are
anticipated to be taken, requirements the repository must possess, etc.
These intents will be passed into hg.repo(), which will pass them into
localrepository, where they can be used to influence the object being
created. Some use cases for this include:

* For read-only intents, constructing a repository object that doesn't
  expose methods that can mutate the repository. Its VFS instances
  don't even allow opening a file with write access.
* For read-only intents, constructing a repository object without
  cache invalidation logic. If the repo never changes during its lifetime,
  nothing ever needs to be invalidated and we don't need to do expensive
  things like verify the changelog's hidden revisions state is accurate
  every time we access repo.changelog.
* We can automatically hide commands from `hg help` when the current
  repository doesn't provide that command. For example, an alternate
  storage backend may not support `hg commit`, so we can hide that
  command or anything else that would perform local commits.

We already kind of had an "intents" mechanism on the registrar in the
form of "cmdtype." However, it was never used. And it was limited to
a single value. We really need something that supports multiple
intents. And because intents may be defined by extensions and at this
point are advisory, I think it is best to define them in a set rather
than as separate arguments/attributes on the command.

Differential Revision: https://phab.mercurial-scm.org/D3376

#!/usr/bin/env python
#
# runrst - register custom roles and run correct writer
#
# Copyright 2010 Matt Mackall <[e-mail]> and others
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

"""usage: %s WRITER args...

where WRITER is the name of a Docutils writer such as 'html' or 'manpage'
"""

import sys
try:
    from docutils.parsers.rst import roles
    from docutils.core import publish_cmdline
    from docutils import nodes, utils
except ImportError:
    sys.stderr.write("abort: couldn't generate documentation: docutils "
                     "module is missing\n")
    sys.stderr.write("please install python-docutils or see "
                     "http://docutils.sourceforge.net/\n")
    sys.exit(-1)

def role_hg(name, rawtext, text, lineno, inliner,
            options={}, content=[]):
    text = "hg " + utils.unescape(text)
    linktext = nodes.literal(rawtext, text)
    parts = text.split()
    cmd, args = parts[1], parts[2:]
    refuri = "hg.1.html#%s" % cmd
    if cmd == 'help' and args:
        if args[0] == 'config':
            # :hg:`help config`
            refuri = "hgrc.5.html"
        elif args[0].startswith('config.'):
            # :hg:`help config.SECTION...`
            refuri = "hgrc.5.html#%s" % args[0].split('.', 2)[1]
        elif len(args) >= 2 and args[0] == '-c':
            # :hg:`help -c COMMAND ...` is equivalent to :hg:`COMMAND`
            # (mainly for :hg:`help -c config`)
            refuri = "hg.1.html#%s" % args[1]
        else:
            refuri = "hg.1.html#%s" % args[0]
    node = nodes.reference(rawtext, '', linktext,
                           refuri=refuri)
    return [node], []

roles.register_local_role("hg", role_hg)

if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.stderr.write(__doc__ % sys.argv[0])
        sys.exit(1)

    writer = sys.argv[1]
    del sys.argv[1]

    publish_cmdline(writer_name=writer)